A2A ve ACP: Yapay Zekâ Ajanlarının Ortak Dili
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
- A2A (Agent-to-Agent Protocol): Google tarafından geliştirilen, Linux Foundation bünyesinde yönetilen resmi ajan iletişim protokolü
- ACP (Agent Communication Protocol): IBM tarafından geliştirilen, Ağustos 2025'te A2A ile birleşen protokol
- MCP (Model Context Protocol): Anthropic tarafından geliştirilen, ajanların araçlara erişimini sağlayan protokol
- Temel Fark: A2A ajanlar arası (yatay), MCP ajan-araç arası (dikey) iletişim için tasarlanmıştır
- Birlikte Kullanım: Karmaşık sistemlerde A2A ve MCP birlikte kullanılarak hem ajan koordinasyonu hem araç entegrasyonu sağlanır
- Gerçek Dünya: Tyson Foods, Gordon Food Service gibi şirketler tedarik zincirinde A2A kullanıyor
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:
- Farklı platformlar birbirleriyle konuşamaz
- Her entegrasyon için özel kod yazmak gerekir
- Ölçeklenebilirlik imkansız hale gelir
- Güvenlik ve yönetim karmaşıklaşır
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:
- Temel kavramlar: Agent, multi-agent sistem, orkestrasyon nedir?
- A2A protokolü: Google'ın yaklaşımı, mimari, özellikler
- ACP protokolü: IBM'in katkıları, BeeAI platformu
- Birleşme süreci: İki protokolün nasıl tek çatı altında toplandığı
- MCP ile ilişki: Neden iki protokole birden ihtiyaç duyuyoruz?
- Paket yapıları: Mesajların teknik detayları
- Kod örnekleri: Python ile pratik implementasyonlar
- Gerçek hayat senaryoları: İşe alım, e-ticaret, tedarik zinciri
- 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:
- Kullanıcı input verir → Program işler → Sonuç döner
Agent (Ajan):
- Hedef belirlenir → Ajan kendi planını yapar → Araçları kullanır → Sonuca ulaşana kadar devam eder
Ajan özellikleri:
- Autonomy (Özerklik): Kendi kararlarını alabilir
- Reactivity (Tepkisellik): Çevredeki değişikliklere cevap verir
- Proactivity (İnisiyatif): Hedefe ulaşmak için kendi başına adım atar
- Social Ability (Sosyal Yetenek): Diğer ajanlarla iletişim kurabilir
Ajanın düşünce döngüsü:
1. Gözlem Yap (Observe)
- Mevcut durumu analiz et
2. Karar Ver (Decide)
- Hangi aksiyonu almalıyım?
3. Eylem Yap (Act)
- Aracı çağır veya başka ajana delege et
- Geri döngü: 1. Gözlem Yap adımına dön
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:
- Güvenlik Ajanı: Kamera görüntülerini izler
- Enerji Ajanı: Elektrik tüketimini optimize eder
- Konfor Ajanı: Sıcaklık ve aydınlatmayı ayarlar
- Bakım Ajanı: Cihazların servis ihtiyaçlarını takip eder
Bu ajanlar birbirinden haberdar olmalı. Örneğin:
- Güvenlik Ajanı ev boşken algılarsa → Enerji Ajanı'na bildirir → Tüm ışıklar kapatılır
- Enerji Ajanı elektrik kesintisi tespit ederse → Konfor Ajanı'na bildirir → Yedek sistemler devreye alınır
Multi-agent sistemin avantajları:
- Modülerlik (her ajan bağımsız geliştirilebilir)
- Ölçeklenebilirlik (yeni ajanlar kolayca eklenebilir)
- Dayanıklılık (bir ajan çökerse diğerleri çalışmaya devam eder)
- Uzmanlık (her ajan kendi alanında uzman)
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)
- Agent A'ya görev 1 ata
- Agent B'ye görev 2 ata
- Agent C'ye görev 3 ata
- Sonuçları topla ve birleştir
Özellikler:
- Merkezi kontrol noktası var
- İş akışı önceden tanımlı
- Hata yönetimi kolay
- Karmaşık koordinasyon gerektiren senaryolar için ideal
Choreography (Koreografi) - Dağıtık Koordinasyon:
Event Bus (Merkezi Mesaj Yolu)
- Agent A → Event Bus'a mesaj gönderir
- Agent B ← Event Bus'tan mesaj alır
- Agent C ← Event Bus'tan mesaj alır
Tüm ajanlar Event Bus üzerinden birbirleriyle haberleşir
Özellikler:
- Merkezi otorite yok, ajanlar eşit
- Event-driven (olay güdümlü) mimari
- Ölçeklenebilirlik yüksek
- Dinamik, değişken senaryolar için uygun
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)
- Görev oluşturuldu ama henüz işlenmeye başlanmadı
2. WORKING (İşleniyor)
- Ajan görev üzerinde aktif olarak çalışıyor
3a. COMPLETED (Tamamlandı)
- Görev başarıyla tamamlandı
VEYA
3b. FAILED (Başarısız)
- Görev hatalarla sonuçlandı
Context (Bağlam): İlişkili görevleri gruplandıran UUID tanımlayıcısı.
Örneğin, bir e-ticaret siparişi işlenirken:
- Context ID:
ctx-order-12345 - Task 1: Stok kontrolü (
task-inventory-001) - Task 2: Ödeme işleme (
task-payment-002) - Task 3: Kargo hazırlık (
task-shipping-003)
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ı:
- Nisan 2025: Google, A2A protokolünü duyurdu
- Haziran 2025: Linux Foundation altında proje başlatıldı
- Ağustos 2025: IBM'in ACP protokolü A2A ile birleştirildi
- Ekim 2025: A2A v1.0 spesifikasyonu yayınlandı
- Aralık 2025: IANA'da
application/a2a+jsonmedya tipi kayıt edildi
Neden önemli?
A2A, sadece bir "fikir" veya "mimari yaklaşım" değil, resmi bir standarttır:
- IANA kayıtlı medya tipi:
application/a2a+json - Well-known URI:
/.well-known/agent.json - Detaylı spesifikasyon: a2a-protocol.org
- Açık kaynak SDK'lar: Python, JavaScript, Go
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:
- protocolVersion: Kullanılan A2A protokol versiyonu
- name & description: Ajanın tanımı
- supportedInterfaces: API endpoint'leri ve protokol bağlamaları
- capabilities: Desteklenen özellikler (streaming, webhook, vb.)
- skills: Ajanın yapabildiği görevler
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):
Non-Blocking Mode (Asenkron):
3.4 Protocol Bindings: Farklı Transport Katmanları
A2A, farklı transport protokolleri üzerinden çalışabilir:
JSON-RPC over HTTP:
- REST benzeri yapı
- HTTP POST istekleri
- JSON formatında mesajlar
gRPC:
- Yüksek performanslı binary protokol
- Streaming desteği
- Google'ın tercih ettiği yöntem
GraphQL:
- Esnek sorgulama
- Sadece gerekli alanları çek
- Real-time subscriptions
WebSocket:
- Çift yönlü iletişim
- Düşük latency
- Push notifications için ideal
Hangi binding'i seçmeli?
- Basit sistemler: JSON-RPC (en kolay)
- Yüksek performans gerekli: gRPC
- Dinamik sorgular: GraphQL
- Real-time: WebSocket
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:
- Stateful Communication: Ajan diyaloglarının durumlu (stateful) olması
- Rich Metadata: Mesajlarda zengin metadata alanları
- Enterprise Security: Kurumsal güvenlik standartları (OAuth, mTLS)
- Task Dependencies: Görevler arası bağımlılık yönetimi
ACP'nin güçlü yönleri:
- IBM'in on yıllarca süren enterprise experience'ı
- Watson platformu entegrasyonu
- Red Hat OpenShift ile konteyner desteği
- Kurumsal SLA (Service Level Agreement) yönetimi
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:
- Agent oluşturma ve yönetim
- LLM entegrasyonları (GPT, Claude, Llama)
- Tool çağırma mekanizmaları
- Memory ve state yönetimi
Bee Agent Hub:
- Hazır agent şablonları
- Community-contributed ajanlar
- Pazar yeri (marketplace)
BeeAI Orchestrator:
- Multi-agent koordinasyonu
- Workflow yönetimi
- Monitoring ve logging
BeeAI mimarisi:
BeeAI Platform Katmanları:
Üst Katman - Orchestrator (Koordinatör)
- Workflow Engine ile iş akışlarını yönetir
Orta Katman - Agent'lar
- Agent A (Planner): Görevleri planlar
- Agent B (Executor): Görevleri çalıştırır
- Agent C (Reviewer): Sonuçları gözden geçirir
İletişim Katmanı - Message Bus
- ACP Protocol ile tüm agent'lar birbirine bağlı
- Merkezi haberleşme noktası
Alt Katman - Kaynaklar
- LLM (GPT): Yapay zeka modeli
- Tools (APIs): Dış araçlar ve servisler
- Database (Memory): Veri ve hafıza yönetimi
4.3 ACP ve A2A Birleşmesi (Ağustos 2025)
Neden birleştiler?
İki ayrı standardın olması:
- Ekosistemi fragmente ediyordu
- Geliştiricileri kararsız bırakıyordu
- Entegrasyon maliyetlerini artırıyordu
Birleşme süreci:
- Nisan-Mayıs 2025: Google ve IBM teknik komite oluşturdu
- Haziran 2025: Ortak spesifikasyon taslağı hazırlandı
- Temmuz 2025: Topluluk geri bildirimleri alındı
- Ağustos 2025: A2A v0.9 yayınlandı (ACP özellikleri dahil)
- Ekim 2025: A2A v1.0 finalize edildi
ACP'den A2A'ya geçenler:
- Stateful sessions: A2A'da
contextIdile desteklendi - Rich metadata:
metadataalanı genişletildi - Task dependencies:
dependsOnalanı eklendi - Enterprise security: OAuth2, mTLS binding'leri eklendi
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:
- A2A: Hem peer-to-peer hem de orchestrated
- ACP: Ağırlıklı olarak orchestrated (merkezi koordinasyon)
Mesaj formatı:
- A2A: Minimal, esnek JSON yapısı
- ACP: Daha yapılandırılmış, zengin metadata
Transport:
- A2A: JSON-RPC, gRPC, GraphQL, WebSocket
- ACP: Ağırlıklı olarak HTTP REST ve gRPC
State yönetimi:
- A2A (orijinal): Stateless tasarım
- ACP: Stateful sessions (birleşme sonrası A2A'ya eklendi)
Güvenlik:
- A2A (orijinal): Transport katmanına bırakılmış
- ACP: Protokol içinde tanımlı (birleşme sonrası A2A'ya eklendi)
Hedef kitle:
- A2A: Genel amaçlı, her ölçek
- ACP: Kurumsal sistemler
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 Protocol ile bağlanır ↓
MCP Server (Araçlar)
- Database: Veritabanı erişimi
- File System: Dosya sistemi işlemleri
- API Services: Dış servis entegrasyonları
- Web Scraping: Web veri çekme 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):
MCP, bir ajanın "aşağı" doğru araçlara erişimini sağlar.
Yatay Entegrasyon (A2A):
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:
- Orchestrator Agent: A2A ile diğer ajanları koordine eder
Agent Katmanı (A2A ile birbirine bağlı):
- Ticket Agent → MCP ile CRM Database'e bağlanır
- FAQ Agent → MCP ile Knowledge Base'e bağlanır
- Analytics Agent → MCP ile Analytics DB'ye bağlanır
Veri Katmanı (MCP üzerinden erişim):
- CRM Database: Müşteri ve ticket verileri
- Knowledge Base: Sık sorulan sorular
- Analytics DB: İstatistik ve raporlar
Akış örneği:
- Müşteri sorusu gelir: "Siparişim nerede?"
- Orchestrator Agent, Ticket Agent'a A2A ile görev atar
- Ticket Agent, MCP ile CRM veritabanını sorgular
- Sipariş bilgisi bulunamazsa, FAQ Agent'a A2A ile sorar
- FAQ Agent, MCP ile Knowledge Base'i arar
- Sonuç bulunursa Analytics Agent'a A2A ile bildirir
- Analytics Agent, MCP ile istatistikleri günceller
- Final cevap müşteriye döner
Özet:
- MCP: "Ben hangi araçları kullanabilirim?"
- A2A: "Ben kimlerle işbirliği yapabilirim?"
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ış:
Client → POST /v1/message:stream → Server
Server → SSE: {"task": {"id": "t1", "status": "working"}}
↓
Server → SSE: {"statusUpdate": {"state": "working"}}
↓
Server → SSE: {"artifactUpdate": {"artifact": {...}}}
↓
Server → SSE: {"statusUpdate": {"state": "completed", "final": true}}
↓
[Connection Closed]
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:
-
Aday Bulma Agent
- MCP → LinkedIn API ile aday arar
-
Mülakat Planlama Agent
- MCP → Google Calendar ile toplantı planlar
-
Background Check Agent
- MCP → Üçüncü Parti Servis ile referans kontrolü
-
IT Sistem Hazırlık Agent
- MCP → Active Directory ile hesap oluşturur
Akış Detayı:
- Orchestrator talebi alır ve görevleri dağıtır
- Aday Bulma Agent'ı MCP üzerinden LinkedIn'e bağlanır
- Uygun adaylar bulunduğunda A2A ile Mülakat Planlama Agent'a iletilir
- Mülakat planlandığında Background Check Agent devreye girer
- Tüm kontroller tamamlandığında IT Sistem Agent hesap oluşturur
- 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ı:
- Üretim Ajanı: Üretim kapasitesi ve planlamayı yönetir
- Envanter Ajanı: Stok durumunu takip eder
Gordon Food Service Agent'ları:
- Dağıtım Ajanı: Lojistik ve teslimat koordinasyonu
- Sipariş Ajanı: Sipariş yönetimi ve talep tahmini
A2A üzerinden paylaşılan veriler:
- Gerçek zamanlı stok seviyeleri
- Talep tahminleri
- Lojistik optimizasyonu
- Fiyat güncellemeleri
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:
- MCP: Ajan-Araç iletişimi (dikey entegrasyon)
- A2A: Ajan-Ajan iletişimi (yatay entegrasyon)
Ç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:
- Extension mekanizması ile özel özellikler eklenebilir
- Birden fazla protokol bağlaması (JSON-RPC, gRPC, REST) desteklenir
- Özel metadata alanları serbest format kullanır
- Agent Card'lar isteğe bağlı alanlarla zenginleştirilebilir
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:
- Basit projeler için minimal implementasyon yeterlidir
- Ücretsiz SDK'lar mevcuttur (Python, JavaScript)
- Localhost üzerinde geliştirme yapılabilir
- Küçük startup'lardan büyük kurumlara kadar herkes kullanabilir
11. Sonuç ve Öneriler
11.1 Ne Öğrendik?
Bu makalede ele aldığımız temel konular:
Protokol Tanımları:
- A2A: Ajan-ajan iletişim protokolü (Google, Linux Foundation)
- ACP: A2A ile birleşmiş eski IBM protokolü
- MCP: Ajan-araç iletişim protokolü (Anthropic)
Mimari Konumlandırma:
- Yatay entegrasyon: A2A (ajanlar arası)
- Dikey entegrasyon: MCP (araçlara erişim)
Pratik Uygulamalar:
- Agent Card ile keşif
- Task lifecycle yönetimi
- Streaming ve async işlemler
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):
- A2A spesifikasyonunu oku
- Basit A2A server/client yaz
- Agent Card yapısını öğren
Orta Seviye (2-4 hafta):
- MCP ile araç entegrasyonu
- Streaming implementasyonu
- Multi-agent koordinasyonu
İleri Seviye (1-2 ay):
- Kurumsal güvenlik (OAuth, mTLS)
- OpenTelemetry entegrasyonu
- Production deployment
Pratik Tavsiyeler:
- Resmi SDK'ları kullan: a2a-python, a2a-js paketleri
- Küçük başla: Önce tek ajan, sonra multi-agent
- Test et: Her aşamada Agent Card validasyonu yap
- Dokümante et: Ajan yeteneklerini açık tanımla
- Toplulukta yer al: GitHub Issues, Discord kanalları
12. Kaynaklar
Resmi Dokümantasyonlar:
- A2A Protocol Specification - Resmi A2A protokol spesifikasyonu
- A2A GitHub Repository - Açık kaynak kod ve örnekler
- Model Context Protocol (MCP) - Anthropic'in MCP dokümantasyonu
- BeeAI Documentation - IBM BeeAI platform rehberi
Akademik ve Teknik Kaynaklar:
- Google Developers Blog: "Announcing the Agent2Agent Protocol (A2A)" (Nisan 2025)
- Linux Foundation: "Agent2Agent Protocol Project Launch" (Haziran 2025)
- IBM Research: "Agent Communication Protocol"
- Google Cloud Blog: "Agent2Agent Protocol Update v0.3" (Temmuz 2025)
Eğitim Kaynakları:
- DeepLearning.AI: MCP ve ACP kursları
- Google Codelabs: A2A Tutorial
- LangChain Documentation: A2A Integration
Topluluk Kaynakları:
- GitHub Discussions: a2aproject/A2A
- Discord: A2A Community
- Stack Overflow: [a2a-protocol] tag
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