LangChain, LangGraph ve Deep Agents Karşılaştırma

Merhaba arkadaşlar! Bugün yapay zeka (AI) dünyasının en çok kafa karıştıran konularından birine dalıyoruz: LangChain, LangGraph ve Deep Agents arasındaki farklar. "Hangisini ne zaman kullanacağım?", "LangGraph, LangChain'in yerini mi aldı?", "Deep Agents da neyin nesi?" diye soruyorsanız, doğru yerdesiniz. Bu yazının sonunda hepsini öğreneceğiz, kod örnekleriyle göreceğiz ve hangi durumda hangisini seçeceğimize birlikte karar vereceğiz.

Baştan söyleyeyim, bu yazıdaki en önemli fikir tek bir cümle: LangChain ekosistemi, birbirinin üstüne inşa edilmiş dört soyutlama katmanı (abstraction layer) olarak düşünülebilir. Bunu bir kere kavradık mı, gerisi çorap söküğü gibi gelecek. Hadi başlayalım!

Büyük Resim: Dört Katmanlı Pasta

LangChain ekosistemini dört katlı bir pasta gibi düşünün. Her kat, altındaki katın üzerine inşa ediliyor:

┌─────────────────────────────────────────┐
│  Katman 4: Deep Agents                  │  → Ajan koşum takımı (agent harness)
├─────────────────────────────────────────┤
│  Katman 3: create_agent (LangChain)     │  → Ajan framework'ü (agent framework)
├─────────────────────────────────────────┤
│  Katman 2: LangGraph                    │  → Orkestrasyon (orchestration) & runtime
├─────────────────────────────────────────┤
│  Katman 1: LangChain Çekirdeği (Core)   │  → LLM çağrıları, araçlar (tools), entegrasyonlar
└─────────────────────────────────────────┘

LangChain'in resmi dokümantasyonu da bu ayrımı net bir şekilde yapıyor: ajan framework'leri (agent frameworks), ajan runtime'ları (agent runtimes) ve ajan koşum takımları (agent harnesses) farklı ihtiyaçlara hizmet eden farklı kavramlar [1]. En kritik bilgi şu: bunlar birbirinin rakibi değil, birbirinin tamamlayıcısı. "LangChain mi LangGraph mı?" sorusu aslında yanlış bir soru; doğru soru "hangi seviyede çalışmam gerekiyor?" [2].

Şimdi bu katmanları tek tek inceleyeceğiz.

Katman 1: LangChain Çekirdeği — Her Şeyin Başladığı Yer

En alttaki katman, en fazla kontrole ve ayrıntı düzeyine (granularity) sahip olduğumuz yer. Çoğumuzun LangChain ile ilk tanıştığı katman da burası.

LangChain, temelde büyük dil modeli (LLM - Large Language Model) çağrılarını saran soyutlama kodudur. Ne yapar?

• Farklı LLM sağlayıcılarına (OpenAI, Anthropic, Google vb.) tek bir standart arayüzle erişmenizi sağlar
• LLM çağrılarını birbirine zincirlemenize (chaining) olanak tanır
• Araç çağırma (tool calling), prompt şablonları (prompt templates) ve çıktı ayrıştırıcıları (output parsers) gibi yaygın görevleri kolaylaştırır

LangChain 2022 sonunda ortaya çıktı ve 2023'te resmen patladı. LLM soyutlaması denince akla gelen ilk framework oldu. Bugün 600'den fazla sağlayıcı entegrasyonuyla hâlâ ekosistemin en geniş entegrasyon kütüphanesi konumunda [2]. Mimari olarak zincir yapısı, yani yönlü çevrimsiz graf (DAG - Directed Acyclic Graph) kullanır: görevler belirli bir sırayla çalışır. "Veriyi getir → özetle → cevapla" gibi adımları önceden bildiğiniz doğrusal (linear) akışlar için biçilmiş kaftandır [3].

Kodda şöyle görünür:

from langchain.chat_models import init_chat_model

model = init_chat_model("anthropic:claude-sonnet-4-6")
response = model.invoke("Merhaba! LangChain nedir?")
print(response.content)

Bu kadar basit. Model sağlayıcısını değiştirmek istediğinizde tek satırı güncelliyorsunuz, uygulamanın geri kalanına dokunmuyorsunuz.

Zayıf noktası ne? LangChain'in zincir yapısı, döngü (loop) gerektiren, duruma bağlı dallanan (conditional branching) veya kalıcı durum (persistent state) isteyen işlerde yetersiz kalıyor. Zincir boyunca bilgi taşıyabilir ama çalıştırmalar arasında kalıcı bir durum yönetimi (state management) sunmaz [3]. İşte tam bu noktada ikinci katman devreye giriyor.

Katman 2: LangGraph — Orkestrasyon Motoru

LangGraph, birinci katmanın üzerine inşa edilmiş bir orkestrasyon framework'ü (orchestration framework) ve ajan runtime'ıdır (agent runtime) [4]. İşin ilginç yanı şu: LangGraph ile kuracağınız bağımlılık grafının (dependency graph) LLM'lerle hiçbir ilgisi olmak zorunda bile değil. Ama birden fazla LLM çağrısını tekrarlanabilir, sağlam, kurşun geçirmez bir yapıya oturtmak istiyorsanız, adres burası.

LangGraph'ın temel yapı taşları:

• Düğümler (nodes): Her biri bir Python fonksiyonu olan işlem adımları
• Kenarlar (edges): Adımlar arası geçişleri ve yönlendirme mantığını (routing logic) tanımlar
• Durum (state): Genellikle TypedDict olarak tanımlanan, açık ve tipli (typed) bir durum nesnesi

LangChain'den en büyük farkı: LangGraph çevrimsel durum makinesi (cyclic state machine) modeli kullanır. Yani graf kendi üzerine dönebilir, önceki durumlara geri gidebilir, koşullara göre dallanabilir [2]. Ayrıca şunları da out of the box, yani kutudan çıktığı gibi sunar:

• Dayanıklı yürütme (durable execution): Ajanlar hatalardan sonra kaldıkları yerden devam edebilir [5]
• Checkpoint'leme (checkpointing): Her düğüm geçişinde durum kaydedilir; sunucu çökse bile ajan yeniden başlatılıp önceki herhangi bir durumdan tekrar oynatılabilir (replay) [6]
• Döngüde insan (human-in-the-loop): Yürütmeyi durdurup insan onayı bekleyebilirsiniz [5]
• Akış (streaming): Belirteç belirteç (token-by-token) gerçek zamanlı çıktı [4]

Basit bir örnek:

from langgraph.graph import StateGraph, START, END
from typing import TypedDict

class State(TypedDict):
    siparis_verisi: dict | None
    sonuc: str

def veri_getir(state: State):
    # veriyi çek
    return {"siparis_verisi": {...}}

def hata_yonet(state: State):
    return {"sonuc": "Sipariş bulunamadı"}

def hesapla(state: State):
    return {"sonuc": "Toplam hesaplandı"}

def yonlendir(state: State):
    # KENDİ iş mantığınız: koşullu yönlendirme
    if state["siparis_verisi"] is None:
        return "hata_yonet"
    return "hesapla"

builder = StateGraph(State)
builder.add_node("veri_getir", veri_getir)
builder.add_node("hata_yonet", hata_yonet)
builder.add_node("hesapla", hesapla)
builder.add_edge(START, "veri_getir")
builder.add_conditional_edges("veri_getir", yonlendir)
graph = builder.compile()

Gördüğünüz gibi her adımı, her geçişi, her koşulu biz kontrol ediyoruz. Bunun bedeli de var tabii: öğrenme eğrisi (learning curve) dik ve kod, kasıtlı olarak ayrıntılı (verbose by design) [7]. Kolaylık istiyorsanız üst katmanlara çıkacağız; kontrol istiyorsanız burada kalacağız. Uber, LinkedIn ve Klarna gibi şirketlerin üretim (production) ortamında LangGraph kullandığını da not düşelim [5].

Katman 3: create_agent — LangChain'in Ajan Çatısı

Şimdi işler ilginçleşiyor. Üçüncü katman, ekosistemdeki ajan framework'üne (agent framework) en yakın şey: create_agent fonksiyonu. OpenAI Agents SDK'ya oldukça benziyor; döngü içinde araçlarla çalışan komple bir LLM ajanı kuruyor.

Ama dikkat, kafa karışıklığının kaynağı tam burası: create_agent, LangGraph'ın değil, LangChain'in bir parçası. Peki perde arkasında nasıl çalışıyor? Bir LangGraph bağımlılık grafı (dependency graph) oluşturuyor ve bu graf da LangChain çekirdek bileşenlerini çağırıyor. Yani üçüncü katman (LangChain'deki ajan framework'ü), ikinci katmanın (LangGraph orkestrasyonu) üzerinde, o da birinci katmanın (LangChain çekirdeği) üzerinde duruyor. Ekim 2025'teki v1.0 sürümünden beri bu resmi olarak böyle: create_agent, LangGraph'ın yürütme motorunu (execution engine) kaputun altında çalıştırıyor [2][8].

Bu sayede tek bir fonksiyon çağrısıyla şunları bedavaya alıyorsunuz: kalıcılık (persistence), akış, döngüde insan desteği ve dayanıklı yürütme [9]. Üstelik LangGraph bilmenize gerek bile yok [1].

from langchain.agents import create_agent

def hava_durumu(sehir: str) -> str:
    """Bir şehrin hava durumunu getirir."""
    return f"{sehir} şu an güneşli, 24 derece"

agent = create_agent(
    model="anthropic:claude-sonnet-4-6",
    tools=[hava_durumu],
)

sonuc = agent.invoke({
    "messages": [{"role": "user", "content": "İstanbul'da hava nasıl?"}]
})

Bu ajan, ReAct (Reasoning + Acting, yani Akıl Yürütme + Eylem) desenini takip eder: model düşünür, gerekirse araç çağırır, sonucu gözlemler ve görev tamamlanana kadar döngüye devam eder [10]. v1.0 ile gelen middleware (ara katman) sistemi sayesinde bu döngünün her adımına hook takabiliyorsunuz: kişisel verileri (PII - Personally Identifiable Information) maskeleme, uzun konuşmaları özetleme, insan onayı isteme gibi işleri hazır middleware'lerle ekleyebiliyorsunuz [9].

Ne zaman yetmez? Yürütme ortasında duruma müdahale etmeniz, koşullu yeniden deneme (retry) mantığı kurmanız veya ajanlar arası görev aktarımları (multi-agent handoffs) tasarlamanız gerektiğinde, bir katman aşağı inip açık StateGraph yazarsınız. Bu bir geçici çözüm (workaround) değil, tasarlanmış yol [2].

Katman 4: Deep Agents — Piller Dahil Ajan Koşum Takımı

Ve geldik en üst katmana. Deep Agents, LangChain'in görece yeni çıkardığı bir paket ve kendini "piller dahil ajan koşum takımı" (batteries-included agent harness) olarak tanımlıyor [11]. Harness ne demek? Kelimenin aslı, atın koşum takımı: hayvanın gücünü arabaya, sabana, yani işe koşmanızı sağlayan donanım. Ajan bağlamında da metafor birebir aynı — LLM'in ham gücünü alıp etrafına planlama, araçlar ve bağlam yönetimi geçirerek onu gerçek işlere koşan çevre donanımı. Pratikteki karşılığı şu: fikirli (opinionated), out of the box çalışmaya hazır bir ajan. Prompt'ları, araçları ve bağlam yönetimini (context management) kendiniz kablolamak yerine, çalışan bir ajanı anında alıp yalnızca ihtiyacınız olan kısımları özelleştiriyorsunuz [11].

Deep Agents, uzun soluklu (long-running), çok adımlı görevler için tasarlandı: araştırma, kodlama, karmaşık iş akışları... Claude Agent SDK gibi araçlara benzetebiliriz. Kutuda neler var [11][12]:

• Planlama (planning): write_todos aracıyla görev ayrıştırma ve ilerleme takibi
• Dosya sistemi (filesystem): read_file, write_file, edit_file, ls, glob, grep gibi araçlarla çalışma belleği; bellek içi (in-memory), yerel disk veya uzak arka uçlarla (backends) çalışabilir [13]
• Alt ajanlar (subagents): task aracıyla, her biri yalıtılmış bağlam penceresine (isolated context window) sahip alt ajanlara iş devretme
• Bağlam yönetimi (context management): Uzun konuşma geçmişini sıkıştırma, büyük araç çıktılarını diske boşaltma (offloading)
• Beceriler (skills): Ajanın davranışını dosya bazlı, güncellenebilir becerilerle şekillendirme [14]

Kullanımı gerçekten bu kadar basit:

from deepagents import create_deep_agent

agent = create_deep_agent(
    model="anthropic:claude-sonnet-4-6",
    tools=[web_arama],
)

sonuc = agent.invoke({
    "messages": [{"role": "user", "content": "LangGraph'ı araştır ve bir özet raporu yaz"}]
})

Bu tek çağrıyla ajan plan yapabilir, dosya okuyup yazabilir, alt ajanlar başlatabilir ve kendi bağlam penceresini yönetebilir [15]. Ve tahmin edin ne? create_deep_agent size derlenmiş bir LangGraph grafı (compiled LangGraph graph) döndürüyor — yani akış, checkpoint'ler, LangGraph Studio gibi tüm LangGraph özellikleri burada da geçerli [15]. Katmanlar birbirine böyle kenetlenmiş işte: Deep Agents → create_agent → LangGraph → LangChain çekirdeği. Hatta herhangi bir özel LangGraph grafınızı bir Deep Agent'a alt ajan olarak takabiliyorsunuz; katmanlar gerçekten birleşebilir (composable) [12].

Peki Hangisini Ne Zaman Kullanacağız?

Şimdi işin en pratik kısmına geldik. LangChain'in kendi GitHub deposundaki tavsiyesi gayet net [12]:

Birkaç pratik ipucu daha:

1. Akıllı bir sohbet botu (chatbot) mu lazım? create_agent ile başlayın. Güvenilir, denetlenebilir bir iş akışı mı lazım? LangGraph'a inin [16].
2. Uyumlu ilerleme mümkün: create_agent ile başlayıp ihtiyaç arttıkça LangGraph'a inebilirsiniz; graflar birleşebilir olduğu için ikisini karıştırmak da serbest [8].
3. Kilitlenme (lock-in) korkusu yersiz: Deep Agents dahil tüm katmanlar model-bağımsız (model-agnostic); araç çağırmayı destekleyen herhangi bir LLM ile çalışır [12].
4. Başarılı LLM uygulamalarının çoğu ikisini birden kullanıyor: Düğümlerin içindeki yaratıcı işler için ajanlar, genel orkestrasyon için graflar [16].

Toparlayalım

Bugün öğrendiklerimizi tek paragrafta özetleyelim: LangChain ekosistemi dört katmandan oluşuyor. Katman 1 (LangChain çekirdeği) LLM çağrılarını ve entegrasyonları soyutluyor. Katman 2 (LangGraph) bunların üzerine durum yönetimli, döngü destekli, dayanıklı bir orkestrasyon runtime'ı kuruyor. Katman 3 (create_agent) LangGraph'ı kaputun altında kullanarak tek fonksiyonla ajan kurmanızı sağlıyor. Katman 4 (Deep Agents) ise bunun üzerine planlama, dosya sistemi, alt ajanlar ve bağlam yönetimini paketleyip piller dahil bir ajan koşum takımı (agent harness) sunuyor. Hiçbiri diğerinin rakibi değil; hepsi aynı stack'in farklı seviyeleri.

Benim tavsiyem: küçük başlayın, ihtiyaç duydukça katman değiştirin. Önce create_agent ile bir şeyler kurun, sınırlarına çarptığınızda göreceksiniz, LangGraph'a inmek çok daha anlamlı gelecek. Uzun soluklu araştırma veya kodlama ajanları yapacaksanız da Deep Agents'a bir şans verin, kablolama derdinden kurtulacaksınız.

Sorularınız varsa yorumlarda buluşalım. Bir sonraki yazıda görüşmek üzere, kodlamaya devam! 🚀

Kaynaklar

1. LangChain Docs — Frameworks, runtimes, and harnesses: https://docs.langchain.com/oss/python/concepts/products
2. Atlan — LangChain vs LangGraph: Key Differences Explained (2026): https://atlan.com/know/ai-agent/ai-agent-memory/langchain-vs-langgraph/
3. Tahir (Medium) — LangChain vs. LangGraph: A Comparative Analysis: https://medium.com/@tahirbalarabe2/%EF%B8%8Flangchain-vs-langgraph-a-comparative-analysis-ce7749a80d9c
4. LangChain — LangGraph: Agent Orchestration Framework: https://www.langchain.com/langgraph
5. LangChain Blog — LangChain and LangGraph Agent Frameworks Reach v1.0 Milestones: https://www.langchain.com/blog/langchain-langgraph-1dot0
6. Spheron Blog — LangGraph vs LangChain: Which to Use for Production AI Agents in 2026: https://www.spheron.network/blog/langgraph-vs-langchain/
7. Speakeasy — Choosing an agent framework: LangChain vs LangGraph vs CrewAI vs PydanticAI: https://www.speakeasy.com/blog/ai-agent-framework-comparison
8. LangChain GitHub — langgraph repository: https://github.com/langchain-ai/langgraph
9. LangChain Docs — What's new in LangChain v1: https://docs.langchain.com/oss/python/releases/langchain-v1
10. Codecademy — Build AI agents with LangChain v1: https://www.codecademy.com/article/build-ai-agents-with-langchain-v1
11. LangChain — Deep Agents: Build Agents for Complex, Multi-Step Tasks: https://www.langchain.com/deep-agents
12. LangChain GitHub — deepagents repository: https://github.com/langchain-ai/deepagents
13. LangChain Docs — Deep Agents overview: https://docs.langchain.com/oss/python/deepagents/overview
14. K Means Karan (Substack) — LangChain DeepAgents Explained: How Agent Harnesses Beat Classic AI Agents: https://kmeanskaran.substack.com/p/how-agent-harnesses-beat-classic
15. Amol Kavitkar (Medium) — Deep Agents SDK: The Batteries-Included Agent Harness from LangChain: https://medium.com/@amolkavitkar/deep-agents-sdk-the-batteries-included-agent-harness-from-langchain-0dcb3a50cefd
16. Sivakami K (Medium) — LangChain Agents vs. LangGraph Agents: When to Use Each: https://medium.com/@sivakami.kanda/langchain-agents-vs-langgraph-agents-when-to-use-each-a-practical-decision-framework-abc9b451a627
17. LangChain Reference — deepagents package: https://reference.langchain.com/python/deepagents
18. LangChain Reference — langchain package: https://reference.langchain.com/python/langchain
19. LangChain — Open Source AI Agent Framework: https://www.langchain.com/langchain
20. DuploCloud — LangChain vs. LangGraph: A Developer's Guide: https://duplocloud.com/blog/langchain-vs-langgraph/
21. Oxylabs — LangChain vs. LangGraph: Comparing AI Agent Frameworks: https://oxylabs.io/blog/langgraph-vs-langchain
22. npm — deepagents package: https://www.npmjs.com/package/deepagents
23. Saefulloh Maslul (Medium) — Building an Agent Harness with LangChain Deep Agents: https://medium.com/populix-engineering/building-an-agent-harness-with-langchain-deep-agents-e0402de12a94