Mem0 Eğitimi: Yapay Zekâ Uygulamaları için Kalıcı Bellek Katmanı

Sohbet botunuza vejetaryen olduğunuzu söylüyorsunuz. Ertesi gün size biftek tarifi öneriyor. Bu bir hata değil. LLM’ler böyle çalışır. Oturumlar arasında bellekleri yoktur; her konuşmayı boş bir sayfa olarak görürler.

Gündelik kullanım için bu sorun olmayabilir. Ancak gerçek kullanıcıları olan gerçek dünya uygulamaları geliştiriyorsanız, bu durumsuzluk ciddi bir probleme dönüşür. Kullanıcılarınız, yapay zekânın onları hatırlamasını bekler.

Mem0, herhangi bir LLM’e bir bellek katmanı ekleyerek bunu çözer. Kullanıcılarla ilgili bilgileri oturumlar arasında depolar, getirir ve günceller; böylece yapay zekânız zamanla gerçekten öğrenip uyum sağlayabilir.

Bu eğitimde, kullanıcı tercihlerini hatırlayan, konuşma geçmişini izleyen ve her etkileşimle daha da akıllanan kişisel bir yapay zekâ asistanı oluşturacaksınız. Projenize uygun olanı seçebilmeniz için hem bulut hem de kendi kendine barındırma kurulumlarını ele alacağız.

Daha önce kullanmadıysanız, OpenAI API’siyle çalışmayı öğrenmek için nasıl çalışılır kursunu alın.

Mem0 Nedir?

Mem0, uygulamanız ile LLM arasında konumlanan açık kaynaklı bir bellek katmanıdır. Konuşmalardan ilgili bilgileri otomatik olarak çıkarır, depolar ve gerektiğinde geri çağırır. Proje Ekim 2025’te 24 milyon dolar topladı ve OpenAI, Anthropic, Ollama veya kendi modelleriniz dâhil herhangi bir LLM sağlayıcısıyla çalışır.

Mem0 anıları üç kapsamda düzenler:

• Kullanıcı belleği: Belirli bir kişiyle yapılan tüm konuşmalar arasında kalıcıdır. Biri sabah çalışmayı tercih ettiğini söylerse, bu bilgi gelecekteki her oturumda kullanılabilir durumda kalır. 

• Oturum belleği: Tek bir konuşma içindeki bağlamı takip eder; örneğin, şu anda konuşulan tarifi. 

• Ajan belleği: Belirli bir yapay zekâ ajanı örneğine özgü bilgileri saklar. 

Bu kapsamları birleştirerek, farklı ajanların kullanıcılar hakkında bildiklerini paylaştığı (veya yalıttığı) karmaşık uygulamalar oluşturabilirsiniz.

Üç bellek kapsamı: kullanıcı, oturum ve ajan; örneklerle birlikte.

Kaputun altında, Mem0 vektör aramasını graf ilişkileri ile birleştirir. Bir konuşmayı belleğe eklediğinizde, önemli kısımları otomatik olarak çıkarır. Nelerin hatırlanması gerektiğini elle etiketlemeniz gerekmez. 

Uygulamanız bağlama ihtiyaç duyduğunda, Mem0 mevcut sorguya göre ilgili anıları getirir ve isteme enjekte eder. Bu, her isteğe tüm konuşma geçmişinizi doldurma alternatifinden daha iyidir.

Mem0’u iki şekilde çalıştırabilirsiniz:

• Platform: app.mem0.ai üzerindeki bulut tabanlı yönetilen hizmet hızlı kurulum ve bir API sunar.

• Kendi kendine barındırma: Altyapınız üzerinde tam kontrol sağlar; vektör veritabanınızı ve gömme modelinizi seçmenize imkân verir. 

Her iki seçenek de aynı Python SDK’sını kullanır; aralarında geçiş yapmak kolaydır.

Performans kazanımları gerçektir; bunu Mem0’nun araştırma makalesi gösteriyor. LOCOMO kıyaslamasında Mem0, OpenAI’nin yerleşik bellek özelliğinden %26 daha yüksek puan aldı. Ayrıca, tüm konuşma geçmişini işlemek yerine yalnızca ilgili anıları seçerek getirerek %91 daha hızlı yanıt veriyor. Tam bağlam yaklaşımlarına kıyasla belirteç kullanımı yaklaşık %90 düşüyor.

Artık Mem0’nun ne yaptığını bildiğinize göre, kuruluma geçelim.

Mem0 ile İlk Adımlar

API anahtarlarını yönetmek için python-dotenv ile birlikte paketi kurun:

pip install mem0ai python-dotenvAltyapı:

app.mem0.ai’de kaydolun ve panodan API anahtarınızı alın. Proje dizininizde bir .env dosyası oluşturun:

MEM0_API_KEY=your-api-key-hereAltyapı:

Şimdi, istemciyi API anahtarıyla başlatın:

from mem0 import MemoryClient
from dotenv import load_dotenv
import os

load_dotenv()

client = MemoryClient(api_key=os.getenv("MEM0_API_KEY"))Altyapı:

Bir anıyı depolamak için, konuşmayı OpenAI sohbet formatında aktarın. user_id parametresi, anıları belirli bir kullanıcıya kapsamlandırır:

messages = [
	{"role": "user", "content": "I'm a vegetarian and allergic to nuts."},
	{"role": "assistant", "content": "Got it! I'll remember that."}
]
client.add(messages, user_id="user123")Altyapı:

Bellek işleme arka planda gerçekleşir. add() yöntemi, Mem0 ilgili gerçekleri çıkarıp depolarken beklemede durumu ile hemen döner.

Anıları almak için, doğal dil sorgusuyla search() kullanın:

results = client.search("dietary restrictions", filters={"user_id": "user123"})Altyapı:

Yanıt, alaka puanlarıyla birlikte çıkarılmış anıları içerir:

{'results': [
	{'memory': 'User is allergic to nuts', 'user_id': 'user123', 'score': 0.66},
	{'memory': 'User is a vegetarian', 'user_id': 'user123', 'score': 0.65}
]}Altyapı:

Mem0’nun "vegetarian” ve “allergic to nuts" ifadelerini kendiliğinden iki ayrı gerçeğe böldüğüne dikkat edin. Sistem çıkarımı kendisi yapar ve arama sırasında, anlamsal benzerliğe göre en alakalı anıları döndürür.

Temelleri gördüğümüze göre, daha pratik bir şey inşa edelim.

Bir Mem0 Yapay Zekâ Ajanı Oluşturma

Temel ekleme/arama iş akışı faydalıdır, ancak gerçek uygulamalar daha fazla incelik gerektirir. Ne zaman anı depolayacağına, getireceğine ve güncelleyeceğine özerk biçimde karar veren bir öğrenme yardımcısı ajanı oluşturalım. Ajanımıza kendi başına çağırabileceği bellek araçları vermek için OpenAI Agents SDK’sını kullanacağız.

LLM’lerle ajan oluşturma konusunda yeniyseniz, kavramlara arka plan oluşturmak için LangChain ajanları oluşturma eğitimimize göz atın. Özellikle OpenAI Agents SDK’sına derinlemesine bakmak için OpenAI Agents SDK eğitimini inceleyin.

Bağımlılıkların kurulumu

OpenAI Agents SDK’yı Mem0 ile birlikte kurun:

pip install openai-agents mem0ai python-dotenvAltyapı:

.env dosyasına OpenAI API anahtarınızı ekleyin:

MEM0_API_KEY=your-mem0-key
OPENAI_API_KEY=your-openai-keyAltyapı:

Şimdi, her iki istemciyi de başlatın ve araçlara kullanıcı bilgisi geçmek için bir bağlam sınıfı oluşturun:

import os
from dataclasses import dataclass
from agents import Agent, Runner, function_tool, RunContextWrapper
from mem0 import MemoryClient
from dotenv import load_dotenv

load_dotenv()

mem0 = MemoryClient(api_key=os.getenv("MEM0_API_KEY"))

@dataclass
class UserContext:
	user_id: strAltyapı:

UserContext veri sınıfı, araçların ihtiyaç duyduğu kullanıcıya özgü verileri tutar. RunContextWrapper ise bu bağlamı, ajanın çağırdığı herhangi bir araca aktarmamıza olanak tanır.

Bellek araçlarının oluşturulması

Ajanın üç araca ihtiyacı var: arama, kaydetme ve güncelleme. Bunları ajana açığa çıkarmak için @function_tool dekoratörünü kullanıyoruz.

Öncelikle, arama aracı ilgili anıları getirir. Çıktıya bellek kimliklerini dâhil ediyoruz ki ajan güncellemeler için bunlara atıfta bulunabilsin:

@function_tool
def search_memory(ctx: RunContextWrapper[UserContext], query: str) -> str:
	"""Search through past learning history and memories."""
	memories = mem0.search(
    	query,
    	filters={"user_id": ctx.context.user_id},
    	limit=5
	)
	if memories and memories.get("results"):
    	return "\n".join([
         	f"- [ID: {m['id']}] {m['memory']}" for m in memories["results"]
     	])
 	return "No relevant memories found."Altyapı:

Ardından, kaydetme aracı yeni bilgileri depolar:

@function_tool
def save_memory(ctx: RunContextWrapper[UserContext], content: str) -> str:
 	"""Save new information about the user's learning journey."""
 	mem0.add(
     	[{"role": "user", "content": content}],
     	user_id=ctx.context.user_id
 	)
 	return "Memory saved successfully."Altyapı:

Son olarak, güncelleme aracı bilgi değiştiğinde mevcut anıları değiştirir:

@function_tool
def update_memory(ctx: RunContextWrapper[UserContext], memory_id: str, new_text: str) -> str:
 	"""Update an existing memory with new information."""
 	mem0.update(memory_id=memory_id, text=new_text)
 	return f"Memory {memory_id} updated."Altyapı:

Ajanın tanımlanması

Şimdi, her aracın ne zaman kullanılacağına dair talimatlarla ajanı oluşturalım:

agent = Agent(
 	name="Learning Companion",
 	instructions="""You are a helpful learning companion with memory. 
            Use search_memory to recall what the user is learning and their level.
            Search results include memory IDs in format [ID: xxx].
            Use save_memory to store new topics, preferences, or progress.
            Use update_memory when information changes. First search to find the memory ID, then call update_memory with that ID and the new text.
            Always check memory before responding to personalize your answers.""",
 	tools=[search_memory, save_memory, update_memory],
 	model="gpt-4o"
)Altyapı:

gpt-4o kullanıyoruz; ancak araç kullanımı akıl yürütme yeteneği için GPT-5’i öneririm. Yeni özelliklerini iş başında görmek için GPT-5 API eğitimimize göz atın.

Ajanın çalıştırılması

Sohbet işlevi, kullanıcı bağlamını ajana geçirir:

def chat(user_input: str, user_id: str) -> str:
	result = Runner.run_sync(
     	agent,
     	user_input,
         context=UserContext(user_id=user_id)
	)
	return result.final_outputAltyapı:

Runner.run_sync()’e yapılan her çağrı, diğer tüm çağrılardan tamamen bağımsızdır. OpenAI Agents SDK, varsayılan olarak çağrılar arasında konuşma geçmişini tutmaz. 

Bu, demomuz için kasıtlıdır: Ajan çağrılar arasında kullanıcı bilgisini hatırlıyorsa, bu bellek gizli bir ajan durumundan değil, Mem0’dan gelmelidir.

Bellek kalıcılığını test etme

Gerçek bellek geri çağırımı gerektiren sorgularla test edelim. Ajan, depolanmış bilgilere erişmeden doğru tahmin yapamaz.

Önce bazı kullanıcı bilgilerini depolayın:

response = chat(
	"My name is Alex. I am learning data visualization with matplotlib. "
	"I am at intermediate level.",
	"student_01"
)
print(response)Altyapı:

Got it, Alex! You're learning data visualization with Matplotlib at an intermediate level. How can I assist you today?Altyapı:

Asenkron işlem için birkaç saniye bekledikten sonra, geri çağırmayı test edin:

response = chat("What is my name and what library am I learning?", "student_01")
print(response)Altyapı:

Your name is Alex, and you're learning data visualization using Matplotlib at an intermediate level.Altyapı:

Şimdi, güncelleme işlevini test edin:

response = chat(
	"I switched from matplotlib to seaborn. Please update your memory.",
	"student_01"
)
print(response)Altyapı:

Got it! I've updated your learning preference to Seaborn for data visualization at an intermediate level. If you need help with anything specific, just let me know!Altyapı:

Güncellemenin çalıştığını doğrulayın:

response = chat("What visualization library am I using now?", "student_01")
print(response)Altyapı:

You are currently using Seaborn for data visualization at an intermediate level.Altyapı:

Son olarak, konuşmalar arasında kalıcılığı test edin:

response = chat("Give me a summary of everything you know about me.", "student_01")
print(response)Altyapı:

Here's what I know about you:

- Your name is Alex.
- You are learning data visualization with Seaborn at an intermediate level.

Is there anything else you'd like to update or add?Altyapı:

Mem0 ajanımız nasıl çalışıyor

Ajan, konuşmaya göre hangi aracı çağıracağına karar verir. 

Kullanıcı profilini sorduğunda search_memory’i çağırır. Yeni bilgi paylaştığında save_memory’yi çağırır. Bilginin değiştiğini söylediğinde önce bellek kimliğini bulmak için arar, sonra update_memory’yi çağırır. 

Hangi mesaj için hangi aracı kullanacağını ona açıkça söylemiyoruz.

Bu, 3. Bölümdeki manuel ekleme/arama iş akışından farklıdır. Orada yöntemleri açıkça çağırıyorduk. Burada ise bu kararları ajan veriyor. Bu desen, her etkileşim türünü öngöremeyeceğiniz karmaşık uygulamalar için daha iyi ölçeklenir.

Ölçeklenebilirlik için manuel ve ajana dayalı iş akışlarının karşılaştırması

Önemli bir not: bellek işleme asenkrondur. Şunu çağırdıktan sonra save_memory, yeni anının aranabilir hâle gelmesi için kısa bir gecikme olur. Üretimde, kullanıcı arayüzünüzde bunu hesaba katmak istersiniz.

Mem0’nun Davranışını İnce Ayarlama

Temel ajan bellek işlemlerini halleder, ancak üretim uygulamaları neyin depolandığı ve nasıl getirildiği üzerinde daha ince kontrol ister. Mem0, bellek kalitesini artıran proje düzeyi ayarlar sunar; bunlar arasında düzenleme için özel kategoriler, filtreleme için kullanıcı tanımlı talimatlar, hedefli aramalar ve temizleme işlemleri bulunur.

Öğrenme alanları için özel kategoriler

Varsayılan olarak Mem0, yiyecek, seyahat ve hobiler gibi genel kategoriler kullanır. Öğrenme yardımcımız gibi belirli uygulamalar için bunlar pek işe yaramaz. Kendi kategorilerinizi tanımlayabilir ve alanınıza uyarlayabilirsiniz:

client.project.update(custom_categories=[
	{"name": "topics", "description": "Programming languages, frameworks, or subjects"},
	{"name": "skill_levels", "description": "Proficiency: beginner, intermediate, advanced"},
	{"name": "goals", "description": "Learning objectives and targets"},
	{"name": "progress", "description": "Completed courses, chapters, or milestones"},
	{"name": "preferences", "description": "Learning style, schedule, or format preferences"}
])Altyapı:

Ayarlandıktan sonra, Mem0’nun sınıflandırıcısı gelen anıları otomatik olarak sizin kategorilerinizle etiketler. Alex, "Python’u başlangıç seviyesinde öğreniyorum" dediğinde, sistem bunu hem topics hem de skill_levels ile etiketler. Ajan kodunuzu değiştirmenize gerek yoktur. Kategorizasyon, bellek çıkarımı sırasında gerçekleşir.

Seçici bellek için özel talimatlar

Özel talimatlar konuşmalardan tam olarak nelerin çıkarılacağını kontrol etmenizi sağlar. Doğal dilde yönergeler yazarsınız ve Mem0 yeni anıları işlerken bunları izler:

client.project.update(custom_instructions="""
Extract and remember:
- Programming topics and technologies mentioned
- Current skill level for each topic
- Learning goals and deadlines
- Progress updates and completions
- Preferred learning resources (videos, docs, exercises)

Do not store:
- Personal identifiers beyond the user_id
- Payment or financial information
- Off-topic conversation that isn't about learning
""")Altyapı:

Bu, üretim uygulamaları için önemlidir. Talimatlar olmadan, Mem0 alakasız ayrıntıları veya hassas bilgileri depolayabilir. Özel talimatlar bir filtre görevi görerek anıları, uygulamanızın gerçekten ihtiyaç duyduğu konulara odaklı tutar. GDPR gibi uyumluluk senaryolarında, kişisel veri kategorilerini açıkça hariç tutabilirsiniz.

Kategoriye göre filtrelenmiş aramalar

Kategorize edilmiş anılarla, arama aracınız daha isabetli olabilir. Tüm anılar arasında arama yapmak yerine, tam olarak ihtiyacınız olanı elde etmek için kategoriye göre filtreleyin:

@function_tool
def search_memory(
	ctx: RunContextWrapper[UserContext],
	query: str,
	category: str = None
) -> str:
	"""Search learning history. Optionally filter by category."""
	filters = {"user_id": ctx.context.user_id}
	if category:
    	filters["categories"] = {"contains": category}

	memories = mem0.search(query, filters=filters, limit=5)
	if memories and memories.get("results"):
    	return "\n".join([
        	f"- [ID: {m['id']}] {m['memory']}" for m in memories["results"]
     	])
	return "No relevant memories found."Altyapı:

Ajan, "Hangi konuları öğrendim?" sorusunu yanıtlaması gerektiğinde, category="topics" ile arama yapabilir ve tercihler veya hedeflerle ilgili alakasız anıları atlayabilir. Ajan talimatları bu kategorilerden bahsetmelidir ki ne zaman filtreli arama kullanacağını bilsin.

Bellek temizliği ve silme

Kullanıcılar, güncelliğini yitirmiş veya hatalı anıları kaldırmak isteyebilir. Ajana bu yeteneği sağlamak için bir silme aracı ekleyin:

@function_tool
def delete_memory(ctx: RunContextWrapper[UserContext], memory_id: str) -> str:
	"""Delete a specific memory by ID."""
	mem0.delete(memory_id=memory_id)
	return f"Memory {memory_id} deleted."Altyapı:

Toplu işlemler için, bir kullanıcının tüm anılarını doğrudan temizleyebilirsiniz:

mem0.delete_all(user_id="student_01")Altyapı:

Silme, bilginin tamamen değiştiği durumlarda güncellemeye kıyasla daha kullanışlıdır. Bir kullanıcı "Python öğrenmemle ilgili her şeyi unut" derse, ajan ilgili anıları arayıp tek tek silebilir veya profilini tamamen temizleyen bir sıfırlama seçeneği sunabilirsiniz.

Bu dört yapılandırma seçeneği, ajanı bir demodan, dağıtıma hazır bir şeye taşır. Kategoriler anıları otomatik olarak düzenler, talimatlar yalnızca ilgili bilgilerin depolanmasını sağlar, filtreli aramalar tam olarak gerekeni getirir ve silme temizlik işini halleder. Ajan kodundaki değişiklikler minimum düzeydedir; zira bunların çoğu proje yapılandırması seviyesinde gerçekleşir.

Bu özellikler hakkında daha fazla ayrıntı için resmi Mem0 belgelerine bakın.

Graf Bellekle İlişkileri Takip Etme

Standart bellek, "Alex Seaborn öğreniyor" ve "Alex matplotlib biliyor" gibi yalıtılmış gerçekleri saklar. Ancak Alex’in önce matplotlib öğrendiğini, ardından Seaborn’a geçtiğini yakalamaz. Graf bellek bu ilişki katmanını ekler. Sıra, ilerleme veya varlıklar arasındaki bağlantılar önemli olduğunda, graf bellek ajanınıza daha zengin bir bağlam sunar.

Not: Graf bellek yalnızca Pro planla (aylık 249 $) veya üzeri planlarda mevcuttur.

Graf belleği açma

Graf belleği proje düzeyinde etkinleştirilebilir:

client.project.update(enable_graph=True)Altyapı:

Bir diğer seçenek, tekil isteklere enable_graph=True parametresi geçmektir:

client.add(messages, user_id="student_01", enable_graph=True)Altyapı:

Etkinleştirildiğinde, Mem0 doğal konuşmadan varlıkları (kişiler, konular, araçlar, tarihler) ve aralarındaki ilişkileri otomatik olarak çıkarır.

Graf arama nasıl çalışır

Graf bellekle arama yaptığınızda, Mem0 hem anıları hem de varlıkların nasıl bağlandığını gösteren bir relations dizisi döndürür:

results = client.search(
	"What has Alex learned?",
	filters={"user_id": "student_01"},
	enable_graph=True
)

# Results include both memories and relations
print(results.get("relations"))Altyapı:

İlişkiler, "Alex → learned → matplotlib" ve "Alex → switched to → seaborn" gibi bağlantıları gösterir. Artık bu ilişkileri açıkça depolamak zorunda kalmadan, ajanınız ilerlemeyle ilgili soruları yanıtlayabilir.

Graf bellek ne zaman kullanılmalı

Graf bellek ek işlem yükü getirir; bu nedenle ilişkiler önemli olduğunda kullanın:

• Yetenek ilerlemesini izleyen öğrenme platformları

• Etkileşim geçmişini analiz eden müşteri destek sistemleri

• Görev bağımlılıklarını haritalayan proje yönetimi

• Belirtileri ve tedavileri zaman içinde ilişkilendiren sağlık hizmetleri

Basit gerçek geri çağırımı için standart bellek daha hızlıdır. Ajanınızın depolanmış bilgiler arasındaki sıralamalar veya bağlantılar hakkında akıl yürütmesi gerektiğinde graf belleği açın.

Mem0: Platform vs. Açık Kaynak

Mem0 iki sürüm hâlinde gelir: Platform ve açık kaynak. 

Bu eğitim boyunca, Platform sürümünü kullandık; bu, MemoryClient ve app.mem0.ai’den alınan bir API anahtarı ile erişilen yönetilen bulut hizmetidir. Her iki sürüm de temel bellek işlemlerini (add(), search(), update(), delete()) paylaşır; ancak kurulum, fiyatlandırma ve kontrol açısından farklılaşırlar.

Platform

Platform, Mem0’nun barındırılan hizmetidir. Kaydolursunuz, bir API anahtarı alırsınız ve dakikalar içinde anı eklemeye başlarsınız. Mem0, altyapı, ölçekleme ve güvenlik sertifikasyonlarını (SOC 2 Type II veya GDPR gibi) üstlenir.

Dört fiyatlandırma katmanı vardır:

• Ücretsiz: 10.000 anı; prototipleme için uygundur.

• Starter: Aylık 19 $; daha yüksek limitlerle.

• Pro: Aylık 249 $; üretim iş yükleri için.

• Kurumsal: Adanmış destekle özel fiyatlandırma.

Platform, açık kaynakta bulunmayan özellikler içerir: ilişki takibi için graf bellek, gerçek zamanlı bildirimler için web kancaları, konuşmacı atamasıyla grup sohbeti ve yerleşik analizler. 

Kullanıma göre ödeme yaparsınız; ancak altyapı ve DevOps süresinden tasarruf edersiniz.

Açık kaynak

Açık kaynak sürümü kendi sunucularınızda çalışır. mem0ai paketini kurar, vektör veritabanınızı yapılandırır ve dağıtımı kendiniz yönetirsiniz. Bu daha fazla kurulum gerektirir; ancak size tam kontrol sağlar.

Altyapı için çeşitli seçenekler mevcuttur:

• Vektör veritabanları: Qdrant, Chroma, Pinecone, PostgreSQL (pgvector) ve MongoDB dâhil 24+ seçenek

• LLM sağlayıcıları: OpenAI, Anthropic, Ollama, Groq ve yerel modeller dâhil 16+ seçenek

• Gömme modelleri: OpenAI, HuggingFace veya özel gömmeleyiciler

Açık kaynak, Memory sınıfını MemoryClient yerine kullanır. 

Maliyetleriniz, altyapı için ödedikleriniz (bulut VM’leri, veritabanı barındırma, LLM sağlayıcılarına yapılan API çağrıları) kadardır. Ölçekte bu, Platform fiyatlandırmasından daha ucuz olabilir; ancak bakım, yedekleme ve uyumluluktan siz sorumlusunuz.

Ne zaman Platform, ne zaman açık kaynak?

Aşağıdaki tablo, Mem0’nun barındırılan ve açık kaynak sürümleri arasındaki karşılaştırmayı sunar:

Önerim; hızlı prototipleme, DevOps yükü olmadan üretim uygulamaları veya yerleşik uyumluluğa ihtiyaç duyduğunuz durumlar için Platformu seçmeniz yönünde. 

Odağınız veri egemenliği, özel model yapılandırmaları veya yüksek hacimde maliyet optimizasyonu ise, doğru seçim açık kaynaktır.

Ayrıntılı kurulum kılavuzları için Platform hızlı başlangıç veya açık kaynak genel bakış sayfasına bakın.

Sonuç

Bu eğitimde, Mem0 ile LLM uygulamalarına kalıcı bellek eklemeyi ele aldık. Temel bellek işlemleriyle başladınız; ardından OpenAI Agents SDK’yı kullanarak belleğini özerk biçimde yöneten bir öğrenme yardımcısı ajanı oluşturdunuz. Sonrasında, özel kategoriler, talimatlar ve filtreli aramalarla bellek davranışını yapılandırdınız. Son olarak, Platform ve açık kaynak dağıtım seçeneklerini karşılaştırdınız.

Üretim kullanımı için, bellek işlemleri etrafına hata ele alma ekleyin ve yeni anılar kaydedildikten sonra kısa gecikmeleri hesaba katın. Platform ücretsiz katmanındaysanız oran sınırlamalarını göz önünde bulundurun.

Bireysel bileşenlerin ötesine geçip yapay zekâ uygulama geliştirmenin tüm yığınında uzmanlaşmaya hazır mısınız? Kayıt olun: Geliştiriciler için Yapay Zekâ Mühendisi kariyer programı.