Yapay zeka ajanlarıyla çalışırken en sık karşılaşılan sorunlardan biri “hafıza eksikliği” problemidir. Bir sohbet robotuyla (chatbot) konuştuğunuzu düşünün: ona adınızı söylüyorsunuz, birkaç mesaj sonra “Adın neydi?” diye sorduğunuzda ise hiçbir fikri olmuyor. Bunu sorunu ChatGPT, Gemini, Claude ile pek yaşamamışsınızdır. Peki o zaman bunun neden tartışıyoruz. Şunun için; bunlar milyar dolarlık bebekler ve sizin müşterileriniz (iç veya dış müşteri farketmez) bu milyar dolarlık bebekleri kullanmaya ve onların sunduğu konfora alıştılar. Siz de kendi şirketinizde veya bir müşterinize bir sohbet robotu yapmaya kalktığınızda daha önceki sohbetleri ve kullanıcı tercihlerini hatırlayamazsanız geçmiş olsun. Çünkü ChatGPT arayüzünü kullanmayıp API anahtarıyla istek göndermeye başladığınızda istekleriniz stateless olacak. OpenAI’yı bağlamaz sizin probleminiz.
Bu yüzden bu yazıda, LangChain bu hazıfa sorununu nasıl çözüyor ve kısa süreli bellek (short-term memory) ve uzun süreli bellek (long-term memory) ne demek inceleyeceğiz.

Bellek Neden Bu Kadar Önemli?

Büyük Dil Modelleri (Large Language Models – LLM’ler) kendi başlarına durumsuz (stateless) yapılardır [1]. Yani her sorgunuzda, ChatGPT’de alıştığınızın aksine, önceki konuşmalarınızı hatırlamazlar. Bu durum, doğal ve akıcı bir kullanıcı deneyimi için bir engel oluşturur.

Düşünün biriyle her konuşmanızda söylediklerinizi unutuyor ve siz de sürekli aynı bilgileri tekrar etmek zorunda kalıyorsunuz. Sinir bozucu bir durum! İnsanlar genellikle LLM sistemlerinin doğuştan bir belleğe sahip olduğunu varsayar çünkü bu sistemler zaten çok insani bir şekilde iletişim kurabiliyor veya ChatGPT, Gemini vb. kullanım alışkanlıkları böyle düşündürüyor [2]. Ancak gerçek şu ki, LLM’ler kendileri doğuştan bir şey hatırlamaz — bu yüzden kasıtlı olarak bellek eklememiz gerekiyor.

LangChain ekibi, müşterilerle birlikte ajanlarına bellek ekleme üzerine çalışırken önemli bir şey fark etmiş: yapay zeka belleği için evrensel olarak mükemmel bir çözüm yok [3]. Her uygulama için en iyi bellek, uygulamaya özel mantık içeriyor. Bu içgörü, LangChain’in bellek desteğini basit bir belge deposu (document store) olarak inşa etmesinin nedenini açıklıyor.

Kısa Süreli Bellek (Short-Term Memory) Nedir?

Kısa süreli bellek, uygulamanızın tek bir oturum veya konuşma içindeki önceki etkileşimleri hatırlamasını sağlar [4]. Buna aslında alışkınız. ChatGPT’de yeni bir chat açarsanız temiz bir hafıza, önceki sohbetlerden birini açarsanız daha önceki soru ve cevapları göz önüne alır.

LangChain’de kısa süreli bellek, bir thread kapsamında yönetilir. Thread, bir oturumda birden fazla etkileşimi organize eder — tıpkı e-postanın mesajları tek bir konuşmada gruplandırması gibi [4].

Kısa Süreli Bellek Nasıl Çalışır?

LangChain’de kısa süreli bellek, ajanın durumunun (state) bir parçası olarak yönetilir ve kontrol noktası kaydedici (checkpointer) kullanılarak kalıcı hale getirilir [5]. Checkpointer, graf durumunun (ajanlarda geri planda langgraph çalışır, buradaki graf bu) anlık görüntüsünü (snapshot) her süper adımda (superstep) kaydeder.

İşte temel bir örnek:

from langchain.agents import create_agent
from langgraph.checkpoint.memory import InMemorySaver

agent = create_agent(
    "gpt-5",
    [get_user_info],
    checkpointer=InMemorySaver(),
)

agent.invoke(
    {"messages": [{"role": "user", "content": "Merhaba! Benim adım Ahmet."}]},
    {"configurable": {"thread_id": "1"}},
)

Burada dikkat edilmesi gereken birkaç önemli nokta var:

1. InMemorySaver: Belleği RAM’de tutan basit bir checkpointer
2. thread_id: Her konuşma oturumu için benzersiz bir tanımlayıcı
3. messages: Konuşma geçmişini tutan mesaj listesi

Üretim Ortamında Kısa Süreli Bellek

Geliştirme aşamasında InMemorySaver yeterli olsa da, canlı ortamlarda veritabanı destekli bir kontrol noktası kaydedici kullanmanız gerekir [6]. PostgreSQL gibi güvenilir bir veritabanı tercih edilebilir:

from langgraph.checkpoint.postgres import PostgresSaver

DB_URI = "postgresql://postgres:postgres@localhost:5442/postgres"

with PostgresSaver.from_conn_string(DB_URI) as checkpointer:
    checkpointer.setup()
    agent = create_agent(
        "gpt-5",
        [get_user_info],
        checkpointer=checkpointer,
    )

Bağlam Penceresi (Context Window) Sorunu

Uzun konuşmalar, günümüz LLM’leri için ciddi bir zorluk oluşturur. Tam bir sohbet geçmişi, LLM’in bağlam penceresine sığmayabilir ve bu da bağlam kaybına veya hatalara neden olur [4]. Yani düşünün bazen bir kodun yüzlerce satır hatasını yapıştırıp cevap bekliyoruz, bağlam penceresi çabucak dolacaktır. Ayrıca model geniş bağlam penceresine sahip olsa bile, çoğu LLM uzun bağlamlarda hâlâ zayıf performans gösterir — eski veya konu dışı içerikle “dikkatlerini dağıtır”, daha yavaş yanıt süreleri ve daha yüksek maliyetlerle (çok token yakar 🙂 ) karşılaşırlar.

Bu sorunu çözmek için LangChain birkaç strateji sunar:

1. Mesaj Kırpma (Message Trimming)

Mesaj geçmişini belirli bir token/mesaj sayısına göre kırpabilirsiniz:

from langchain.agents.middleware import before_model

@before_model
def trim_messages(state: AgentState, runtime: Runtime):
    messages = state["messages"]
    if len(messages) <= 3:
        return None
    
    first_msg = messages[0]
    recent_messages = messages[-3:]
    new_messages = [first_msg] + recent_messages
    
    return {"messages": [RemoveMessage(id=REMOVE_ALL_MESSAGES), *new_messages]}

2. Mesaj Özetleme (Message Summarization)

Mesajları kırpmak veya silmek, bilgi kaybına neden olabilir. Bu nedenle bazı uygulamalar, mesaj geçmişini bir sohbet modeli kullanarak özetlemekten fayda görür [7]:

from langchain.agents.middleware import SummarizationMiddleware

agent = create_agent(
    model="gpt-4o",
    tools=[],
    middleware=[
        SummarizationMiddleware(
            model="gpt-4o-mini",
            max_tokens_before_summary=4000,
            messages_to_keep=20,
        )
    ],
    checkpointer=checkpointer,
)

Bu yaklaşım, özetleme eşiğine ulaşıldığında otomatik olarak eski mesajları özetleyerek bağlam penceresini verimli kullanır. Bence güzel bir yöntem bu özetleme. Bir çok vibe coding aracı kullanıyor.

Uzun Süreli Bellek (Long-Term Memory) Nedir?

Kısa süreli bellek tek bir konuşma oturumunu kapsarken, uzun süreli bellek farklı konuşmalar veya oturumlar arasında bilgi saklamanızı sağlar [8]. Bu, ajanınızın geri bildirimlerden öğrenmesine ve kullanıcı tercihlerine uyum sağlamasına olanak tanır.

Uzun süreli bellek, özel “ad alanları” (namespaces) içinde saklanır ve thread kapsamlı olan kısa süreli bellekten farklı olarak daha esnek bir yapıya sahiptir [9].

İnsan Belleğinden Esinlenen Bellek Türleri

LangChain’in uzun süreli bellek yaklaşımı, insan bellek yapısından esinlenmiştir. Üç ana bellek türü vardır:

1. Anlamsal Bellek (Semantic Memory)

Anlamsal bellek, bir ajanın yanıtlarını temellendiren temel gerçekleri ve diğer bilgileri depolar [10]. Bu, modelin kendisinin “önceden eğitilmediği” ve web araması veya genel bir alıcıdan erişilemeyecek önemli ayrıntıları hatırlamanızı sağlar.

Örneğin, bir kullanıcı hakkında şu bilgileri saklayabilirsiniz:

• Tercih ettiği programlama dili
• Çalıştığı şirket
• İlgi alanları ve hobiler

from langgraph.store.memory import InMemoryStore

store = InMemoryStore()

store.put(
    ("users",),  # Namespace
    "user_123",  # Key
    {
        "name": "Ahmet Yılmaz",
        "language": "Turkish",
        "preferences": {"theme": "dark"}
    }
)

2. Epizodik Bellek (Episodic Memory)

Epizodik bellek, başarılı etkileşimleri öğrenme örnekleri olarak korur ve gelecekteki davranışlara rehberlik eder [10]. Gerçekleri depolayan anlamsal bellekten farklı olarak, epizodik bellek bir etkileşimin tam bağlamını yakalar — durumu, başarıya götüren düşünce sürecini ve bu yaklaşımın neden işe yaradığını.

Pratikte, epizodik bellekler genellikle az örnekli (few-shot) örnek istemi şeklinde uygulanır. Her örnek, daha uzun bir ham etkileşimden damıtılır [11].

3. Prosedürel Bellek (Procedural Memory)

Prosedürel bellek, tekrarlayan görevler için talimatları veya kuralları kaydeder [12]. CoALA makalesine göre, prosedürel bellek LLM ağırlıklarının ve ajan kodunun kombinasyonu olarak tanımlanır ve temelde ajanın nasıl çalıştığını belirler.

Uzun Süreli Bellek Nasıl Uygulanır?

LangChain, uzun süreli bellek için BaseStore arayüzünü (interface) kullanır. İşte temel bir uygulama:

from langgraph.store.memory import InMemoryStore
from langchain.tools import tool, ToolRuntime

store = InMemoryStore(
    index={
        "dims": 1536,
        "embed": "openai:text-embedding-3-small",
    }
)

@tool
def get_user_info(runtime: ToolRuntime) -> str:
    """Kullanıcı bilgilerini ara."""
    store = runtime.store
    user_id = runtime.context.user_id
    user_info = store.get(("users",), user_id)
    return str(user_info.value) if user_info else "Bilinmeyen kullanıcı"

Anlamsal Arama (Semantic Search)

LangChain’in BaseStore’una anlamsal arama eklendi [13]. Bu özellik, ajanların belleği tam eşleşmeler yerine anlama dayalı olarak bulmasını sağlar — böylece konuşmalar arasında doğru bilgiyi yüzeye çıkarmak kolaylaşır.

from langgraph.store.postgres import PostgresStore

store = PostgresStore(
    connection_string="postgresql://user:pass@localhost:5432/dbname",
    index={
        "dims": 1536,
        "embed": init_embeddings("openai:text-embedding-3-small"),
        "fields": ["text"],
    },
)

results = store.search(
    ("user_123", "interactions"),
    query="karanlık mod tercihi",
    filter={"type": "preference"},
    limit=3
)

Kısa Süreli ve Uzun Süreli Bellek Arasındaki Farklar

İki bellek türü arasındaki temel farkları bir tabloda özetleyelim:

Bellek Güncelleme Stratejileri

Belleği güncellemek için iki ana yaklaşım vardır [14]:

1. Sıcak Yol (Hot Path)

Ajan sistemi, yanıt vermeden önce gerçekleri hatırlamaya açıkça karar verir (genellikle araç çağrısı yoluyla). ChatGPT bu yaklaşımı kullanır.

from langmem import create_manage_memory_tool, create_search_memory_tool

agent = create_react_agent(
    "anthropic:claude-3-5-sonnet-latest",
    tools=[
        create_manage_memory_tool(namespace=("memories",)),
        create_search_memory_tool(namespace=("memories",)),
    ],
    store=store,
)

2. Arka Plan (Background)

Belleği güncellemek için konuşma sırasında veya sonrasında bir arka plan işlemi çalışır [15]. Bu yaklaşım, kullanıcı deneyimini kesintiye uğratmadan bellek yönetimi sağlar.

LangMem SDK

LangChain ekibi, uzun süreli bellek yönetimi için LangMem SDK’sını geliştirmiştir [16]. Bu kütüphane, ajanlarınızın uzun süreli bellek aracılığıyla öğrenmesine ve gelişmesine yardımcı olan araçlar sağlar.

LangMem’in temel özellikleri:

• Her depolama sistemiyle çalışan çekirdek bellek API’si
• Aktif konuşmalar sırasında bilgi kaydetme ve arama araçları
• Ajan bilgisini otomatik olarak çıkaran, birleştiren ve güncelleyen arka plan bellek yöneticisi
• LangGraph’ın Uzun Süreli Bellek Deposu ile yerel entegrasyon

Kullanım Senaryoları (Use Cases)

Kısa Süreli Bellek İçin Kullanım Senaryoları

1. Müşteri Destek Sohbet Robotları

Müşteri destek sistemlerinde, kısa süreli bellek mevcut sohbet oturumu boyunca bağlamı korumak için kritik öneme sahiptir [17]. Kullanıcı bir sorun bildirdiğinde, takip sorularında aynı bilgileri tekrar etmek zorunda kalmaz.

# Örnek: Müşteri destek botu
agent = create_agent(
    model="gpt-4o",
    tools=[get_order_status, create_ticket, search_faq],
    checkpointer=PostgresSaver.from_conn_string(DB_URI),
    system_prompt="""
    Sen yardımcı bir müşteri destek asistanısın.
    Müşterinin önceki mesajlarındaki bağlamı kullan.
    """
)

2. Teknik Asistanlar

Kod yazma veya hata ayıklama konusunda yardımcı olan teknik asistanlar için kısa süreli bellek, kullanıcının üzerinde çalıştığı projeyi, karşılaştığı hataları ve tercih ettiği çözümleri takip eder.

3. Eğitim Tutorları

Öğrencilerle etkileşime giren eğitim botları, bir ders oturumu boyunca öğrencinin ilerlemesini, zorlandığı konuları ve başarılı olduğu alanları izleyebilir.

Uzun Süreli Bellek İçin Kullanım Senaryoları

1. Kişisel Asistanlar

Kişisel asistanlar, kullanıcı tercihlerini oturumlar arasında hatırlayarak daha kişiselleştirilmiş bir deneyim sunar [18]:

# Kişisel asistan örneği
@tool
def remember_preference(
    preference_type: str,
    value: str,
    runtime: ToolRuntime
) -> str:
    """Kullanıcı tercihini kaydet."""
    store = runtime.store
    user_id = runtime.context.user_id
    
    current_prefs = store.get(("preferences",), user_id)
    prefs = current_prefs.value if current_prefs else {}
    prefs[preference_type] = value
    
    store.put(("preferences",), user_id, prefs)
    return f"{preference_type} tercihi kaydedildi."

2. E-posta Ajanları

DeepLearning.AI’ın LangGraph ile uzun süreli bellek kursunda, gelen e-postaları otomatik olarak yoksayabilen, yanıtlayabilen veya bildirim gönderebilen kişisel e-posta ajanları örnek olarak gösterilmiştir [19]. Bu ajanlar:

• Kullanıcı hakkında gerçekleri öğrenir (anlamsal bellek)
• Kullanıcı tercihlerini örneklerle öğrenir (epizodik bellek)
• Sistem istemlerini geri bildirimlere göre optimize eder (prosedürel bellek)

3. Sağlık ve Wellness Uygulamaları

Uzun süreli bellek, sağlık uygulamalarında kullanıcının tıbbi geçmişini, ilaç alerjilerini ve yaşam tarzı tercihlerini takip etmek için kullanılabilir. Bu bilgiler, her oturumda daha bilinçli ve kişiselleştirilmiş tavsiyeler sunmayı mümkün kılar.

4. Eğitim Platformları

EdTech uygulamalarında uzun süreli bellek, öğrencinin öğrenme yolculuğunu, güçlü ve zayıf yönlerini, tercih ettiği öğrenme stilini takip ederek adaptif öğrenme deneyimleri sunar [17].

MongoDB ile Üretim Ortamı Entegrasyonu

MongoDB, LangGraph için yeni bir depo (store) entegrasyonu sunmuştur [20]. Bu entegrasyon, esnek ve ölçeklenebilir uzun süreli bellek sağlayarak yapay zeka ajanlarının önceki etkileşimleri hatırlamasına ve çoklu oturumlar arasında bunları geliştirmesine olanak tanır.

from langgraph.store.mongodb import MongoDBStore

store = MongoDBStore(
    connection_string="mongodb://localhost:27017",
    database="agent_memory",
    collection="memories",
    index_config={
        "dims": 1536,
        "embed": "openai:text-embedding-3-small",
    }
)

Üretim Ortamı İçin Veritabanı Alternatifleri

PostgreSQL ve MongoDB dışında, LangChain/LangGraph ile üretim ortamlarında kullanabileceğiniz birçok veritabanı alternatifi bulunuyor. Her birinin kendine özgü avantajları var. Şimdi bunları inceleyelim:

1. Redis

Redis, bellek içi (in-memory) veri yapısı deposu olarak, özellikle yüksek performans gerektiren uygulamalar için mükemmel bir seçenektir [23]. LangGraph için resmi olarak desteklenen langgraph-checkpoint-redis paketi hem kısa süreli hem de uzun süreli bellek için kullanılabilir.

Avantajları:

• Milisaniyenin altında yanıt süreleri
• Hem checkpointer hem de store desteği
• Vektör arama yetenekleri (RedisStore ile)
• Azure Cache for Redis ve Redis Enterprise ile uyumlu

# Kurulum: pip install langgraph-checkpoint-redis

from langgraph.checkpoint.redis import RedisSaver

# Kısa süreli bellek için
with RedisSaver.from_conn_string("redis://localhost:6379") as checkpointer:
    checkpointer.setup()  # İndeksleri oluştur
    
    agent = create_agent(
        model="gpt-4o",
        tools=[get_user_info],
        checkpointer=checkpointer,
    )

Uzun süreli bellek için RedisStore kullanabilirsiniz [24]:

from langgraph.store.redis import RedisStore

# Uzun süreli bellek için
store = RedisStore.from_conn_string(
    "redis://localhost:6379",
    index={
        "dims": 1536,
        "embed": "openai:text-embedding-3-small",
    }
)

2. SQLite

SQLite, yerel geliştirme ve hafif üretim ortamları için ideal bir seçenektir [25]. Dosya tabanlı yapısı sayesinde harici bir veritabanı sunucusuna ihtiyaç duymaz.

Avantajları:

• Sıfır konfigürasyon gerektirir
• Taşınabilir ve hafif
• Yerel geliştirme için mükemmel
• Küçük ve orta ölçekli uygulamalar için yeterli

# Kurulum: pip install langgraph-checkpoint-sqlite

from langgraph.checkpoint.sqlite import SqliteSaver
import sqlite3

# Dosya tabanlı kalıcı depolama
conn = sqlite3.connect('langchain_memory.db', check_same_thread=False)
memory = SqliteSaver(conn)

# Veya bağlantı string'i ile
with SqliteSaver.from_conn_string("checkpoints.db") as checkpointer:
    agent = create_agent(
        model="gpt-4o",
        tools=[],
        checkpointer=checkpointer,
    )

Asenkron destek için AsyncSqliteSaver kullanabilirsiniz [26]:

from langgraph.checkpoint.sqlite.aio import AsyncSqliteSaver

async with AsyncSqliteSaver.from_conn_string("checkpoints.db") as checkpointer:
    # Asenkron işlemler
    await checkpointer.aput(config, checkpoint, metadata, {})

3. Amazon DynamoDB

AWS ekosisteminde çalışıyorsanız, DynamoDB serverless mimarisi ve otomatik ölçeklendirme özellikleriyle güçlü bir seçenektir [27]. Topluluk tarafından geliştirilen checkpointer paketleri mevcuttur.

Avantajları:

• Serverless mimari (yönetim gerektirmez)
• Otomatik ölçeklendirme
• AWS Lambda ile mükemmel entegrasyon
• TTL (Time-to-Live) desteği
• Point-in-time recovery

# Kurulum: pip install langgraph-checkpoint-dynamodb

from langgraph_checkpoint_dynamodb import DynamoDBSaver

# Varsayılan ayarlarla (AWS kimlik bilgileri ortam değişkenlerinden)
checkpointer = DynamoDBSaver(deploy=True)  # Tablo yoksa oluşturur

# Özelleştirilmiş tablo adlarıyla
checkpointer = DynamoDBSaver(
    checkpoints_table_name='my-checkpoints',
    writes_table_name='my-writes',
)

graph = workflow.compile(checkpointer=checkpointer)

4. Azure Cosmos DB

Microsoft Azure kullanıcıları için Cosmos DB, global dağıtım ve çoklu model desteğiyle güçlü bir alternatiftir [28]. Topluluk tarafından geliştirilen checkpointer implementasyonları mevcuttur.

Avantajları:

• Global dağıtım
• Çoklu tutarlılık modelleri
• Azure ekosistemiyle derin entegrasyon
• Otomatik indeksleme

# Cosmos DB Checkpointer örneği
from async_checkpoint_saver import (
    AsyncCosmosDBCheckpointSaver,
    AsyncCosmosDBCheckpointSaverConfig,
)

config = AsyncCosmosDBCheckpointSaverConfig(
    URL="https://your-cosmos-account.documents.azure.com:443/",
    KEY="your-cosmos-key",
    DATABASE="langgraph-db",
    CHECKPOINTS_CONTAINER="checkpoints",
    CHECKPOINT_WRITES_CONTAINER="checkpoint_writes",
)

checkpointer = AsyncCosmosDBCheckpointSaver(config)

5. Vektör Veritabanları (Vector Databases)

Uzun süreli bellek için anlamsal arama yetenekleri kritik önem taşıyorsa, vektör veritabanları mükemmel bir seçenektir. LangChain, birçok açık kaynaklı vektör veritabanını destekler [29]. İşte en popüler üç alternatif:

5.1 Chroma

Chroma, özellikle yerel geliştirme ve hızlı prototipleme için tasarlanmış, kullanımı kolay bir vektör veritabanıdır [30]. LangChain ile mükemmel entegrasyonu sayesinde hızlıca başlayabilirsiniz.

Avantajları:

• Sıfır konfigürasyon, hızlı başlangıç
• Yerel geliştirme için ideal
• Kalıcı depolama desteği
• Metadata filtreleme

# Kurulum: pip install langchain-chroma chromadb

from langchain_chroma import Chroma
from langchain_openai import OpenAIEmbeddings

embeddings = OpenAIEmbeddings(model="text-embedding-3-small")

# Kalıcı depolama ile Chroma
vector_store = Chroma(
    collection_name="agent_memory",
    embedding_function=embeddings,
    persist_directory="./chroma_db"  # Kalıcı depolama
)

# Bellek ekleme
vector_store.add_texts(
    texts=["Kullanıcı Python tercih ediyor", "Karanlık tema seçili"],
    metadatas=[{"user_id": "user_123"}, {"user_id": "user_123"}]
)

# Benzerlik araması
results = vector_store.similarity_search(
    "programlama dili tercihi",
    k=3,
    filter={"user_id": "user_123"}
)

5.2 Qdrant

Qdrant, Rust ile yazılmış, yüksek performanslı ve gerçek zamanlı güncellemeler için optimize edilmiş bir vektör veritabanıdır [31]. Hibrit arama (dense + sparse vectors) desteği ile öne çıkar.

Avantajları:

• Rust ile yazılmış, yüksek performans
• Hibrit arama desteği (vektör + keyword)
• JSON metadata filtreleme
• Yerel mod ve sunucu modu seçenekleri

# Kurulum: pip install langchain-qdrant qdrant-client

from langchain_qdrant import QdrantVectorStore
from langchain_openai import OpenAIEmbeddings

embeddings = OpenAIEmbeddings(model="text-embedding-3-small")

# Yerel mod (bellek içi - test için)
vector_store = QdrantVectorStore.from_texts(
    texts=["Kullanıcı sabah kahve içmeyi sever"],
    embedding=embeddings,
    location=":memory:",  # Bellek içi mod
    collection_name="agent_memory",
)

# Veya kalıcı yerel depolama
vector_store = QdrantVectorStore.from_texts(
    texts=["Kullanıcı İstanbul'da yaşıyor"],
    embedding=embeddings,
    path="./qdrant_data",  # Yerel dosya sistemi
    collection_name="agent_memory",
)

# Veya uzak Qdrant sunucusu
vector_store = QdrantVectorStore.from_existing_collection(
    embedding=embeddings,
    collection_name="agent_memory",
    url="http://localhost:6333",
)

# Benzerlik araması
results = vector_store.similarity_search("kahve tercihleri", k=3)

5.3 FAISS (Facebook AI Similarity Search)

FAISS, Meta (Facebook) tarafından geliştirilen, milyarlarca vektör üzerinde son derece hızlı benzerlik araması yapabilen bir kütüphanedir [32]. GPU desteği ile büyük ölçekli uygulamalar için idealdir.

Avantajları:

• Milyarlarca vektör için optimize
• GPU hızlandırma desteği
• Çok düşük gecikme süresi
• Tamamen ücretsiz ve açık kaynak

# Kurulum: pip install faiss-cpu  (veya faiss-gpu GPU için)

from langchain_community.vectorstores import FAISS
from langchain_openai import OpenAIEmbeddings

embeddings = OpenAIEmbeddings(model="text-embedding-3-small")

# FAISS vektör deposu oluştur
vector_store = FAISS.from_texts(
    texts=[
        "Kullanıcı machine learning ile ilgileniyor",
        "Favori IDE: VS Code",
        "Python ve TypeScript biliyor"
    ],
    embedding=embeddings,
    metadatas=[
        {"user_id": "user_123", "category": "interest"},
        {"user_id": "user_123", "category": "tools"},
        {"user_id": "user_123", "category": "skills"}
    ]
)

# Yerel dosyaya kaydet
vector_store.save_local("./faiss_index")

# Daha sonra yükle
loaded_store = FAISS.load_local(
    "./faiss_index", 
    embeddings,
    allow_dangerous_deserialization=True
)

# Benzerlik araması
results = loaded_store.similarity_search("hangi programlama dilleri", k=3)

Vektör Veritabanı Karşılaştırması

Veritabanı Seçim Rehberi

Hangi veritabanını seçeceğinize karar verirken şu kriterleri göz önünde bulundurun:

En İyi Uygulamalar

Kısa Süreli Bellek İçin

1. Token Limitlerini İzleyin: Konuşma geçmişi büyüdükçe token tüketimini takip edin ve gerektiğinde kırpma veya özetleme stratejileri uygulayın [21].
2. Uygun Checkpointer Seçin: Geliştirme için InMemorySaver, üretim için PostgresSaver veya SqliteSaver kullanın.
3. Thread ID Yönetimi: Her kullanıcı oturumu için benzersiz thread_id’ler kullanarak konuşmaları izole edin.

Uzun Süreli Bellek İçin

1. Ad Alanı Stratejisi: Belleği kullanıcı, organizasyon veya bağlam bazında organize etmek için anlamlı ad alanları kullanın [22].
2. Anlamsal Arama Entegrasyonu: Tam metin eşleştirme yerine anlam tabanlı arama için embedding’ler kullanın.
3. Bellek Temizleme: Eski veya alakasız bellekleri periyodik olarak temizleyin veya güncelleyin.
4. Gizlilik ve Uyumluluk: Kişisel verileri saklarken KVKK/GDPR gibi düzenlemelere uyumlu olun [17].

Sonuç

LangChain’in bellek sistemi, yapay zeka ajanlarınızı daha akıllı, daha bağlamsal ve daha kişisel hale getirmenin anahtarıdır. Kısa süreli bellek, tek bir konuşma içinde tutarlılık sağlarken, uzun süreli bellek ajanınızın zaman içinde öğrenmesine ve gelişmesine olanak tanır.

Hangi bellek türünü kullanacağınıza karar verirken şu soruları sorun:

• Bilgi tek bir oturum içinde mi gerekli, yoksa oturumlar arası mı?
• Bellek ne sıklıkta güncellenecek?
• Kullanıcı kişiselleştirme ne kadar önemli?

Bu rehberde öğrendiklerimizi özetlersek:

• Kısa süreli bellek, checkpointer kullanarak tek bir konuşma thread’i içinde bağlamı korur
• Uzun süreli bellek, memory store kullanarak oturumlar ve kullanıcılar arası bilgi saklar
• Her iki bellek türü de birlikte kullanıldığında en güçlü sonuçları verir
• LangMem SDK, bellek yönetimini kolaylaştıran araçlar sunar

Umarım LangChain kısa ve uzun süreli bellek için faydalı bir yazı olmuştur. Bir sonraki yazıda görüşünceye dek çav…

Kaynaklar

[1] LangChain Documentation – Memory Overview. https://docs.langchain.com/oss/python/concepts/memory

[2] LangChain Blog – Memory for Agents. https://blog.langchain.com/memory-for-agents/

[3] LangChain Blog – Launching Long-Term Memory Support in LangGraph. https://blog.langchain.com/launching-long-term-memory-support-in-langgraph/

[4] LangChain Documentation – Short-term Memory. https://docs.langchain.com/oss/python/langchain/short-term-memory

[5] PyPI – langgraph-checkpoint. https://pypi.org/project/langgraph-checkpoint/

[6] LangChain Documentation – Memory (JavaScript). https://langchain-ai.lang.chat/langgraphjs/agents/memory/

[7] Supermemory – How To Add Conversational Memory To LLMs Using LangChain. https://supermemory.ai/blog/how-to-add-conversational-memory-to-llms-using-langchain/

[8] FutureSmart AI – How to Build LangGraph Agent with Long-term Memory. https://blog.futuresmart.ai/how-to-build-langgraph-agent-with-long-term-memory

[9] Medium – Conversational Memory in LangChain. https://medium.com/@khadkaujjwal47/conversational-memory-in-langchain-532fe4460add

[10] LangMem Documentation – Conceptual Guide. https://langchain-ai.github.io/langmem/concepts/conceptual_guide/

[11] LangChain Blog – LangMem SDK Launch. https://blog.langchain.com/langmem-sdk-launch/

[12] MongoDB Blog – Powering Long-Term Memory for Agents With LangGraph and MongoDB. https://www.mongodb.com/company/blog/product-release-announcements/powering-long-term-memory-for-agents-langgraph

[13] LangChain Blog – Semantic Search for LangGraph Memory. https://blog.langchain.com/semantic-search-for-langgraph-memory/

[14] LangMem Documentation – Hot Path Quickstart Guide. https://langchain-ai.github.io/langmem/hot_path_quickstart/

[15] LangMem Documentation – Introduction. https://langchain-ai.github.io/langmem/

[16] Analytics Vidhya – LangMem SDK: Personalizing AI Agents with Semantic Memory. https://www.analyticsvidhya.com/blog/2025/03/langmem-sdk/

[17] Medium – Building Context-Aware Chatbots: Implementing Persistent Memory with LangChain and Oracle NoSQL. https://medium.com/@dariovega/building-context-aware-chatbots-implementing-persistent-memory-with-langchain-and-oracle-nosql-63149d9c718b

[18] Pinecone – Conversational Memory for LLMs with Langchain. https://www.pinecone.io/learn/series/langchain/langchain-conversational-memory/

[19] DeepLearning.AI – Long-Term Agentic Memory with LangGraph. https://www.deeplearning.ai/short-courses/long-term-agentic-memory-with-langgraph/

[20] LangChain Changelog – Semantic Search for LangGraph’s Long-term Memory. https://changelog.langchain.com/announcements/semantic-search-for-langgraph-s-long-term-memory

[21] Focused.io – Customizing Memory in LangGraph Agents for Better Conversations. https://focused.io/lab/customizing-memory-in-langgraph-agents-for-better-conversations

[22] HexaCluster – Persistent Memory for Chatbots using PostgreSQL and LangChain. https://hexacluster.ai/postgresql/postgres-for-chat-history-langchain-postgres-postgreschatmessagehistory/

[23] Redis Blog – LangGraph & Redis: Build smarter AI agents with memory & persistence. https://redis.io/blog/langgraph-redis-build-smarter-ai-agents-with-memory-persistence/

[24] Redis Blog – LangGraph Redis Checkpoint 0.1.0. https://redis.io/blog/langgraph-redis-checkpoint-010/

[25] PyPI – langgraph-checkpoint-sqlite. https://pypi.org/project/langgraph-checkpoint-sqlite/

[26] LangChain Blog – LangGraph v0.2: Increased customization with new checkpointer libraries. https://blog.langchain.com/langgraph-v0-2/

[27] GitHub – langgraph-checkpoint-dynamodb. https://github.com/aaronsu11/langgraph-checkpoint-dynamodb

[28] GitHub – langgraph-checkpoint-cosmos. https://github.com/shengbo-ma/langgraph-checkpoint-cosmos

[29] LangChain Documentation – Vector Stores. https://python.langchain.com/docs/integrations/vectorstores/

[30] LangChain Blog – LangChain + Chroma. https://blog.langchain.com/langchain-chroma/

[31] Qdrant Documentation – LangChain Integration. https://qdrant.tech/documentation/frameworks/langchain/

[32] GeeksforGeeks – Vector Stores in LangChain. https://www.geeksforgeeks.org/artificial-intelligence/vector-stores-in-langchain/