Çoklu Ajan AI Sistemleri: LangGraph, CrewAI ve MCP ile Üretim Rehberi (2026)

Giriş: Tek Ajandan Çoklu Ajan Mimarisine Geçiş

Yapay zeka ajanları, 2026 yılında yazılım geliştirmenin en hızlı büyüyen alanlarından biri haline geldi. Ama dürüst olmak gerekirse, tek bir ajanın her şeyi üstlendiği monolitik yaklaşımlar artık karmaşık iş süreçlerinde yetmiyor. Bir müşteri destek sistemini düşünün: gelen soruyu anlamak, bilgi tabanını aramak, çözüm üretmek, gerekiyorsa insana yönlendirmek ve sonucu raporlamak — bunların her biri bambaşka uzmanlık alanları. İşte tam bu noktada çoklu ajan (multi-agent) sistemler devreye giriyor.

Peki çoklu ajan sistemi tam olarak ne demek? Aslında fikir oldukça basit: her biri belirli bir rol ve yetkinliğe sahip birden fazla yapay zeka ajanının koordineli biçimde çalışması. Bir ajan araştırma yaparken diğeri analiz eder, bir başkası içerik üretir, bir süpervizör ajan da tüm süreci yönetir. Gerçek hayattaki bir ekip gibi düşünebilirsiniz.

Bu makalede, 2026 itibarıyla en olgun ve üretim ortamına hazır üç temel teknolojiyi — LangGraph, CrewAI ve Model Context Protocol (MCP) — derinlemesine inceleyeceğiz. Pratik kod örnekleriyle birlikte üretim ortamında çoklu ajan orkestrasyonu nasıl kurulur, adım adım göstereceğim.

Çoklu Ajan Sistemlerinin Temel Mimarisi

Çoklu ajan sistemlerini tasarlarken karşınıza üç temel mimari kalıp çıkar. Hangisini seçeceğiniz, projenizin ihtiyaçlarına bağlı.

1. Süpervizör (Supervisor) Mimarisi

Merkezi bir süpervizör ajan, gelen görevleri analiz eder ve uygun alt ajanlara yönlendirir. Her alt ajanın çıktısını değerlendirir, gerekirse görevi yeniden yönlendirebilir. Görev dağılımının önceden tahmin edilemediği karmaşık senaryolarda bu mimari ideal çalışır.

2. Hiyerarşik (Hierarchical) Mimari

Birden fazla süpervizör katmanı içeren bu yaklaşımda, üst düzey süpervizörler stratejik kararlar alırken alt düzey süpervizörler operasyonel görevleri yönetir. Büyük ölçekli kurumsal uygulamalarda sıklıkla tercih edilir.

3. Eşler Arası (Peer-to-Peer) Mimari

Burada merkezi bir koordinatör yok. Ajanlar doğrudan birbirleriyle iletişim kurar, her biri kendi uzmanlık alanına göre görevi devralır ya da aktarır. Yaratıcı iş akışları ve beyin fırtınası senaryolarında oldukça etkili bir yaklaşım.

LangGraph: Graf Tabanlı Ajan Orkestrasyonu

LangGraph, LangChain ekibi tarafından geliştirilen ve ajanları yönlü graf (directed graph) yapısında modelleyen bir orkestrasyon çerçevesi. Her ajan bir düğüm (node), ajanlar arası geçişler ise kenar (edge) olarak tanımlanıyor. Bu yaklaşım sayesinde karmaşık karar ağaçları, koşullu dallanmalar ve döngüsel iş akışlarını çok doğal biçimde ifade edebiliyorsunuz.

LangGraph'ın Temel Avantajları

LangGraph'ı diğer çerçevelerden ayıran üç kritik özellik var:

• Durum Yönetimi (State Management): Paylaşılan, kalıcı durum nesneleri sayesinde ajanlar arası bağlam aktarımı sorunsuz gerçekleşir.
• Checkpoint Mekanizması: İş akışının her adımında durum kaydedilir; bir hata olursa kaldığı yerden devam edebilir. Bu özellik üretim ortamında gerçekten hayat kurtarıcı.
• İnsan Gözetimi (Human-in-the-Loop): Kritik karar noktalarında iş akışı duraklatılarak insan onayı alınabilir.

LangGraph ile Çoklu Ajan Sistemi Kurulumu

Hadi gelin bir örnekle başlayalım. Aşağıda araştırma ajanı ve yazım ajanından oluşan basit bir çoklu ajan sistemi oluşturuyoruz:

from langgraph.graph import StateGraph, MessagesState, START, END
from langgraph.checkpoint.memory import MemorySaver
from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage, SystemMessage
from typing import Annotated, TypedDict, Literal

# Durum tanımı
class AgentState(TypedDict):
    messages: list
    research_data: str
    draft_content: str
    current_agent: str

# LLM yapılandırması
llm = ChatOpenAI(model="gpt-4o", temperature=0.3)

# Araştırma ajanı
def research_agent(state: AgentState) -> AgentState:
    system_msg = SystemMessage(
        content="Sen bir araştırma uzmanısın. Verilen konu hakkında "
                "kapsamlı ve doğru bilgi topla. Kaynaklarını belirt."
    )
    messages = [system_msg] + state["messages"]
    response = llm.invoke(messages)
    return {
        "research_data": response.content,
        "current_agent": "researcher"
    }

# Yazım ajanı
def writer_agent(state: AgentState) -> AgentState:
    system_msg = SystemMessage(
        content="Sen profesyonel bir içerik yazarısın. "
                "Araştırma verilerini kullanarak etkileyici, "
                "doğru ve iyi yapılandırılmış içerik üret."
    )
    writer_prompt = HumanMessage(
        content=f"Araştırma verileri:\n{state['research_data']}\n\n"
                "Bu verilere dayalı kapsamlı bir makale yaz."
    )
    response = llm.invoke([system_msg, writer_prompt])
    return {
        "draft_content": response.content,
        "current_agent": "writer"
    }

# Kalite kontrol yönlendirici
def quality_router(state: AgentState) -> Literal["writer", "end"]:
    if len(state.get("draft_content", "")) < 500:
        return "writer"  # Yetersizse yeniden yaz
    return "end"

# Graf oluşturma
workflow = StateGraph(AgentState)

# Düğüm ekleme
workflow.add_node("researcher", research_agent)
workflow.add_node("writer", writer_agent)

# Kenar tanımlama
workflow.add_edge(START, "researcher")
workflow.add_edge("researcher", "writer")
workflow.add_conditional_edges("writer", quality_router)

# Checkpoint ile derleme
memory = MemorySaver()
app = workflow.compile(checkpointer=memory)

# Çalıştırma
config = {"configurable": {"thread_id": "makale-001"}}
result = app.invoke(
    {"messages": [HumanMessage(content="Yapay zeka etiği")]},
    config=config
)
print(result["draft_content"])

LangGraph'da Süpervizör Kalıbı

Daha karmaşık senaryolarda, bir süpervizör ajanın alt ajanları yönettiği mimari kullanılır. Süpervizör gelen görevi analiz eder ve hangi ajanın görevlendirilmesi gerektiğine karar verir. Bu kalıp, gerçek projelerde en çok karşılaşacağınız yaklaşımlardan biri:

from langgraph.graph import StateGraph, MessagesState, START, END
from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage, SystemMessage
from typing import Literal

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

# Süpervizör ajanı
def supervisor_node(state: MessagesState) -> dict:
    system_msg = SystemMessage(
        content="""Sen bir süpervizör ajansın. Gelen görevi analiz et
        ve uygun ajana yönlendir.
        Seçeneklerin:
        - 'researcher': Bilgi toplama ve araştırma görevleri
        - 'coder': Kod yazma ve teknik görevler
        - 'analyst': Veri analizi ve raporlama görevleri
        - 'FINISH': Tüm görevler tamamlandığında

        Sadece ajan adını döndür."""
    )
    messages = [system_msg] + state["messages"]
    response = llm.invoke(messages)
    return {"messages": [response]}

def route_supervisor(state: MessagesState) -> Literal[
    "researcher", "coder", "analyst", "end"
]:
    last_message = state["messages"][-1].content.strip().lower()
    if "researcher" in last_message:
        return "researcher"
    elif "coder" in last_message:
        return "coder"
    elif "analyst" in last_message:
        return "analyst"
    return "end"

# Alt ajanlar
def researcher_node(state: MessagesState) -> dict:
    response = llm.invoke([
        SystemMessage(content="Sen bir araştırma uzmanısın."),
        *state["messages"]
    ])
    return {"messages": [response]}

def coder_node(state: MessagesState) -> dict:
    response = llm.invoke([
        SystemMessage(content="Sen bir yazılım mühendisisin."),
        *state["messages"]
    ])
    return {"messages": [response]}

def analyst_node(state: MessagesState) -> dict:
    response = llm.invoke([
        SystemMessage(content="Sen bir veri analistisin."),
        *state["messages"]
    ])
    return {"messages": [response]}

# Süpervizör grafiği oluşturma
graph = StateGraph(MessagesState)
graph.add_node("supervisor", supervisor_node)
graph.add_node("researcher", researcher_node)
graph.add_node("coder", coder_node)
graph.add_node("analyst", analyst_node)

graph.add_edge(START, "supervisor")
graph.add_conditional_edges("supervisor", route_supervisor)

# Her alt ajan tamamlandığında süpervizöre dön
graph.add_edge("researcher", "supervisor")
graph.add_edge("coder", "supervisor")
graph.add_edge("analyst", "supervisor")

app = graph.compile()
result = app.invoke({
    "messages": [HumanMessage(
        content="Satış verilerini analiz et ve bir Python dashboard oluştur"
    )]
})

CrewAI: Rol Tabanlı Çoklu Ajan Çerçevesi

CrewAI, gerçek dünyadaki ekip yapılarından esinlenen, rol tabanlı bir çoklu ajan çerçevesi. Bence en güzel yanı şu: her ajana bir "backstory" (geçmiş hikayesi) tanımlıyorsunuz ve ajan bu role bürünüyor. Her ajan belirli bir role, hedeflere ve araçlara sahip; hepsi bir "mürettebat" (crew) içinde organize ediliyor.

CrewAI'nin Temel Kavramları

• Agent (Ajan): Belirli bir rol, hedef ve araçlara sahip yapay zeka birimi
• Task (Görev): Bir ajanın gerçekleştirmesi gereken somut iş birimi
• Crew (Mürettebat): Ajanlar ve görevlerin bir arada yönetildiği üst yapı
• Process (Süreç): Görevlerin yürütülme biçimi — sıralı, hiyerarşik veya paralel

CrewAI ile İçerik Üretim Pipeline'ı

Şimdi somut bir örneğe bakalım. Aşağıdaki kod, araştırmacı, yazar ve editörden oluşan bir içerik üretim pipeline'ı gösteriyor:

from crewai import Agent, Task, Crew, Process
from crewai.tools import SerperDevTool, WebsiteSearchTool

# Araçlar
search_tool = SerperDevTool()
web_tool = WebsiteSearchTool()

# Ajanları tanımlama
researcher = Agent(
    role="Kıdemli Araştırma Analisti",
    goal="Verilen konu hakkında kapsamlı ve güncel bilgi toplamak",
    backstory="""10 yıllık deneyime sahip bir araştırma analistisin.
    Karmaşık konuları basitleştirme ve güvenilir kaynaklardan
    bilgi toplama konusunda uzmansın.""",
    tools=[search_tool, web_tool],
    verbose=True,
    llm="gpt-4o"
)

writer = Agent(
    role="Profesyonel İçerik Yazarı",
    goal="Araştırma verilerini ilgi çekici ve bilgilendirici "
         "makalelere dönüştürmek",
    backstory="""Teknik konuları geniş kitlelere anlatan ödüllü
    bir yazarsın. SEO uyumlu, okunabilir ve değerli
    içerikler üretme konusunda uzmansın.""",
    verbose=True,
    llm="gpt-4o"
)

editor = Agent(
    role="Baş Editör",
    goal="İçeriğin doğruluğunu, tutarlılığını ve kalitesini "
         "sağlamak",
    backstory="""Yıllarca ulusal yayınevlerinde çalışmış deneyimli
    bir editörsün. Dil bilgisi, akıcılık ve içerik
    doğruluğu konusunda titizsin.""",
    verbose=True,
    llm="gpt-4o"
)

# Görevleri tanımlama
research_task = Task(
    description="""'{topic}' konusu hakkında kapsamlı araştırma yap.
    - En az 5 güvenilir kaynak bul
    - Güncel istatistikler ve veriler topla
    - Farklı bakış açılarını ortaya koy
    - Temel bulgularını özetle""",
    expected_output="Kapsamlı araştırma raporu",
    agent=researcher
)

writing_task = Task(
    description="""Araştırma raporunu kullanarak profesyonel
    bir makale yaz.
    - Dikkat çekici bir başlık oluştur
    - Mantıklı bir yapıda organize et
    - Kod örnekleri ve pratik bilgiler ekle
    - Yaklaşık 2000 kelime olsun""",
    expected_output="Tam makale taslağı",
    agent=writer,
    context=[research_task]
)

editing_task = Task(
    description="""Makaleyi gözden geçir ve düzenle.
    - Dil bilgisi ve yazım hatalarını düzelt
    - Teknik doğruluğu kontrol et
    - Akıcılığı ve okunabilirliği artır
    - SEO optimizasyonu öner""",
    expected_output="Düzenlenmiş ve yayına hazır makale",
    agent=editor,
    context=[writing_task]
)

# Mürettebatı oluşturma ve çalıştırma
crew = Crew(
    agents=[researcher, writer, editor],
    tasks=[research_task, writing_task, editing_task],
    process=Process.sequential,
    verbose=True
)

result = crew.kickoff(inputs={"topic": "2026 yapay zeka trendleri"})
print(result)

CrewAI'de Hiyerarşik Süreç

Karmaşık iş akışlarında bir yönetici ajanın alt ajanları koordine ettiği hiyerarşik süreç de kullanılabilir. Burada yönetici ajan otomatik olarak oluşturuluyor ve görev dağılımını dinamik olarak yönetiyor:

from crewai import Crew, Process

# Hiyerarşik süreç ile mürettebat
hierarchical_crew = Crew(
    agents=[researcher, writer, editor],
    tasks=[research_task, writing_task, editing_task],
    process=Process.hierarchical,
    manager_llm="gpt-4o",
    verbose=True
)

# Yönetici ajan otomatik olarak oluşturulur
# ve görev dağılımını dinamik olarak yönetir
result = hierarchical_crew.kickoff(
    inputs={"topic": "Çoklu ajan sistemleri"}
)

Model Context Protocol (MCP): Evrensel Araç Entegrasyon Standardı

Model Context Protocol (MCP), Anthropic tarafından geliştirilen ve 2025 sonlarında Linux Foundation bünyesindeki Agentic AI Foundation'a devredilen açık bir standart. MCP'nin yaptığı şey özünde çok basit: yapay zeka ajanlarının harici araçlara, veritabanlarına ve API'lere standartlaştırılmış bir şekilde erişmesini sağlıyor. 2026 itibarıyla 500'den fazla açık kaynaklı MCP sunucusu mevcut — bu sayı hızla artmaya devam ediyor.

MCP Neden Bu Kadar Önemli?

MCP öncesinde her ajan çerçevesi kendi araç entegrasyon mekanizmasını kullanıyordu. Tahmin edebileceğiniz gibi, bu ciddi sorunlara yol açıyordu:

• Parçalanma: Bir çerçeve için yazılan araç, diğerinde kullanılamıyordu
• Tekrarlı Çaba: Her proje için araç entegrasyonları sıfırdan yazılıyordu
• Güvenlik Boşlukları: Standart olmayan erişim kontrolleri güvenlik açıklarına neden oluyordu

MCP, istemci-sunucu mimarisiyle bu sorunların hepsini çözüyor. Bir MCP sunucusu, belirli bir aracı veya veri kaynağını standart bir arayüz üzerinden sunuyor. Herhangi bir MCP istemcisi (yani ajan) bu sunucuya bağlanıp aracı kullanabiliyor. USB gibi düşünün — tak ve çalıştır.

MCP Sunucusu Oluşturma

Aşağıdaki örnekte, veritabanı sorgulama yeteneği sunan basit bir MCP sunucusu oluşturuyoruz. Dikkat ederseniz güvenlik açısından sadece SELECT sorgularına izin veriyoruz:

from mcp.server.fastmcp import FastMCP
import sqlite3
from datetime import datetime

# MCP sunucusu oluştur
mcp = FastMCP("veritabani-servisi")

@mcp.tool()
def query_database(
    sql_query: str,
    database_path: str = "app.db"
) -> str:
    """Veritabanında SQL sorgusu çalıştırır."""
    # Güvenlik kontrolü - sadece SELECT sorgularına izin ver
    if not sql_query.strip().upper().startswith("SELECT"):
        return "Hata: Sadece SELECT sorguları desteklenir."

    try:
        conn = sqlite3.connect(database_path)
        cursor = conn.cursor()
        cursor.execute(sql_query)
        columns = [desc[0] for desc in cursor.description]
        rows = cursor.fetchall()
        conn.close()

        # Sonuçları formatla
        result = f"Sütunlar: {', '.join(columns)}\n"
        for row in rows:
            result += f"{row}\n"
        return result
    except Exception as e:
        return f"Sorgu hatası: {str(e)}"

@mcp.tool()
def get_table_schema(table_name: str) -> str:
    """Belirtilen tablonun şemasını döndürür."""
    conn = sqlite3.connect("app.db")
    cursor = conn.cursor()
    cursor.execute(f"PRAGMA table_info({table_name})")
    columns = cursor.fetchall()
    conn.close()

    schema = f"Tablo: {table_name}\n"
    for col in columns:
        schema += f"  - {col[1]} ({col[2]})"
        if col[5]:
            schema += " PRIMARY KEY"
        if col[3]:
            schema += " NOT NULL"
        schema += "\n"
    return schema

@mcp.resource("db://tables")
def list_tables() -> str:
    """Veritabanındaki tüm tabloları listeler."""
    conn = sqlite3.connect("app.db")
    cursor = conn.cursor()
    cursor.execute(
        "SELECT name FROM sqlite_master WHERE type='table'"
    )
    tables = cursor.fetchall()
    conn.close()
    return "\n".join(t[0] for t in tables)

if __name__ == "__main__":
    mcp.run()

MCP İstemcisi ile Ajanı Bağlama

MCP sunucusunu bir ajana bağlamak için aşağıdaki gibi bir yapılandırma dosyası kullanılır. Güzel olan şu ki, birden fazla MCP sunucusunu aynı anda tanımlayabilirsiniz:

{
  "mcpServers": {
    "veritabani": {
      "command": "python",
      "args": ["mcp_db_server.py"],
      "env": {
        "DATABASE_PATH": "/path/to/production.db"
      }
    },
    "dosya-sistemi": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "/izin-verilen/dizin"
      ]
    }
  }
}

LangGraph + MCP Entegrasyonu: Üretim Ortamı Mimarisi

LangGraph ve MCP'nin birleşimi, üretim ortamına hazır çoklu ajan sistemleri için gerçekten güçlü bir temel oluşturuyor. LangGraph iş akışı orkestrasyonunu ve durum yönetimini üstlenirken, MCP araçlara standartlaştırılmış erişim sunuyor. İkisini birleştirdiğinizde ortaya oldukça sağlam bir mimari çıkıyor.

Üretim Ortamı için Mimari Tasarım

Şimdi işlerin biraz daha ciddiye bindiği bir örneğe bakalım. Aşağıda müşteri destek senaryosu için LangGraph ve MCP'yi birleştiren tam bir sistem var:

from langgraph.graph import StateGraph, START, END
from langgraph.checkpoint.postgres.aio import AsyncPostgresSaver
from langchain_openai import ChatOpenAI
from langchain_core.messages import HumanMessage, SystemMessage
from langchain_mcp_adapters.client import MultiServerMCPClient
from langgraph.prebuilt import create_react_agent
from typing import TypedDict, Literal
import asyncio

# Durum tanımı
class CustomerSupportState(TypedDict):
    messages: list
    customer_query: str
    ticket_category: str
    knowledge_base_results: str
    proposed_solution: str
    human_approval_needed: bool
    resolution_status: str

# MCP istemcisi yapılandırması
mcp_config = {
    "knowledge_base": {
        "command": "python",
        "args": ["mcp_kb_server.py"]
    },
    "ticket_system": {
        "command": "python",
        "args": ["mcp_ticket_server.py"]
    },
    "crm": {
        "command": "python",
        "args": ["mcp_crm_server.py"]
    }
}

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

async def build_support_system():
    async with MultiServerMCPClient(mcp_config) as mcp_client:
        tools = mcp_client.get_tools()

        # Sınıflandırma ajanı
        def classify_agent(state: CustomerSupportState):
            response = llm.invoke([
                SystemMessage(content="""Müşteri sorgusunu analiz et
                ve kategorize et:
                - billing: Fatura ve ödeme sorunları
                - technical: Teknik destek
                - account: Hesap yönetimi
                - general: Genel sorular"""),
                HumanMessage(content=state["customer_query"])
            ])
            return {
                "ticket_category": response.content.strip(),
                "messages": state["messages"]
            }

        # Bilgi tabanı arama ajanı
        async def search_agent(state: CustomerSupportState):
            kb_agent = create_react_agent(
                llm,
                tools=[t for t in tools if "knowledge" in t.name]
            )
            result = await kb_agent.ainvoke({
                "messages": [HumanMessage(
                    content=f"Şu sorunu ara: {state['customer_query']}"
                )]
            })
            return {
                "knowledge_base_results": (
                    result["messages"][-1].content
                )
            }

        # Çözüm üretme ajanı
        def solution_agent(state: CustomerSupportState):
            response = llm.invoke([
                SystemMessage(content="""Bilgi tabanı sonuçlarını
                kullanarak müşteriye uygun bir çözüm öner."""),
                HumanMessage(
                    content=f"Sorun: {state['customer_query']}\n"
                    f"Kategori: {state['ticket_category']}\n"
                    f"Bilgi: {state['knowledge_base_results']}"
                )
            ])
            needs_approval = (
                state["ticket_category"] in ["billing", "account"]
            )
            return {
                "proposed_solution": response.content,
                "human_approval_needed": needs_approval
            }

        # Yönlendirme mantığı
        def approval_router(
            state: CustomerSupportState
        ) -> Literal["human_review", "auto_resolve"]:
            if state["human_approval_needed"]:
                return "human_review"
            return "auto_resolve"

        # Grafı oluştur
        workflow = StateGraph(CustomerSupportState)
        workflow.add_node("classify", classify_agent)
        workflow.add_node("search", search_agent)
        workflow.add_node("solve", solution_agent)
        workflow.add_node("human_review", lambda s: {
            "resolution_status": "awaiting_human_review"
        })
        workflow.add_node("auto_resolve", lambda s: {
            "resolution_status": "resolved"
        })

        workflow.add_edge(START, "classify")
        workflow.add_edge("classify", "search")
        workflow.add_edge("search", "solve")
        workflow.add_conditional_edges(
            "solve", approval_router
        )
        workflow.add_edge("human_review", END)
        workflow.add_edge("auto_resolve", END)

        # Üretim ortamı checkpoint
        checkpointer = AsyncPostgresSaver.from_conn_string(
            "postgresql://user:pass@localhost/agents_db"
        )
        return workflow.compile(checkpointer=checkpointer)

# Sistemi çalıştır
async def main():
    app = await build_support_system()
    result = await app.ainvoke(
        {
            "messages": [],
            "customer_query": "Faturamda yanlış tutar var",
            "human_approval_needed": False,
            "resolution_status": "pending"
        },
        config={"configurable": {"thread_id": "ticket-42"}}
    )
    print(f"Durum: {result['resolution_status']}")
    print(f"Çözüm: {result['proposed_solution']}")

asyncio.run(main())

İnsan Gözetimi (Human-in-the-Loop) Entegrasyonu

Üretim ortamında çalışan yapay zeka ajanlarının kritik kararlarında insan onayı almak, hem güvenlik hem de güvenilirlik açısından olmazsa olmaz. Açıkçası, otonom ajanların her kararı kendi başına vermesini istemezsiniz — özellikle parayla veya hassas verilerle ilgili işlemlerde. LangGraph'ın interrupt mekanizması bu ihtiyacı gayet güzel karşılıyor.

Dinamik Kesme (Dynamic Interrupt) ile İnsan Onayı

from langgraph.types import interrupt, Command
from langgraph.graph import StateGraph, START, END
from langgraph.checkpoint.memory import MemorySaver

def sensitive_action_node(state):
    """Hassas işlemler için insan onayı ister."""
    action = state.get("proposed_action", "")

    # İnsan onayı iste
    human_response = interrupt({
        "question": f"Şu işlem onayınızı bekliyor:\n{action}",
        "options": ["Onayla", "Reddet", "Düzenle"]
    })

    if human_response == "Onayla":
        return {
            "action_status": "approved",
            "messages": state["messages"]
        }
    elif human_response == "Reddet":
        return {
            "action_status": "rejected",
            "messages": state["messages"]
        }
    else:
        return {
            "action_status": "needs_edit",
            "messages": state["messages"]
        }

# Graf oluştur ve interrupt noktası ekle
graph = StateGraph(dict)
graph.add_node("analyze", analyze_node)
graph.add_node("sensitive_action", sensitive_action_node)
graph.add_node("execute", execute_node)

graph.add_edge(START, "analyze")
graph.add_edge("analyze", "sensitive_action")
graph.add_edge("sensitive_action", "execute")
graph.add_edge("execute", END)

checkpointer = MemorySaver()
app = graph.compile(checkpointer=checkpointer)

# İlk çalıştırma - interrupt noktasında duracak
config = {"configurable": {"thread_id": "tx-001"}}
result = app.invoke(
    {"proposed_action": "1000 TL iade işlemi"},
    config=config
)

# İnsan onayıyla devam ettirme
result = app.invoke(
    Command(resume="Onayla"),
    config=config
)

LangGraph ve CrewAI Karşılaştırması: Hangisini Seçmelisiniz?

Her iki çerçeve de çoklu ajan sistemleri oluşturmak için güçlü araçlar sunuyor ama farklı kullanım senaryoları için optimize edilmişler. Doğru seçimi yapabilmeniz için aşağıdaki karşılaştırma tablosunu hazırladım:

Özellik	LangGraph	CrewAI
Mimari Yaklaşım	Graf tabanlı, düşük seviye	Rol tabanlı, yüksek seviye
Öğrenme Eğrisi	Dik — graf düşünce modeli gerektirir	Düşük — sezgisel kavramlar
Durum Yönetimi	Gelişmiş, checkpoint destekli	Temel düzeyde
İnsan Gözetimi	Yerleşik interrupt desteği	Sınırlı, özel uygulama gerekir
Esneklik	Çok yüksek — her türlü iş akışı	Orta — rol tabanlı senaryolar
Üretim Hazırlığı	Yüksek — Klarna, Replit kullanıyor	Orta-Yüksek
Performans	En düşük gecikme süresi	Orta
İdeal Kullanım	Karmaşık, durumsal iş akışları	Ekip benzeri işbirliği senaryoları

Ne Zaman LangGraph Kullanmalısınız?

• Karmaşık koşullu dallanmalar ve döngüler içeren iş akışlarında
• Üretim ortamında checkpoint ve hata kurtarma gerektiğinde
• İnsan gözetiminin kritik olduğu senaryolarda
• Maksimum performans ve düşük gecikme istediğinizde
• İş akışının görselleştirilmesi ve izlenmesi önemliyse

Ne Zaman CrewAI Kullanmalısınız?

• Rol tabanlı, ekip benzeri işbirliği senaryolarında
• Hızlı prototipleme ve MVP geliştirmede
• Araştırma-yazım-düzenleme gibi sıralı pipeline'larda
• Düşük öğrenme eğrisi sizin için önemliyse
• ReAct tabanlı ajan davranışının yeterli olduğu durumlarda

Kişisel deneyimime dayanarak şunu söyleyebilirim: eğer projeniz karmaşık ve uzun vadeli bir üretim sistemi olacaksa, LangGraph'ın dik öğrenme eğrisine katlanmaya değer. Ama hızlıca bir prototip çıkarmak istiyorsanız, CrewAI ile birkaç saat içinde çalışan bir sistem kurabilirsiniz.

Üretim Ortamında En İyi Uygulamalar

Çoklu ajan sistemlerini üretim ortamına taşırken dikkat etmeniz gereken birkaç kritik nokta var. Bunları atlamak, ileride başınızı ciddi şekilde ağrıtabilir.

1. Gözlemlenebilirlik (Observability)

Her ajanın giriş-çıkışını, karar mantığını ve performans metriklerini izlemek zorunlu. "Ajan neden bu kararı verdi?" sorusuna cevap veremiyorsanız, üretim ortamında sıkıntı yaşarsınız. LangSmith veya benzeri araçlarla ajan izleme altyapısı kurun:

import os

# LangSmith izleme yapılandırması
os.environ["LANGCHAIN_TRACING_V2"] = "true"
os.environ["LANGCHAIN_API_KEY"] = "ls-your-api-key"
os.environ["LANGCHAIN_PROJECT"] = "coklu-ajan-uretim"

# Özel metrik toplama
from langsmith import traceable

@traceable(name="agent_execution", tags=["production"])
def monitored_agent_call(agent, input_data):
    """İzlenebilir ajan çağrısı."""
    result = agent.invoke(input_data)
    return result

2. Hata Yönetimi ve Geri Dönüş Stratejileri

Üretim ortamında ajanlar hata yapabilir (ve yapacaklardır). Buna hazırlıklı olmanız gerekiyor. Geri dönüş (fallback) mekanizmaları kurmak şart:

from langchain_core.runnables import RunnableWithFallbacks

# Birincil ve yedek LLM yapılandırması
primary_llm = ChatOpenAI(model="gpt-4o", request_timeout=30)
fallback_llm = ChatOpenAI(model="gpt-4o-mini", request_timeout=60)

# Otomatik geri dönüş
resilient_llm = primary_llm.with_fallbacks([fallback_llm])

# Yeniden deneme ile
from tenacity import retry, stop_after_attempt, wait_exponential

@retry(
    stop=stop_after_attempt(3),
    wait=wait_exponential(multiplier=1, min=2, max=10)
)
def robust_agent_call(agent, state):
    """Yeniden deneme mekanizmalı ajan çağrısı."""
    return agent.invoke(state)

3. Güvenlik Katmanları

Ajan çıktılarını filtrelemek ve girişleri doğrulamak için koruma katmanları (guardrails) eklemeyi kesinlikle ihmal etmeyin. Özellikle prompt injection saldırıları ve hassas veri sızıntısı konusunda dikkatli olun:

def input_guardrail(state: dict) -> dict:
    """Giriş doğrulama katmanı."""
    user_input = state.get("user_query", "")

    # Prompt injection kontrolü
    dangerous_patterns = [
        "ignore previous instructions",
        "system prompt",
        "önceki talimatları unut"
    ]
    for pattern in dangerous_patterns:
        if pattern.lower() in user_input.lower():
            return {
                "blocked": True,
                "reason": "Potansiyel prompt injection tespit edildi"
            }

    # Uzunluk sınırı
    if len(user_input) > 10000:
        return {
            "blocked": True,
            "reason": "Giriş çok uzun"
        }

    return {"blocked": False, "sanitized_input": user_input}

def output_guardrail(state: dict) -> dict:
    """Çıkış filtreleme katmanı."""
    output = state.get("agent_output", "")

    # Hassas veri sızıntısı kontrolü
    import re
    patterns = {
        "kredi_kart": r"\b\d{4}[\s-]?\d{4}[\s-]?\d{4}[\s-]?\d{4}\b",
        "tc_kimlik": r"\b\d{11}\b",
        "email": r"\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b"
    }

    for name, pattern in patterns.items():
        if re.search(pattern, output):
            output = re.sub(pattern, f"[{name} GİZLENDİ]", output)

    return {"filtered_output": output}

4. Maliyet Optimizasyonu

Çoklu ajan sistemleri birden fazla LLM çağrısı gerektirdiğinden, maliyetler hızla artabilir. Bunu kontrol altında tutmak için bazı stratejiler:

• Ajan Seviyeli Model Seçimi: Her ajan için göreve uygun modeli kullanın. Sınıflandırma ajanı için GPT-4o-mini yeterliyken, karmaşık analiz için GPT-4o kullanın. Bu tek başına ciddi tasarruf sağlar.
• Önbellek (Cache) Mekanizması: Tekrarlayan sorgular için sonuçları önbelleğe alın.
• Token Bütçesi: Her ajan için maksimum token limiti belirleyin.
• Paralel Yürütme: Bağımsız ajanları paralel çalıştırarak toplam süreyi (ve dolaylı olarak maliyeti) azaltın.

2026 Trendleri ve Gelecek Perspektifi

Çoklu ajan AI sistemleri alanında 2026'da öne çıkan bazı trendlere de kısaca değinmek istiyorum.

MCP'nin Evrenselleşmesi

OpenAI'nin Assistants API'yi 2026 ortasında sonlandıracağını duyurması, MCP tabanlı mimarilere geçişi zorunlu kıldı. Bu da MCP'yi fiilen endüstri standardı haline getirdi. Artık LangGraph, CrewAI, AutoGen ve diğer çerçevelerin tamamı MCP'yi destekliyor.

Ajandan Ajana İletişim

MCP'nin 2026 yol haritasında ilginç bir gelişme var: MCP sunucularının birer ajan gibi davranabilmesi planlanıyor. Bu ne demek? Bir "Seyahat Ajanı" MCP sunucusu, bir "Rezervasyon Ajanı" MCP sunucusuyla otonom olarak pazarlık yapabilecek. Açıkçası bu biraz bilim kurgu gibi geliyor ama teknoloji hızla o yöne ilerliyor.

Çok Modlu Ajan Yetenekleri

2026'da MCP, görüntü, video, ses ve diğer medya türlerini desteklemeye başlıyor. Yani ajanlar sadece metin okuyup yazmakla kalmayacak, aynı zamanda görebilecek ve duyabilecek. Bu, kullanım senaryolarını kökten değiştirecek bir gelişme.

Gelişmiş Güvenlik ve Yönetişim

Ajanların hassas görevleri güvenli ve sorumlu biçimde yerine getirmesi için daha güçlü izin kontrolleri uygulanıyor. MCP'nin açık yönetişim modeli, şeffaf standartlar ve karar alma süreçleri sunuyor — bu da kurumsal benimseme için kritik bir faktör.

Sonuç

Çoklu ajan AI sistemleri, 2026'da yazılım geliştirmenin vazgeçilmez bir parçası haline geldi. LangGraph'ın graf tabanlı orkestrasyon gücü, CrewAI'nin sezgisel rol tabanlı yaklaşımı ve MCP'nin evrensel araç entegrasyon standardı bir araya geldiğinde, gerçekten karmaşık iş süreçlerini otomatize eden güçlü ve güvenilir sistemler inşa etmek mümkün oluyor.

Doğru çerçeveyi seçerken projenizin gereksinimlerini iyi değerlendirin: karmaşık durumsal iş akışları için LangGraph, ekip benzeri işbirliği senaryoları için CrewAI ve araç entegrasyonunu standartlaştırmak için MCP. Üretim ortamına geçerken gözlemlenebilirlik, hata yönetimi, güvenlik katmanları ve maliyet optimizasyonunu kesinlikle ihmal etmeyin.

Benim önerim? Küçük bir prototiple başlayın. Bu makalede gösterilen kalıpları kendi kullanım senaryonuza uyarlayın. Checkpoint mekanizması, insan gözetimi ve MCP araç entegrasyonu gibi üretim özelliklerini adım adım ekleyin. İlk çalışan sisteminizi gördüğünüzde, çoklu ajan mimarisinin gücünü bizzat deneyimleyeceksiniz.