AI Genel Çalışma Rehberi

Blog / Karşılaştırma

A2A ve ACP: Yapay Zekâ Ajanlarının Ortak Dili

20 dk okumaA2AACPMulti-AgentMCP

Düşünsenize, bir şirketin işe alım sürecini otomatize eden bir yapay zeka ajanınız var. Bu ajan LinkedIn'de aday ararken başka bir ajan mülakatları planlıyor, bir diğeri referans kontrolü yapıyor. Peki bu ajanlar birbirleriyle nasıl konuşuyor? İşte tam burada Agent-to-Agent (A2A) ve Agent Communication Protocol (ACP) devreye giriyor.

Bu yazıda, Google ve IBM'in multi-agent sistemler için geliştirdiği protokolleri derinlemesine inceleyeceğiz. Model Context Protocol (MCP) ile ilişkilerini anlayacak ve gerçek dünya senaryolarıyla bu protokollerin nasıl kullanıldığını göreceğiz.

TL;DR - Hızlı Özet

1. Giriş

1.1 Neden Bu Protokollere İhtiyaç Duyuldu?

2024 yılına kadar, yapay zeka ajanları genellikle tek başına çalışan monolitik sistemlerdi. Bir chatbot müşteri sorularını yanıtlıyordu, bir asistan e-postaları sınıflandırıyordu, bir planlayıcı takvim yönetiyordu. Her biri kendi dünyasında yaşıyordu.

Ama gerçek dünya problemleri nadiren tek bir ajanın çözebileceği kadar basittir. Kurumsal bir süreç düşünün: bir müşteri şikayeti alındığında, CRM sistemine kaydedilmeli, ilgili departmana yönlendirilmeli, müşteriye bildirim gönderilmeli, takip süreci başlatılmalı. Bu, en az 4 farklı ajanın koordineli çalışmasını gerektiriyor.

İşte bu noktada, ajanların birbirleriyle standart bir şekilde iletişim kurması kritik hale geliyor. Her şirket kendi protokolünü geliştirirse:

Bu soruna çözüm olarak Google Agent-to-Agent (A2A) protokolünü, IBM ise Agent Communication Protocol (ACP)'yi geliştirdi. 2025 yılında bu iki protokol birleşerek A2A adı altında tek bir standart haline geldi.

1.2 Bu Makalede Neler Öğreneceğiz?

Bu kapsamlı rehberde şu konuları ele alacağız:

  1. Temel kavramlar: Agent, multi-agent sistem, orkestrasyon nedir?
  2. A2A protokolü: Google'ın yaklaşımı, mimari, özellikler
  3. ACP protokolü: IBM'in katkıları, BeeAI platformu
  4. Birleşme süreci: İki protokolün nasıl tek çatı altında toplandığı
  5. MCP ile ilişki: Neden iki protokole birden ihtiyaç duyuyoruz?
  6. Paket yapıları: Mesajların teknik detayları
  7. Kod örnekleri: Python ile pratik implementasyonlar
  8. Gerçek hayat senaryoları: İşe alım, e-ticaret, tedarik zinciri
  9. Sık yapılan hatalar: Yanlış anlamalar ve doğruları

2. Temel Kavramlar

2.1 Agent (Ajan) Nedir?

Agent (Ajan), bir hedefe ulaşmak için otonom olarak hareket edebilen yazılım bileşenidir. Klasik bir programdan farkı:

Klasik Program:

Agent (Ajan):

Ajan özellikleri:

Ajanın düşünce döngüsü:

1. Gözlem Yap (Observe)

2. Karar Ver (Decide)

3. Eylem Yap (Act)

2.2 Multi-Agent Sistem Nedir?

Multi-Agent System (Çok-Ajanlı Sistem), birden fazla ajanın birlikte çalıştığı ve etkileşimde bulunduğu sistemdir.

Örnek senaryo - Akıllı Ev Sistemi:

Bu ajanlar birbirinden haberdar olmalı. Örneğin:

Multi-agent sistemin avantajları:

2.3 Orchestration (Orkestrasyon) vs. Choreography (Koreografi)

Multi-agent sistemlerde iki temel koordinasyon yaklaşımı vardır:

Orchestration (Orkestrasyon) - Merkezi Koordinasyon:

Orchestrator Agent (Orkestratör)

Özellikler:

Choreography (Koreografi) - Dağıtık Koordinasyon:

Event Bus (Merkezi Mesaj Yolu)

Tüm ajanlar Event Bus üzerinden birbirleriyle haberleşir

Özellikler:

A2A her iki yaklaşımı da destekler. Bazı sistemlerde bir Orchestrator Agent tüm süreci yönetirken, bazılarında ajanlar peer-to-peer iletişim kurar.

2.4 Task (Görev) ve Context (Bağlam)

A2A'nın temel iş birimi Task'tır.

Task (Görev): Bir ajanın yerine getirmesi istenen spesifik bir iş.

Task yaşam döngüsü:

1. PENDING (Beklemede)

2. WORKING (İşleniyor)

3a. COMPLETED (Tamamlandı)

VEYA

3b. FAILED (Başarısız)

Context (Bağlam): İlişkili görevleri gruplandıran UUID tanımlayıcısı.

Örneğin, bir e-ticaret siparişi işlenirken:

Tüm bu görevler aynı contextId ile ilişkilendirilir, böylece hangi görevlerin aynı sürecin parçası olduğu takip edilebilir.

3. A2A (Agent-to-Agent) Protokolü

3.1 A2A'nın Tarihçesi ve Yönetimi

Agent-to-Agent (A2A) Protokolü, Google tarafından geliştirilmiş ve Linux Foundation bünyesinde yönetilen açık kaynaklı bir standarttır.

Kilometre taşları:

Neden önemli?

A2A, sadece bir "fikir" veya "mimari yaklaşım" değil, resmi bir standarttır:

3.2 Agent Card: Ajanın Kimlik Kartı

A2A'da her ajan, yeteneklerini tanımlayan bir Agent Card yayınlar. Bu, REST API'lerdeki OpenAPI/Swagger spesifikasyonuna benzer.

Agent Card nerede bulunur?

https://agent-domain.com/.well-known/agent.json

Örnek Agent Card:

{
  "protocolVersion": "1.0",
  "name": "Müşteri Destek Ajanı",
  "description": "Müşteri sorularını yanıtlar ve destek taleplerini yönetir",
  "version": "2.1.0",
  "provider": {
    "organization": "Acme Corp",
    "url": "https://acme.com"
  },
  "supportedInterfaces": [
    {
      "url": "https://support-agent.acme.com/a2a",
      "protocolBinding": "JSONRPC"
    }
  ],
  "capabilities": {
    "streaming": true,
    "pushNotifications": false,
    "stateTransitionHistory": true
  },
  "defaultInputModes": ["text/plain", "text/markdown"],
  "defaultOutputModes": ["text/plain", "application/json"],
  "skills": [
    {
      "id": "ticket-creation",
      "name": "Destek Talebi Oluşturma",
      "description": "Müşteri şikayetlerinden destek talebi oluşturur",
      "tags": ["support", "crm"],
      "examples": [
        "Ürün hasar görmüş olarak geldi",
        "Sipariş takip numarası çalışmıyor"
      ]
    }
  ]
}

Agent Card bölümleri:

3.3 Task Lifecycle: Görev Yaşam Döngüsü

A2A'da bir görev şu aşamalardan geçer:

1. Task Oluşturma:

Client, ajana mesaj göndererek task başlatır:

POST /v1/message:send

2. Task İşleme:

Ajan, görevi alır ve işlemeye başlar. Durum working olarak güncellenir.

3. Progress Updates (İlerleme Güncellemeleri):

Uzun süren görevlerde ajan periyodik olarak ilerleme bilgisi gönderebilir:

{
  "statusUpdate": {
    "state": "working",
    "progressPercent": 45,
    "message": "Veritabanı taraması devam ediyor..."
  }
}

4. Task Tamamlama:

Görev bittiğinde ajan completed durumunu ve sonuçları döner.

İki görev modu:

Blocking Mode (Senkron):

sequenceDiagram participant Client participant Agent Client->>Agent: Send Message Agent-->>Client: Task Result (final) Note over Client: Client bekler, cevap gelene kadar

Non-Blocking Mode (Asenkron):

sequenceDiagram participant Client participant Agent Client->>Agent: Send Message Agent-->>Client: Task ID (hemen döner) Note over Client: Daha sonra Client->>Agent: GET /tasks/{id} Agent-->>Client: Task Result

3.4 Protocol Bindings: Farklı Transport Katmanları

A2A, farklı transport protokolleri üzerinden çalışabilir:

JSON-RPC over HTTP:

gRPC:

GraphQL:

WebSocket:

Hangi binding'i seçmeli?

4. ACP (Agent Communication Protocol)

4.1 IBM'in Yaklaşımı: ACP'nin Doğuşu

Agent Communication Protocol (ACP), IBM Research tarafından geliştirildi. IBM, özellikle kurumsal çok-ajanlı sistemler için tasarım yapmaya odaklandı.

ACP'nin özgün özellikleri:

ACP'nin güçlü yönleri:

4.2 BeeAI Platform

IBM, ACP'yi BeeAI platformunda somutlaştırdı. BeeAI, multi-agent sistemlerin geliştirilmesini kolaylaştıran bir framework'tür.

BeeAI bileşenleri:

Bee Agent Framework:

Bee Agent Hub:

BeeAI Orchestrator:

BeeAI mimarisi:

BeeAI Platform Katmanları:

Üst Katman - Orchestrator (Koordinatör)

Orta Katman - Agent'lar

İletişim Katmanı - Message Bus

Alt Katman - Kaynaklar

4.3 ACP ve A2A Birleşmesi (Ağustos 2025)

Neden birleştiler?

İki ayrı standardın olması:

Birleşme süreci:

  1. Nisan-Mayıs 2025: Google ve IBM teknik komite oluşturdu
  2. Haziran 2025: Ortak spesifikasyon taslağı hazırlandı
  3. Temmuz 2025: Topluluk geri bildirimleri alındı
  4. Ağustos 2025: A2A v0.9 yayınlandı (ACP özellikleri dahil)
  5. Ekim 2025: A2A v1.0 finalize edildi

ACP'den A2A'ya geçenler:

BeeAI'nin güncel durumu:

BeeAI, artık A2A protokolünü kullanıyor. Eski ACP API'leri deprecated (kullanımdan kaldırılmış) olarak işaretlendi ve 2026 ortasında tamamen kaldırılacak.

5. A2A ve ACP Arasındaki Farklar (Tarihsel)

Bu bölüm artık tarihi bir karşılaştırma, çünkü ACP, A2A ile birleşti. Ancak eski sistemleri anlayabilmek için farkları bilmek önemli.

İletişim modeli:

Mesaj formatı:

Transport:

State yönetimi:

Güvenlik:

Hedef kitle:

Birleşme sonrası durum:

Artık tek bir protokol var: A2A. Bu protokol, her iki yaklaşımın güçlü yönlerini birleştiriyor.

6. MCP (Model Context Protocol) ile İlişki

6.1 MCP Nedir? (Kısa Hatırlatma)

Model Context Protocol (MCP), Anthropic tarafından geliştirilen ve ajanların dış araçlara/kaynaklara erişmesini standartlaştıran bir protokoldür.

MCP'nin temel amacı:

Bir ajanın (örneğin Claude), veritabanlarına, API'lere, dosya sistemlerine erişmesini kolaylaştırmak.

MCP mimari yapısı:

AI Agent (Claude)

MCP Server (Araçlar)

6.2 A2A vs. MCP: Hangi Katmanda Çalışırlar?

A2A ve MCP birbirinin rakibi değil, tamamlayıcısıdır.

Dikey Entegrasyon (MCP):

flowchart TB Agent["Agent (üst katman)"] MCP["MCP Protocol"] Tools["Tools/Resources (alt katman)"] Agent --> MCP --> Tools

MCP, bir ajanın "aşağı" doğru araçlara erişimini sağlar.

Yatay Entegrasyon (A2A):

flowchart LR A["Agent A"] <--> |"A2A Protocol"| B["Agent B"] B <--> |"A2A Protocol"| C["Agent C"]

A2A, ajanların "yatay" olarak birbirleriyle iletişimini sağlar.

6.3 A2A + MCP Birlikte Kullanım Senaryosu

Çoğu karmaşık sistem her ikisini de kullanır.

Örnek: Kurumsal Müşteri Destek Sistemi

Üst Katman:

Agent Katmanı (A2A ile birbirine bağlı):

Veri Katmanı (MCP üzerinden erişim):

Akış örneği:

  1. Müşteri sorusu gelir: "Siparişim nerede?"
  2. Orchestrator Agent, Ticket Agent'a A2A ile görev atar
  3. Ticket Agent, MCP ile CRM veritabanını sorgular
  4. Sipariş bilgisi bulunamazsa, FAQ Agent'a A2A ile sorar
  5. FAQ Agent, MCP ile Knowledge Base'i arar
  6. Sonuç bulunursa Analytics Agent'a A2A ile bildirir
  7. Analytics Agent, MCP ile istatistikleri günceller
  8. Final cevap müşteriye döner

Özet:

7. Paket Yapıları ve Akışlar

7.1 Basit Görev Akışı (Non-Streaming)

Senaryo: Client, ajana mesaj gönderir, ajan anında cevap verir.

Adım 1: Mesaj Gönder

POST /v1/message:send
Content-Type: application/a2a+json

İstek:

{
  "message": {
    "messageId": "msg-001",
    "role": "user",
    "parts": [
      {
        "text": "Bugün hava nasıl?"
      }
    ]
  },
  "configuration": {
    "blocking": true
  }
}

Adım 2: Task Cevabı

{
  "id": "task-abc-123",
  "contextId": "ctx-weather-query",
  "status": {
    "state": "completed",
    "timestamp": "2026-01-03T10:30:00Z"
  },
  "artifacts": [
    {
      "artifactId": "weather-report",
      "name": "Hava Durumu",
      "parts": [
        {
          "text": "Bugün İstanbul'da güneşli, 18°C"
        }
      ]
    }
  ],
  "history": [
    {
      "messageId": "msg-001",
      "role": "user",
      "parts": [{"text": "Bugün hava nasıl?"}]
    },
    {
      "messageId": "msg-002",
      "role": "agent",
      "parts": [{"text": "Hava durumunu sorguluyorum..."}]
    }
  ]
}

7.2 Streaming Akışı (Uzun Süren Görevler)

Uzun süren görevler için streaming desteği:

Client ile Server arasındaki akış:

sequenceDiagram participant C as Client participant S as Server (A2A agent) C->>S: POST /v1/message:stream Note over C,S: Bağlantı açık kalır, cevaplar SSE olayları olarak akar S-->>C: SSE · task {id: "t1", status: "working"} S-->>C: SSE · statusUpdate {state: "working"} S-->>C: SSE · artifactUpdate {artifact: …} S-->>C: SSE · statusUpdate {state: "completed", final: true} Note over C,S: final: true → bağlantı kapanır

7.3 Mesaj Yapıları

SendMessageRequest:

{
  "message": {
    "messageId": "msg-uuid-123",
    "role": "user",
    "parts": [
      {
        "text": "Stok durumunu kontrol et: SKU-12345"
      }
    ],
    "contextId": "ctx-uuid-456"
  },
  "configuration": {
    "acceptedOutputModes": ["text/plain", "application/json"],
    "blocking": false,
    "historyLength": 10
  },
  "metadata": {
    "requestSource": "web-app",
    "priority": "normal"
  }
}

Task Response:

{
  "id": "task-uuid-789",
  "contextId": "ctx-uuid-456",
  "status": {
    "state": "completed",
    "timestamp": "2026-01-03T14:30:00Z"
  },
  "artifacts": [
    {
      "artifactId": "artifact-001",
      "name": "Stok Raporu",
      "parts": [
        {
          "data": {
            "sku": "SKU-12345",
            "productName": "Laptop Stand",
            "currentStock": 42,
            "reorderLevel": 50,
            "status": "LOW_STOCK"
          }
        }
      ]
    }
  ],
  "history": [
    {
      "messageId": "msg-uuid-123",
      "role": "user",
      "parts": [{"text": "Stok durumunu kontrol et: SKU-12345"}]
    },
    {
      "messageId": "msg-uuid-124",
      "role": "agent",
      "parts": [{"text": "Stok kontrolü tamamlandı. Detaylar artifact'ta."}]
    }
  ]
}

8. Kod Örnekleri

8.1 Basit A2A Server (Python)

Aşağıdaki örnek, temel bir A2A sunucusunun nasıl oluşturulacağını gösterir:

"""
Basit A2A Server Örneği
Bu örnek öğretici amaçlıdır ve production-ready değildir.
"""
 
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from typing import Optional, List, Dict, Any
from datetime import datetime
import uuid
 
app = FastAPI()
 
# Veri modelleri
class Part(BaseModel):
    text: Optional[str] = None
    data: Optional[Dict[str, Any]] = None
 
class Message(BaseModel):
    messageId: str
    role: str
    parts: List[Part]
    contextId: Optional[str] = None
    taskId: Optional[str] = None
 
class SendMessageConfiguration(BaseModel):
    acceptedOutputModes: Optional[List[str]] = None
    blocking: Optional[bool] = False
 
class SendMessageRequest(BaseModel):
    message: Message
    configuration: Optional[SendMessageConfiguration] = None
    metadata: Optional[Dict[str, Any]] = None
 
class TaskStatus(BaseModel):
    state: str
    timestamp: str
 
class Artifact(BaseModel):
    artifactId: str
    name: Optional[str] = None
    parts: List[Part]
 
class Task(BaseModel):
    id: str
    contextId: str
    status: TaskStatus
    artifacts: Optional[List[Artifact]] = None
    history: Optional[List[Message]] = None
 
# Bellekte task deposu
tasks_db: Dict[str, Task] = {}
 
# Agent Card endpoint
@app.get("/.well-known/agent.json")
async def get_agent_card():
    return {
        "protocolVersion": "1.0",
        "name": "Stok Kontrol Ajanı",
        "description": "Ürün stok durumlarını kontrol eder",
        "version": "1.0.0",
        "capabilities": {
            "streaming": False,
            "pushNotifications": False
        },
        "defaultInputModes": ["text/plain"],
        "defaultOutputModes": ["text/plain", "application/json"],
        "skills": [
            {
                "id": "check-stock",
                "name": "Stok Kontrolü",
                "description": "Belirtilen SKU için stok durumunu döner",
                "tags": ["stock", "inventory"]
            }
        ]
    }
 
# Mesaj gönderme endpoint
@app.post("/v1/message:send")
async def send_message(request: SendMessageRequest) -> Task:
    # Yeni task oluştur
    task_id = str(uuid.uuid4())
    context_id = request.message.contextId or str(uuid.uuid4())
    
    # Basit stok kontrolü simülasyonu
    user_text = request.message.parts[0].text if request.message.parts else ""
    
    # Sahte stok verisi
    stock_data = {
        "sku": "SKU-12345",
        "productName": "Laptop Stand",
        "currentStock": 42,
        "status": "AVAILABLE"
    }
    
    # Task oluştur
    task = Task(
        id=task_id,
        contextId=context_id,
        status=TaskStatus(
            state="completed",
            timestamp=datetime.utcnow().isoformat() + "Z"
        ),
        artifacts=[
            Artifact(
                artifactId=str(uuid.uuid4()),
                name="Stok Bilgisi",
                parts=[Part(data=stock_data)]
            )
        ],
        history=[
            request.message,
            Message(
                messageId=str(uuid.uuid4()),
                role="agent",
                parts=[Part(text="Stok kontrolü tamamlandı.")]
            )
        ]
    )
    
    # Kaydet ve döndür
    tasks_db[task_id] = task
    return task
 
# Task sorgulama endpoint
@app.get("/v1/tasks/{task_id}")
async def get_task(task_id: str) -> Task:
    if task_id not in tasks_db:
        raise HTTPException(status_code=404, detail="Task not found")
    return tasks_db[task_id]
 
if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)

8.2 A2A Client Örneği (Python)

"""
Basit A2A Client Örneği
"""
 
import requests
import json
from typing import Optional, Dict, Any
 
class A2AClient:
    def __init__(self, base_url: str):
        self.base_url = base_url.rstrip('/')
        self.agent_card = None
    
    def discover(self) -> Dict[str, Any]:
        """Agent Card'ı keşfet"""
        response = requests.get(f"{self.base_url}/.well-known/agent.json")
        response.raise_for_status()
        self.agent_card = response.json()
        return self.agent_card
    
    def send_message(
        self, 
        text: str, 
        context_id: Optional[str] = None,
        blocking: bool = True
    ) -> Dict[str, Any]:
        """Ajana mesaj gönder"""
        import uuid
        
        payload = {
            "message": {
                "messageId": str(uuid.uuid4()),
                "role": "user",
                "parts": [{"text": text}]
            },
            "configuration": {
                "blocking": blocking
            }
        }
        
        if context_id:
            payload["message"]["contextId"] = context_id
        
        response = requests.post(
            f"{self.base_url}/v1/message:send",
            json=payload,
            headers={"Content-Type": "application/json"}
        )
        response.raise_for_status()
        return response.json()
    
    def get_task(self, task_id: str) -> Dict[str, Any]:
        """Task durumunu sorgula"""
        response = requests.get(f"{self.base_url}/v1/tasks/{task_id}")
        response.raise_for_status()
        return response.json()
 
# Kullanım örneği
if __name__ == "__main__":
    client = A2AClient("http://localhost:8000")
    
    # Agent'ı keşfet
    card = client.discover()
    print(f"Bağlantı kuruldu: {card['name']}")
    print(f"Yetenekler: {card['skills']}")
    
    # Mesaj gönder
    result = client.send_message("SKU-12345 stok durumu nedir?")
    
    # Sonuçları göster
    print(f"\nTask ID: {result['id']}")
    print(f"Durum: {result['status']['state']}")
    
    if result.get('artifacts'):
        for artifact in result['artifacts']:
            print(f"Artifact: {artifact['name']}")
            for part in artifact['parts']:
                if part.get('data'):
                    print(f"Veri: {json.dumps(part['data'], indent=2)}")

8.3 MCP ile A2A Entegrasyonu Örneği

"""
A2A Agent içinde MCP Tool kullanımı örneği
Bu örnek, bir ajanın A2A üzerinden görev alıp MCP üzerinden araç kullandığını gösterir.
"""
 
from typing import Dict, Any, List
import json
 
class MCPTool:
    """Basit MCP Tool simülasyonu"""
    
    def __init__(self, name: str, endpoint: str):
        self.name = name
        self.endpoint = endpoint
    
    def call(self, method: str, params: Dict[str, Any]) -> Dict[str, Any]:
        """MCP tool çağrısı (JSON-RPC 2.0 formatı)"""
        # Gerçek implementasyonda HTTP çağrısı yapılır
        request = {
            "jsonrpc": "2.0",
            "id": 1,
            "method": f"tools/call",
            "params": {
                "name": method,
                "arguments": params
            }
        }
        
        # Simüle edilmiş yanıt
        if method == "get_inventory":
            return {
                "jsonrpc": "2.0",
                "id": 1,
                "result": {
                    "content": [{
                        "type": "text",
                        "text": json.dumps({
                            "sku": params.get("sku"),
                            "quantity": 42,
                            "warehouse": "Istanbul-01"
                        })
                    }],
                    "isError": False
                }
            }
        return {"error": "Unknown method"}
 
class InventoryAgent:
    """MCP araçları kullanan A2A uyumlu ajan"""
    
    def __init__(self):
        # MCP araçlarını bağla
        self.inventory_tool = MCPTool(
            name="inventory_db",
            endpoint="http://localhost:3000/mcp"
        )
    
    def get_agent_card(self) -> Dict[str, Any]:
        return {
            "protocolVersion": "1.0",
            "name": "Envanter Yönetim Ajanı",
            "description": "Stok yönetimi ve envanter kontrolü",
            "version": "1.0.0",
            "capabilities": {"streaming": True},
            "skills": [
                {
                    "id": "inventory-check",
                    "name": "Envanter Kontrolü",
                    "description": "Ürün stok durumunu kontrol eder"
                },
                {
                    "id": "reorder-alert",
                    "name": "Yeniden Sipariş Uyarısı",
                    "description": "Düşük stok uyarısı üretir"
                }
            ]
        }
    
    def process_task(self, message: Dict[str, Any]) -> Dict[str, Any]:
        """Gelen A2A mesajını işle"""
        user_text = message['parts'][0].get('text', '')
        
        # Basit intent detection
        if 'stok' in user_text.lower() or 'envanter' in user_text.lower():
            # MCP üzerinden envanter aracını çağır
            sku = self._extract_sku(user_text)
            mcp_result = self.inventory_tool.call(
                "get_inventory", 
                {"sku": sku}
            )
            
            # MCP sonucunu A2A artifact'a dönüştür
            inventory_data = json.loads(
                mcp_result['result']['content'][0]['text']
            )
            
            return {
                "status": "completed",
                "artifacts": [{
                    "artifactId": "inv-001",
                    "name": "Envanter Raporu",
                    "parts": [{
                        "data": inventory_data
                    }]
                }],
                "response_message": f"Ürün {sku} için stok: {inventory_data['quantity']} adet"
            }
        
        return {
            "status": "completed",
            "response_message": "Anlayamadım. Stok kontrolü için ürün kodu belirtin."
        }
    
    def _extract_sku(self, text: str) -> str:
        """Metinden SKU çıkar (basitleştirilmiş)"""
        import re
        match = re.search(r'SKU-\d+', text, re.IGNORECASE)
        return match.group(0) if match else "SKU-00000"
 
# Kullanım
if __name__ == "__main__":
    agent = InventoryAgent()
    
    # Simüle edilmiş A2A mesajı
    incoming_message = {
        "messageId": "msg-001",
        "role": "user",
        "parts": [{"text": "SKU-12345 için stok durumu nedir?"}]
    }
    
    result = agent.process_task(incoming_message)
    print(json.dumps(result, indent=2, ensure_ascii=False))

9. Gerçek Hayat Senaryoları

9.1 Senaryo: Kurumsal İşe Alım Süreci

Kurumsal işe alım workflow mimarisi:

İşe Alım Müdürü: "Backend developer arıyoruz, 5+ yıl deneyim"

Orchestrator Agent (Koordinatör) - A2A ile dağıtım yapar:

  1. Aday Bulma Agent

    • MCP → LinkedIn API ile aday arar

  2. Mülakat Planlama Agent

    • MCP → Google Calendar ile toplantı planlar

  3. Background Check Agent

    • MCP → Üçüncü Parti Servis ile referans kontrolü

  4. IT Sistem Hazırlık Agent

    • MCP → Active Directory ile hesap oluşturur

Akış Detayı:

  1. Orchestrator talebi alır ve görevleri dağıtır
  2. Aday Bulma Agent'ı MCP üzerinden LinkedIn'e bağlanır
  3. Uygun adaylar bulunduğunda A2A ile Mülakat Planlama Agent'a iletilir
  4. Mülakat planlandığında Background Check Agent devreye girer
  5. Tüm kontroller tamamlandığında IT Sistem Agent hesap oluşturur
  6. Her aşamada ilerleme Orchestrator'a raporlanır

9.2 Senaryo: E-Ticaret Sipariş Yönetimi

"""
E-Ticaret Sipariş Yönetimi - Multi-Agent Senaryo
"""
 
class OrderOrchestrator:
    """Sipariş sürecini yöneten ana ajan"""
    
    def __init__(self):
        self.inventory_agent = A2AClient("http://inventory-agent:8000")
        self.payment_agent = A2AClient("http://payment-agent:8000")
        self.shipping_agent = A2AClient("http://shipping-agent:8000")
        self.notification_agent = A2AClient("http://notification-agent:8000")
    
    async def process_order(self, order: dict) -> dict:
        """
        Sipariş işleme akışı:
        1. Stok kontrolü
        2. Ödeme işleme
        3. Kargo hazırlık
        4. Müşteri bildirimi
        """
        context_id = str(uuid.uuid4())
        results = {"order_id": order["id"], "steps": []}
        
        # Adım 1: Stok kontrolü
        inventory_result = await self.inventory_agent.send_message(
            text=f"Stok kontrolü: {json.dumps(order['items'])}",
            context_id=context_id
        )
        
        if inventory_result["status"]["state"] != "completed":
            return {"error": "Stok kontrolü başarısız", "details": inventory_result}
        
        results["steps"].append({"step": "inventory", "status": "ok"})
        
        # Adım 2: Ödeme işleme
        payment_result = await self.payment_agent.send_message(
            text=f"Ödeme al: {order['total']} TL, Kart: {order['payment_method']}",
            context_id=context_id
        )
        
        if payment_result["status"]["state"] != "completed":
            # Stok rezervasyonunu geri al
            await self.inventory_agent.send_message(
                text=f"Rezervasyon iptal: {order['id']}",
                context_id=context_id
            )
            return {"error": "Ödeme başarısız", "details": payment_result}
        
        results["steps"].append({"step": "payment", "status": "ok"})
        
        # Adım 3: Kargo hazırlık
        shipping_result = await self.shipping_agent.send_message(
            text=f"Kargo hazırla: Adres={order['address']}, Items={order['items']}",
            context_id=context_id
        )
        
        results["steps"].append({
            "step": "shipping",
            "status": "ok",
            "tracking_number": shipping_result.get("artifacts", [{}])[0]
                .get("parts", [{}])[0]
                .get("data", {})
                .get("tracking_number")
        })
        
        # Adım 4: Müşteri bildirimi
        await self.notification_agent.send_message(
            text=f"Sipariş onayı gönder: {order['customer_email']}, Sipariş: {order['id']}",
            context_id=context_id
        )
        
        results["steps"].append({"step": "notification", "status": "ok"})
        results["final_status"] = "completed"
        
        return results

9.3 Senaryo: Tedarik Zinciri Optimizasyonu

Tyson Foods ve Gordon Food Service gibi şirketler, A2A protokolünü tedarik zinciri yönetiminde kullanıyor:

Şirketler arası A2A iletişim mimarisi:

Tyson Foods (Üretim) ↔ A2A Protocol ↔ Gordon Food Service (Dağıtım)

Tyson Foods Agent'ları:

Gordon Food Service Agent'ları:

A2A üzerinden paylaşılan veriler:

10. Sık Yapılan Hatalar ve Yanlış Anlamalar

10.1 "A2A Sadece Bir Mimari Yaklaşımdır" Yanılgısı

Yanlış: A2A genel bir kavramdır, herkes kendi yöntemini kullanabilir.

Doğru: A2A, Google tarafından tanımlanan ve Linux Foundation tarafından yönetilen resmi bir protokoldür. IANA'da kayıtlı medya tipi (application/a2a+json), well-known URI (/.well-known/agent.json) ve detaylı spesifikasyonu vardır.

10.2 "ACP, A2A'nın Rakibidir" Yanılgısı

Yanlış: ACP ve A2A birbirinin alternatifidir, birini seçmelisiniz.

Doğru: ACP, Ağustos 2025'te A2A ile birleşmiştir. Artık tek bir birleşik protokol vardır ve bu protokol A2A adını taşımaktadır. BeeAI dahil tüm ACP implementasyonları A2A'ya geçiş yapmıştır.

10.3 "MCP Yerine A2A Kullanmalıyım" Yanılgısı

Yanlış: A2A, MCP'nin gelişmiş versiyonudur.

Doğru: MCP ve A2A farklı katmanlarda çalışır ve birbirini tamamlar:

Çoğu karmaşık sistem her ikisini de kullanır.

10.4 "Standart Olmak Esnekliği Öldürür" Yanılgısı

Yanlış: A2A gibi standartlar sistemi katılaştırır.

Doğru: A2A özellikle esneklik için tasarlanmıştır:

10.5 "A2A Sadece Büyük Şirketler İçindir" Yanılgısı

Yanlış: A2A enterprise-only bir teknolojidir.

Doğru: A2A açık kaynaklıdır ve her ölçekte kullanılabilir:

11. Sonuç ve Öneriler

11.1 Ne Öğrendik?

Bu makalede ele aldığımız temel konular:

Protokol Tanımları:

Mimari Konumlandırma:

Pratik Uygulamalar:

11.2 Hangi Durumda Hangisi?

Veritabanı sorgusu: MCP kullan API entegrasyonu: MCP kullan Başka ajana görev delegasyonu: A2A kullan Çok turlu ajan diyaloğu: A2A kullan Araç çağrısı + ajan koordinasyonu: MCP + A2A birlikte kullan

11.3 Yeni Mezunlar İçin Öneriler

Öğrenme Yol Haritası:

Başlangıç (1-2 hafta):

Orta Seviye (2-4 hafta):

İleri Seviye (1-2 ay):

Pratik Tavsiyeler:

  1. Resmi SDK'ları kullan: a2a-python, a2a-js paketleri
  2. Küçük başla: Önce tek ajan, sonra multi-agent
  3. Test et: Her aşamada Agent Card validasyonu yap
  4. Dokümante et: Ajan yeteneklerini açık tanımla
  5. Toplulukta yer al: GitHub Issues, Discord kanalları

12. Kaynaklar

Resmi Dokümantasyonlar:

Akademik ve Teknik Kaynaklar:

Eğitim Kaynakları:

Topluluk Kaynakları:

Bu makale, yapay zekâ ajan iletişim protokollerinin güncel durumunu yansıtmaktadır. Protokoller aktif geliştirme altında olduğundan, en güncel bilgiler için resmi dokümantasyonları takip etmenizi öneririz.

Son güncelleme: 3 Ocak 2026