LangChain ile AI Ajan Geliştirme: Pratik Rehber

Yapay zeka ajanları, günümüz yazılım dünyasının en heyecan verici gelişmelerinden birini temsil ediyor. Bir LLM'in (Büyük Dil Modeli) sadece metin üretmekle kalmayıp, karar verme, araç kullanma ve otonom görevler yürütme yeteneğine sahip olması, uygulama geliştirme paradigmasını kökten değiştiriyor. LangChain, bu dönüşümün merkezinde yer alan en popüler ve kapsamlı framework olarak öne çıkıyor. Bu rehberde, LangChain ile AI ajan geliştirmenin tüm yönlerini derinlemesine inceleyeceğiz.

1. LangChain Nedir?

LangChain, büyük dil modelleri (LLM) ile güçlendirilmiş uygulamalar geliştirmek için tasarlanmış açık kaynaklı bir Python ve JavaScript framework'üdür. 2022 yılında Harrison Chase tarafından oluşturulan LangChain, kısa sürede yapay zeka geliştirme ekosisteminin vazgeçilmez bir parçası haline gelmiştir.

LangChain'in temel felsefesi, LLM'leri izole bir şekilde kullanmak yerine, onları harici veri kaynaklarına, API'lere ve araçlara bağlayarak çok daha güçlü ve işlevsel uygulamalar oluşturmaktır. Framework, modüler bir mimariye sahiptir ve geliştiricilere birbirine bağlanabilen bileşenler sunarak karmaşık iş akışlarını kolayca oluşturmalarına olanak tanır.

LangChain'in popülerliğinin ardında yatan bazı temel nedenler şunlardır:

• Model Bağımsızlığı: OpenAI, Anthropic, Google, Hugging Face gibi onlarca LLM sağlayıcısıyla çalışır
• Zengin Entegrasyon: 700'den fazla üçüncü parti entegrasyon sunar
• Aktif Topluluk: 80.000+ GitHub yıldızı ve binlerce katkıda bulunan
• Kapsamlı Dokümantasyon: Detaylı rehberler ve örneklerle desteklenir
• Hızlı Prototipleme: Karmaşık AI uygulamalarını hızla geliştirmenizi sağlar

2. Temel Bileşenler

LangChain'in mimarisi, birbirine bağlanabilen modüler bileşenler üzerine kurulmuştur. Her bileşen, belirli bir sorumluluğa sahiptir ve bağımsız olarak kullanılabilir veya diğer bileşenlerle birleştirilebilir.

Bileşen	Açıklama	Kullanım Alanı
Models	LLM ve Chat Model soyutlamaları	Metin üretme, sohbet
Prompts	Prompt şablonları ve yönetimi	Dinamik prompt oluşturma
Chains	Bileşenlerin zincirlenmesi	Çok adımlı iş akışları
Agents	Karar veren otonom ajanlar	Dinamik araç seçimi
Tools	Ajanların kullandığı araçlar	API çağrıları, hesaplamalar
Memory	Konuşma geçmişi yönetimi	Chatbot'lar, bağlam koruma
Retrievers	Belge arama ve getirme	RAG uygulamaları

Kurulum son derece basittir. Temel paketi ve ihtiyaç duyduğunuz entegrasyonları pip ile kurabilirsiniz:

pip install langchain langchain-openai langchain-community
pip install langgraph langsmith

3. Chains: Zincirleme İşlemler

Chains, LangChain'in adını aldığı temel kavramdır. Bir chain, birden fazla bileşeni sıralı veya paralel olarak birleştirerek karmaşık iş akışları oluşturmanızı sağlar. En basit haliyle, bir prompt şablonunu bir LLM'e bağlamak bile bir chain oluşturur.

Basit Chain Örneği

from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser

# Model ve prompt tanımlama
model = ChatOpenAI(model="gpt-4o", temperature=0.7)

prompt = ChatPromptTemplate.from_messages([
    ("system", "Sen deneyimli bir yazılım danışmanısın."),
    ("human", "{konu} hakkında kısa bir özet yaz.")
])

# LCEL ile chain oluşturma
chain = prompt | model | StrOutputParser()

# Chain'i çalıştırma
sonuc = chain.invoke({"konu": "microservices mimarisi"})
print(sonuc)

Sıralı Chain (Sequential Chain)

Sıralı chain'ler, bir adımın çıktısının sonraki adımın girdisi olduğu iş akışlarını modellemek için kullanılır. Örneğin, önce bir konu hakkında araştırma yapıp, ardından bu araştırmayı özetlemek isteyebilirsiniz:

from langchain_core.runnables import RunnablePassthrough

# İlk adım: Araştırma
arastirma_prompt = ChatPromptTemplate.from_template(
    "{konu} hakkında detaylı bir analiz yap."
)

# İkinci adım: Özet
ozet_prompt = ChatPromptTemplate.from_template(
    "Aşağıdaki analizi 3 maddede özetle:\n\n{analiz}"
)

# Zincirleme
chain = (
    arastirma_prompt 
    | model 
    | StrOutputParser() 
    | (lambda x: {"analiz": x})
    | ozet_prompt 
    | model 
    | StrOutputParser()
)

sonuc = chain.invoke({"konu": "Yapay zeka etiği"})

4. Agents ve Tools

Agent'lar, LangChain'in en güçlü özelliklerinden biridir. Bir chain önceden tanımlanmış adımları sırasıyla uygularken, bir agent LLM'i bir muhakeme motoru olarak kullanarak hangi adımları atacağına ve hangi araçları kullanacağına dinamik olarak karar verir. Bu, AI uygulamalarına gerçek bir özerklik kazandırır.

Tool (Araç) Tanımlama

Tool'lar, ajanların dış dünyayla etkileşim kurmak için kullandığı fonksiyonlardır. LangChain, araç oluşturmayı son derece kolaylaştırır:

from langchain_core.tools import tool
from langchain_openai import ChatOpenAI

@tool
def hava_durumu_getir(sehir: str) -> str:
    """Belirtilen şehrin güncel hava durumu bilgisini getirir."""
    # Gerçek uygulamada bir API çağrısı yapılır
    hava_verileri = {
        "İstanbul": "22°C, Parçalı Bulutlu",
        "Ankara": "18°C, Güneşli",
        "İzmir": "25°C, Açık"
    }
    return hava_verileri.get(sehir, f"{sehir} için veri bulunamadı.")

@tool
def hesap_makinesi(ifade: str) -> str:
    """Matematiksel ifadeleri hesaplar. Örn: '2 + 3 * 4'"""
    try:
        sonuc = eval(ifade)
        return f"Sonuç: {sonuc}"
    except Exception as e:
        return f"Hesaplama hatası: {str(e)}"

@tool
def web_arama(sorgu: str) -> str:
    """Web'de arama yapar ve sonuçları döndürür."""
    # Gerçek uygulamada SerpAPI, Tavily vb. kullanılır
    return f"'{sorgu}' için arama sonuçları bulundu."

Agent Oluşturma

from langgraph.prebuilt import create_react_agent

# Araçları listele
tools = [hava_durumu_getir, hesap_makinesi, web_arama]

# Model
model = ChatOpenAI(model="gpt-4o", temperature=0)

# ReAct Agent oluştur
agent = create_react_agent(model, tools)

# Agent'ı çalıştır
sonuc = agent.invoke({
    "messages": [
        ("human", "İstanbul'un hava durumu nedir ve sıcaklığı Fahrenheit'a çevir")
    ]
})

for mesaj in sonuc["messages"]:
    print(mesaj.content)

5. Memory: Konuşma Hafızası

LLM'ler doğası gereği durumsuz (stateless) çalışır; her istek birbirinden bağımsız işlenir. Ancak bir chatbot veya asistan oluştururken, önceki konuşmaların hatırlanması kritik önem taşır. LangChain'in memory sistemi bu sorunu çeşitli stratejilerle çözer.

Memory Türleri

Memory Türü	Çalışma Şekli	Kullanım Senaryosu
ConversationBufferMemory	Tüm mesajları saklar	Kısa konuşmalar
ConversationBufferWindowMemory	Son N mesajı saklar	Token sınırı yönetimi
ConversationSummaryMemory	Konuşmanın özetini tutar	Uzun konuşmalar
VectorStoreMemory	Embedding ile arama	Semantik hafıza

LangGraph ile Modern Memory Yönetimi

Güncel LangChain ekosisteminde memory yönetimi için LangGraph'ın checkpointer mekanizması tercih edilmektedir. Bu yaklaşım, her konuşma durumunu otomatik olarak kaydeder ve geri yükler:

from langgraph.prebuilt import create_react_agent
from langgraph.checkpoint.memory import MemorySaver

# Bellek yöneticisi
checkpointer = MemorySaver()

# Agent'ı memory ile oluştur
agent = create_react_agent(
    model, 
    tools, 
    checkpointer=checkpointer
)

# İlk mesaj
config = {"configurable": {"thread_id": "konusma-1"}}
agent.invoke(
    {"messages": [("human", "Benim adım Ahmet.")]},
    config=config
)

# İkinci mesaj - önceki bağlamı hatırlar
agent.invoke(
    {"messages": [("human", "Adımı hatırlıyor musun?")]},
    config=config
)
# Çıktı: "Evet, adınız Ahmet!"

6. LCEL (LangChain Expression Language)

LCEL, LangChain'in deklaratif zincirleme dilidir. Pipe (|) operatörünü kullanarak bileşenleri birbirine bağlamanızı sağlar. LCEL ile oluşturulan her chain otomatik olarak şu özelliklere sahiptir:

• Streaming: Token bazında gerçek zamanlı çıktı akışı
• Async Desteği: ainvoke, astream gibi asenkron metodlar
• Batch İşleme: Birden fazla girdiyi paralel işleme
• Otomatik Retry: Hata durumunda otomatik yeniden deneme
• Fallback: Alternatif model/chain tanımlama

LCEL ile Paralel İşleme

from langchain_core.runnables import RunnableParallel

# Paralel çalışan chain'ler
analiz_chain = RunnableParallel(
    ozet=ChatPromptTemplate.from_template(
        "{metin} metnini özetle"
    ) | model | StrOutputParser(),
    
    duygu=ChatPromptTemplate.from_template(
        "{metin} metninin duygu analizini yap"
    ) | model | StrOutputParser(),
    
    anahtar_kelimeler=ChatPromptTemplate.from_template(
        "{metin} metninden anahtar kelimeleri çıkar"
    ) | model | StrOutputParser()
)

# Tek çağrıyla 3 analiz birden
sonuclar = analiz_chain.invoke({"metin": "Uzun bir makale metni..."})
print(sonuclar["ozet"])
print(sonuclar["duygu"])
print(sonuclar["anahtar_kelimeler"])

Streaming ile Gerçek Zamanlı Çıktı

chain = prompt | model | StrOutputParser()

# Token token akış
async for chunk in chain.astream({"konu": "Kuantum bilgisayarlar"}):
    print(chunk, end="", flush=True)

7. RAG Entegrasyonu

RAG (Retrieval-Augmented Generation), LLM'lerin kendi eğitim verilerinin ötesindeki bilgilere erişmesini sağlayan en önemli mimari kalıplardan biridir. LangChain, RAG pipeline'ları oluşturmak için kapsamlı araçlar sunar.

RAG Pipeline Adımları

Tipik bir RAG pipeline'ı dört temel adımdan oluşur:

1. Belge Yükleme (Loading): PDF, web sayfası, veritabanı gibi kaynaklardan veri yükleme
2. Parçalama (Splitting): Belgeleri küçük, anlamlı parçalara bölme
3. Gömme (Embedding): Metin parçalarını vektör temsillerine dönüştürme
4. Getirme ve Üretme (Retrieval + Generation): İlgili parçaları bulup LLM'e bağlam olarak sunma

from langchain_community.document_loaders import PyPDFLoader
from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain_openai import OpenAIEmbeddings
from langchain_community.vectorstores import FAISS
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.runnables import RunnablePassthrough

# 1. Belge yükleme
loader = PyPDFLoader("sirket_politikalari.pdf")
documents = loader.load()

# 2. Parçalama
text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=1000,
    chunk_overlap=200,
    separators=["\n\n", "\n", ". ", " "]
)
chunks = text_splitter.split_documents(documents)

# 3. Vektör veritabanına kaydetme
embeddings = OpenAIEmbeddings(model="text-embedding-3-small")
vectorstore = FAISS.from_documents(chunks, embeddings)
retriever = vectorstore.as_retriever(search_kwargs={"k": 4})

# 4. RAG Chain
rag_prompt = ChatPromptTemplate.from_template("""
Aşağıdaki bağlam bilgisini kullanarak soruyu yanıtla.
Bağlamda bulamadığın bilgiyi uydurma.

Bağlam: {context}

Soru: {question}

Yanıt:""")

def format_docs(docs):
    return "\n\n".join(doc.page_content for doc in docs)

rag_chain = (
    {"context": retriever | format_docs, "question": RunnablePassthrough()}
    | rag_prompt
    | model
    | StrOutputParser()
)

# Soru sorma
yanit = rag_chain.invoke("Şirketin uzaktan çalışma politikası nedir?")
print(yanit)

8. LangSmith ile Debugging

LangSmith, LangChain ekibinin geliştirdiği bir gözlemlenebilirlik (observability) platformudur. LLM uygulamalarının her adımını izlemenizi, hata ayıklamanızı ve performansını değerlendirmenizi sağlar. Üretim ortamında çalışan AI ajanlarını yönetmek için vazgeçilmezdir.

LangSmith Kurulumu

# Ortam değişkenlerini ayarla
import os
os.environ["LANGSMITH_API_KEY"] = "ls__..."
os.environ["LANGSMITH_TRACING"] = "true"
os.environ["LANGSMITH_PROJECT"] = "ai-ajan-projem"

# Artık tüm LangChain çağrıları otomatik olarak izlenir!

LangSmith ile yapabilecekleriniz:

• Trace Görüntüleme: Her chain/agent çağrısının tüm adımlarını görsel olarak inceleyin
• Token Kullanımı: Her adımdaki token tüketimini ve maliyeti izleyin
• Gecikme Analizi: Hangi adımların en uzun sürdüğünü tespit edin
• Hata İzleme: Başarısız çağrıları ve hata mesajlarını analiz edin
• Değerlendirme: Otomatik ve insan değerlendirmesi ile çıktı kalitesini ölçün
• Dataset Yönetimi: Test veri setleri oluşturup regresyon testleri çalıştırın

Otomatik Değerlendirme

from langsmith import Client
from langsmith.evaluation import evaluate

client = Client()

# Değerlendirme veri seti oluştur
dataset = client.create_dataset("rag-test-seti")
client.create_examples(
    inputs=[{"question": "Uzaktan çalışma politikası nedir?"}],
    outputs=[{"answer": "Haftalık 3 gün uzaktan çalışma..."}],
    dataset_id=dataset.id
)

# Otomatik değerlendirme çalıştır
results = evaluate(
    rag_chain.invoke,
    data="rag-test-seti",
    evaluators=["correctness", "relevance"]
)

9. LangGraph ile Multi-Agent Sistemler

LangGraph, LangChain ekosisteminin en yeni ve en güçlü bileşenidir. Durum makinesi (state machine) ve graf tabanlı bir yaklaşımla karmaşık, çok adımlı ve çok ajanlı iş akışları oluşturmanızı sağlar. LangGraph ile döngüsel grafikler, koşullu dallanmalar ve insan müdahalesi gerektiren iş akışları modellenebilir.

Multi-Agent Mimarisi

Multi-agent sistemlerde, her ajan belirli bir uzmanlık alanına sahiptir ve birbirleriyle işbirliği yaparak karmaşık görevleri çözer. Yaygın multi-agent kalıpları şunlardır:

• Supervisor (Yönetici): Merkezi bir ajan, görevleri alt ajanlara dağıtır
• Hierarchical (Hiyerarşik): Çok katmanlı yönetici yapısı
• Collaborative (İşbirlikçi): Ajanlar eşit düzeyde işbirliği yapar
• Competitive (Rekabetçi): Ajanlar aynı görevi bağımsız çözer, en iyi sonuç seçilir

from langgraph.graph import StateGraph, MessagesState, START, END
from langgraph.prebuilt import create_react_agent
from langchain_core.messages import HumanMessage

# Uzman ajanlar oluştur
arastirmaci = create_react_agent(
    model, 
    tools=[web_arama],
    prompt="Sen bir araştırma uzmanısın. Web'de araştırma yap."
)

yazar = create_react_agent(
    model, 
    tools=[],
    prompt="Sen bir içerik yazarısın. Araştırma sonuçlarını makaleye dönüştür."
)

# Supervisor agent
def supervisor_node(state: MessagesState):
    """Görevi analiz edip hangi ajana yönlendireceğine karar verir."""
    response = model.invoke([
        ("system", """Gelen görevi analiz et. 
        Araştırma gerekiyorsa 'arastirmaci' yönlendir.
        Yazma gerekiyorsa 'yazar' yönlendir.
        İş bittiyse 'FINISH' de."""),
        *state["messages"]
    ])
    return {"messages": [response]}

# Graf oluştur
builder = StateGraph(MessagesState)
builder.add_node("supervisor", supervisor_node)
builder.add_node("arastirmaci", arastirmaci)
builder.add_node("yazar", yazar)

# Kenarları tanımla
builder.add_edge(START, "supervisor")

def route(state):
    last_msg = state["messages"][-1].content.lower()
    if "arastirmaci" in last_msg:
        return "arastirmaci"
    elif "yazar" in last_msg:
        return "yazar"
    return END

builder.add_conditional_edges("supervisor", route)
builder.add_edge("arastirmaci", "supervisor")
builder.add_edge("yazar", "supervisor")

# Derle ve çalıştır
graph = builder.compile()
sonuc = graph.invoke({
    "messages": [HumanMessage("Yapay zeka trendleri hakkında blog yazısı hazırla")]
})

Human-in-the-Loop (İnsan Müdahalesi)

LangGraph, kritik kararlarda insan onayı gerektiren iş akışlarını da destekler. Bu özellik, özellikle finansal işlemler veya hassas veri işlemleri gibi senaryolarda kritiktir:

from langgraph.prebuilt import create_react_agent
from langgraph.checkpoint.memory import MemorySaver

# interrupt_before ile belirli araçlardan önce durdur
agent = create_react_agent(
    model,
    tools=[hava_durumu_getir, hesap_makinesi],
    checkpointer=MemorySaver(),
    interrupt_before=["hesap_makinesi"]  # Bu araç çağrılmadan önce dur
)

# Agent çalışır ve hesap_makinesi'nden önce durur
# Kullanıcı onayladıktan sonra devam eder

10. Pratik Proje Örnekleri

LangChain ile geliştirilebilecek pratik proje örneklerini inceleyelim. Bu projeler, öğrendiklerinizi uygulamaya koymanız için mükemmel başlangıç noktaları sunar.

Proje 1: Akıllı Müşteri Destek Botu

RAG ve agent yapısını birleştirerek, şirket bilgi tabanından yanıt üreten ve gerektiğinde destek talebi oluşturan bir bot geliştirebilirsiniz. Bu bot, müşteri sorularını otomatik sınıflandırır, bilgi tabanından ilgili cevabı bulur ve çözemediği soruları insan operatöre yönlendirir.

Proje 2: Kod İnceleme Ajanı

GitHub API'si ile entegre bir ajan oluşturarak pull request'leri otomatik inceleyebilirsiniz. Ajan, kod kalitesi, güvenlik açıkları ve performans sorunlarını tespit eder ve öneriler sunar.

Proje 3: Veri Analiz Asistanı

CSV ve veritabanı dosyalarını analiz eden, grafik oluşturan ve raporlar hazırlayan bir asistan. LangChain'in PandasDataFrameAgent'ı ve SQL araçları bu tür projeler için idealdir:

from langchain_community.utilities import SQLDatabase
from langchain_community.agent_toolkits import SQLDatabaseToolkit

# Veritabanı bağlantısı
db = SQLDatabase.from_uri("sqlite:///satis_verileri.db")
toolkit = SQLDatabaseToolkit(db=db, llm=model)

# SQL Agent oluştur
sql_agent = create_react_agent(model, toolkit.get_tools())

sonuc = sql_agent.invoke({
    "messages": [("human", "Son 3 ayda en çok satan 5 ürünü listele")]
})

Proje 4: Çok Dilli İçerik Üretim Pipeline'ı

LangChain ile çok dilli içerik üretim pipeline'ları oluşturabilirsiniz. LCEL'in paralel işleme özelliğini kullanarak bir içeriği aynı anda birden fazla dile çevirebilir, her dil için SEO optimizasyonu yapabilir ve sonuçları otomatik olarak CMS'e yayınlayabilirsiniz.

11. Sıkça Sorulan Sorular

LangChain ekosistemi hızla gelişmeye devam ediyor ve yapay zeka ajan geliştirme alanında standart haline geliyor. Bu rehberde ele aldığımız temel kavramları ve pratik örnekleri kullanarak kendi AI ajan projelerinizi geliştirmeye bugün başlayabilirsiniz. Chains ile basit iş akışları oluşturup, agents ile dinamik karar verme yeteneği ekleyerek, RAG ile bilgi tabanı entegrasyonu sağlayarak ve LangGraph ile karmaşık multi-agent sistemler kurarak gücünüzü katlayabilirsiniz.

]]>