Tutorial Google A2A Protocol: Membangun Sistem Multi-Agent yang Saling Berkomunikasi
Dalam era AI yang semakin canggih, satu AI agent saja sering tidak cukup untuk menyelesaikan tugas kompleks. Bayangkan Anda memiliki agent yang ahli dalam riset, agent lain yang ahli dalam coding, dan satu lagi yang ahli dalam analisis data. Bagaimana cara membuat mereka berkomunikasi dan berkolaborasi? Inilah masalah yang diselesaikan oleh Google A2A (Agent-to-Agent) Protocol.
A2A adalah protokol terbuka yang dikembangkan Google untuk memungkinkan AI agent dari berbagai vendor dan platform saling berkomunikasi secara standar. Jika Anda sudah familiar dengan Model Context Protocol (MCP) yang menghubungkan agent ke tools dan data sources, maka A2A melengkapinya dengan menghubungkan agent ke agent lain.
Dalam tutorial ini, kita akan belajar cara menggunakan A2A Protocol untuk membangun sistem multi-agent yang saling berkomunikasi, mulai dari konsep dasar hingga implementasi lengkap dalam Python.
Apa Itu Google A2A Protocol?
A2A (Agent-to-Agent) Protocol adalah spesifikasi terbuka berbasis JSON-RPC 2.0 yang memungkinkan AI agent berkomunikasi satu sama lain secara terstandar. Protocol ini dirilis Google pada April 2025 dan didukung oleh lebih dari 50 technology partners termasuk Salesforce, SAP, MongoDB, dan lainnya.
Mengapa A2A Diperlukan?
Sebelum A2A, integrasi antar agent dilakukan secara ad-hoc. Setiap vendor memiliki API dan format komunikasi yang berbeda. Ini menciptakan beberapa masalah:
A2A menyelesaikan semua masalah ini dengan menyediakan protokol standar yang mencakup discovery, communication, dan task management.
A2A vs MCP: Apa Bedanya?
| Aspek | MCP | A2A |
|-------|-----|-----|
| Fungsi | Menghubungkan agent ke tools/data | Menghubungkan agent ke agent |
| Analogi | USB port di komputer | HTTP di internet |
| Interaksi | Client-server (agent -> tool) | Peer-to-peer (agent <-> agent) |
| Use case | Akses database, API, file system | Kolaborasi multi-agent |
Keduanya saling melengkapi: MCP memberi agent akses ke tools dan data, sementara A2A memungkinkan agent berkolaborasi satu sama lain.
Konsep Utama A2A Protocol
1. Agent Card
Agent Card adalah dokumen JSON yang mendeskripsikan identitas dan kemampuan sebuah agent. Analoginya seperti "kartu nama digital" yang memungkinkan agent lain mengetahui apa yang bisa dilakukan oleh suatu agent.
{
"name": "Data Analysis Agent",
"description": "Agent yang menganalisis dataset dan menghasilkan insight",
"url": "https://data-agent.example.com",
"version": "1.0.0",
"capabilities": {
"streaming": true,
"pushNotifications": false,
"stateTransitionHistory": true
},
"skills": [
{
"id": "analyze-csv",
"name": "Analisis CSV",
"description": "Menganalisis file CSV dan menghasilkan ringkasan statistik",
"tags": ["data", "analytics", "csv"],
"examples": [
"Analisis dataset penjualan Q3 2026",
"Berikan ringkasan statistik dari data pelanggan"
]
},
{
"id": "create-chart",
"name": "Buat Grafik",
"description": "Membuat visualisasi grafik dari data",
"tags": ["visualization", "charts"]
}
],
"defaultInputModes": ["text/plain", "application/json"],
"defaultOutputModes": ["text/plain", "image/png"]
}
2. Task
Task adalah unit kerja dalam A2A. Ketika satu agent meminta agent lain melakukan sesuatu, itu menciptakan sebuah Task. Setiap task memiliki lifecycle dengan state transitions:
submitted → working → completed
→ failed
→ canceled
→ input-required (menunggu input tambahan)
3. Message dan Part
Komunikasi antar agent dilakukan melalui Message yang berisi satu atau lebih Part. Part bisa berupa teks, file, data terstruktur, atau bahkan referensi ke resource lain.
4. Artifact
Artifact adalah output yang dihasilkan oleh agent selama menjalankan task. Berbeda dengan message yang merupakan komunikasi, artifact adalah hasil kerja (misalnya file, grafik, atau dokumen).
Instalasi dan Setup
Prasyarat
- Python 3.10 atau lebih baru
- pip atau uv package manager
Instalasi A2A SDK
pip install a2a-sdk
Atau menggunakan uv:
uv pip install a2a-sdk
Instalasi Dependencies Tambahan
Untuk tutorial ini, kita juga membutuhkan beberapa package tambahan:
pip install uvicorn httpx python-dotenv
Struktur Project
Buat struktur project berikut:
a2a-demo/
├── .env
├── researchagent/
│ ├── init.py
│ └── agent.py
├── writeragent/
│ ├── init.py
│ └── agent.py
├── orchestrator.py
└── requirements.txt
File requirements.txt:
a2a-sdk>=0.2.0
uvicorn>=0.30.0
httpx>=0.27.0
python-dotenv>=1.0.0
Membangun A2A Agent Pertama
Mari kita mulai dengan membuat agent sederhana yang bisa menerima dan memproses task dari agent lain.
Step 1: Definisikan Agent Card
# researchagent/agent.py
from a2a.server import A2AServer, TaskHandler, TaskContext
from a2a.types import (
AgentCard,
AgentCapabilities,
AgentSkill,
Task,
TaskState,
Message,
TextPart,
Role,
)
import uvicorn
agent
card = AgentCard(
name="Research Agent",
description="Agent yang melakukan riset dan mengumpulkan informasi tentang topik tertentu",
url="http://localhost:8001",
version="1.0.0",
capabilities=AgentCapabilities(
streaming=False,
pushNotifications=False,
stateTransitionHistory=True,
),
skills=[
AgentSkill(
id="research-topic",
name="Research Topic",
description="Melakukan riset mendalam tentang topik yang diberikan",
tags=["research", "information", "analysis"],
examples=[
"Riset tentang tren AI di Indonesia 2026",
"Kumpulkan informasi tentang framework Python terbaru",
],
)
],
defaultInputModes=["text/plain"],
defaultOutputModes=["text/plain"],
)
Step 2: Implementasikan Task Handler
class ResearchTaskHandler(TaskHandler):
async def handletask(self, context: TaskContext) -> None:
usermessage = context.task.messages[-1]
query = ""
for part in usermessage.parts:
if hasattr(part, "text"):
query = part.text
break
await context.updatestate(TaskState.WORKING)
researchresult = await self.doresearch(query)
responsemessage = Message(
role=Role.AGENT,
parts=[TextPart(text=researchresult)],
)
await context.addmessage(responsemessage)
await context.complete()
async def doresearch(self, query: str) -> str:
# Dalam implementasi nyata, ini bisa memanggil search API,
# scrape website, atau menggunakan LLM untuk riset
return (
f"Hasil riset untuk '{query}':\n\n"
f"1. Topik ini sedang trending di kalangan developer\n"
f"2. Terdapat 15+ framework terkait yang aktif dikembangkan\n"
f"3. Adopsi meningkat 40% dibanding tahun lalu\n"
f"4. Komunitas open-source sangat aktif dengan 500+ kontributor\n\n"
f"Rekomendasi: Fokus pada aspek praktis dan implementasi "
f"untuk mendapatkan value terbaik dari topik ini."
)
Step 3: Jalankan Agent Server
# Lanjutan researchagent/agent.py
def main():
handler = ResearchTaskHandler()
server = A2AServer(
agentcard=agentcard,
taskhandler=handler,
host="0.0.0.0",
port=8001,
)
server.run()
if name == "main":
main()
Jalankan agent:
python -m researchagent.agent
Agent sekarang berjalan di http://localhost:8001 dan siap menerima task dari agent lain.
Step 4: Verifikasi dengan Agent Card
Setiap A2A agent meng-expose Agent Card-nya di endpoint /.well-known/agent.json:
curl http://localhost:8001/.well-known/agent.json
Output:
{
"name": "Research Agent",
"description": "Agent yang melakukan riset dan mengumpulkan informasi tentang topik tertentu",
"url": "http://localhost:8001",
"version": "1.0.0",
"capabilities": {
"streaming": false,
"pushNotifications": false,
"stateTransitionHistory": true
},
"skills": [...]
}
Membuat A2A Client
Sekarang mari buat agent kedua yang berkomunikasi dengan Research Agent menggunakan A2A Client.
Writer Agent yang Menggunakan Research Agent
# writeragent/agent.py
from a2a.client import A2AClient
from a2a.server import A2AServer, TaskHandler, TaskContext
from a2a.types import (
AgentCard,
AgentCapabilities,
AgentSkill,
Task,
TaskState,
TaskSendParams,
Message,
TextPart,
Role,
)
writer
card = AgentCard(
name="Writer Agent",
description="Agent yang menulis artikel berdasarkan hasil riset",
url="http://localhost:8002",
version="1.0.0",
capabilities=AgentCapabilities(
streaming=False,
pushNotifications=False,
),
skills=[
AgentSkill(
id="write-article",
name="Write Article",
description="Menulis artikel berdasarkan topik yang diberikan. "
"Secara otomatis melakukan riset terlebih dahulu.",
tags=["writing", "article", "content"],
examples=["Tulis artikel tentang AI agents"],
)
],
defaultInputModes=["text/plain"],
defaultOutputModes=["text/plain"],
)
class WriterTaskHandler(TaskHandler):
def init(self):
self.researchclient = A2AClient(url="http://localhost:8001")
async def handletask(self, context: TaskContext) -> None:
usermessage = context.task.messages[-1]
topic = ""
for part in usermessage.parts:
if hasattr(part, "text"):
topic = part.text
break
await context.updatestate(TaskState.WORKING)
# Step 1: Minta Research Agent melakukan riset
researchtask = await self.researchclient.sendtask(
TaskSendParams(
message=Message(
role=Role.USER,
parts=[TextPart(text=f"Riset tentang: {topic}")],
)
)
)
# Ambil hasil riset dari response
researchresult = ""
if researchtask.messages:
for part in researchtask.messages[-1].parts:
if hasattr(part, "text"):
researchresult = part.text
# Step 2: Tulis artikel berdasarkan hasil riset
article = self.writearticle(topic, researchresult)
response = Message(
role=Role.AGENT,
parts=[TextPart(text=article)],
)
await context.addmessage(response)
await context.complete()
def writearticle(self, topic: str, research: str) -> str:
return (
f"# {topic}\n\n"
f"## Pendahuluan\n"
f"Artikel ini membahas tentang {topic} berdasarkan riset terkini.\n\n"
f"## Hasil Riset\n{research}\n\n"
f"## Kesimpulan\n"
f"Berdasarkan riset di atas, {topic} merupakan area yang sangat "
f"menjanjikan dan layak untuk dieksplorasi lebih lanjut."
)
def main():
handler = WriterTaskHandler()
server = A2AServer(
agentcard=writercard,
taskhandler=handler,
host="0.0.0.0",
port=8002,
)
server.run()
if name == "main":
main()
Membangun Orchestrator
Orchestrator adalah komponen yang mengkoordinasikan interaksi antar agent. Ini bisa berupa agent sendiri atau script yang mengelola workflow multi-agent.
# orchestrator.py
import asyncio
from a2a.client import A2AClient
from a2a.types import (
TaskSendParams,
Message,
TextPart,
Role,
TaskState,
)
async def discoveragents():
"""Discover agent capabilities melalui Agent Card"""
agents = {}
researchclient = A2AClient(url="http://localhost:8001")
card = await researchclient.getagentcard()
agents["research"] = {
"client": researchclient,
"card": card,
"skills": {s.id: s for s in card.skills},
}
print(f"Discovered: {card.name} - {card.description}")
writerclient = A2AClient(url="http://localhost:8002")
card = await writerclient.getagentcard()
agents["writer"] = {
"client": writerclient,
"card": card,
"skills": {s.id: s for s in card.skills},
}
print(f"Discovered: {card.name} - {card.description}")
return agents
async def runworkflow(topic: str):
"""Jalankan workflow multi-agent untuk menulis artikel"""
print(f"\n{'='60}")
print(f"Memulai workflow untuk topik: {topic}")
print(f"{'='60}\n")
# Step 1: Discover agents
print("[1/3] Discovering agents...")
agents = await discoveragents()
# Step 2: Kirim task ke Research Agent
print(f"\n[2/3] Mengirim task riset ke {agents['research']['card'].name}...")
researchclient = agents["research"]["client"]
researchtask = await researchclient.sendtask(
TaskSendParams(
message=Message(
role=Role.USER,
parts=[TextPart(text=f"Riset mendalam tentang: {topic}")],
)
)
)
print(f" Task ID: {researchtask.id}")
print(f" Status: {researchtask.state}")
if researchtask.messages:
lastmsg = researchtask.messages[-1]
for part in lastmsg.parts:
if hasattr(part, "text"):
print(f" Hasil riset:\n{part.text[:200]}...")
# Step 3: Kirim task ke Writer Agent
print(f"\n[3/3] Mengirim task menulis ke {agents['writer']['card'].name}...")
writerclient = agents["writer"]["client"]
writertask = await writerclient.sendtask(
TaskSendParams(
message=Message(
role=Role.USER,
parts=[TextPart(text=topic)],
)
)
)
print(f" Task ID: {writertask.id}")
print(f" Status: {writertask.state}")
if writertask.messages:
lastmsg = writertask.messages[-1]
for part in lastmsg.parts:
if hasattr(part, "text"):
print(f"\n{'='60}")
print("ARTIKEL FINAL:")
print(f"{'='60}")
print(part.text)
return writertask
if name == "main":
asyncio.run(runworkflow("Perkembangan AI Agents di Indonesia 2026"))
Menjalankan Sistem Multi-Agent
Buka 3 terminal terpisah:
Terminal 1 - Jalankan Research Agent:python -m researchagent.agent
Output: A2A Server running on http://0.0.0.0:8001
Terminal 2 - Jalankan Writer Agent:
python -m writeragent.agent
Output: A2A Server running on http://0.0.0.0:8002
Terminal 3 - Jalankan Orchestrator:
python orchestrator.py
Fitur Lanjutan
1. Streaming Responses
A2A mendukung streaming untuk respons yang panjang, memungkinkan agent mengirim hasil secara bertahap:
from a2a.server import TaskHandler, TaskContext
from a2a.types import (
TaskState,
Message,
TextPart,
Role,
)
class StreamingTaskHandler(TaskHandler):
async def handletask(self, context: TaskContext) -> None:
await context.updatestate(TaskState.WORKING)
# Kirim update bertahap
sections = [
"## Bagian 1: Pendahuluan\nIni adalah bagian pendahuluan...\n\n",
"## Bagian 2: Analisis\nBerikut analisis mendalam...\n\n",
"## Bagian 3: Kesimpulan\nDari analisis di atas...\n\n",
]
for i, section in enumerate(sections):
updatemsg = Message(
role=Role.AGENT,
parts=[TextPart(text=section)],
metadata={"section": i + 1, "total": len(sections)},
)
await context.sendstreamingupdate(updatemsg)
finalmsg = Message(
role=Role.AGENT,
parts=[TextPart(text="Artikel lengkap telah selesai ditulis.")],
)
await context.addmessage(finalmsg)
await context.complete()
Di sisi client, streaming dapat dikonsumsi seperti ini:
from a2a.client import A2AClient
from a2a.types import TaskSendParams, Message, TextPart, Role
async def consumestreaming():
client = A2AClient(url="http://localhost:8001")
async for event in client.sendtaskstreaming(
TaskSendParams(
message=Message(
role=Role.USER,
parts=[TextPart(text="Tulis artikel panjang tentang AI")],
)
)
):
if hasattr(event, "message"):
for part in event.message.parts:
if hasattr(part, "text"):
print(part.text, end="", flush=True)
elif hasattr(event, "state"):
print(f"\n[State: {event.state}]")
2. Multi-Turn Conversations
A2A mendukung percakapan multi-turn di mana agent bisa meminta informasi tambahan sebelum menyelesaikan task:
from a2a.server import TaskHandler, TaskContext
from a2a.types import (
TaskState,
Message,
TextPart,
Role,
)
class InteractiveTaskHandler(TaskHandler):
async def handletask(self, context: TaskContext) -> None:
messages = context.task.messages
lastmessage = messages[-1]
query = ""
for part in lastmessage.parts:
if hasattr(part, "text"):
query = part.text
# Jika ini pesan pertama, minta klarifikasi
if len(messages) == 1:
clarification = Message(
role=Role.AGENT,
parts=[
TextPart(
text=(
f"Saya akan melakukan riset tentang '{query}'. "
"Apakah Anda ingin fokus pada aspek tertentu? "
"Pilihan: teknis, bisnis, atau keduanya."
)
)
],
)
await context.addmessage(clarification)
await context.updatestate(TaskState.INPUTREQUIRED)
return
# Jika ini respons dari user, proses berdasarkan pilihan
focus = query.lower()
if "teknis" in focus:
result = "Hasil riset fokus teknis: ..."
elif "bisnis" in focus:
result = "Hasil riset fokus bisnis: ..."
else:
result = "Hasil riset komprehensif (teknis + bisnis): ..."
response = Message(
role=Role.AGENT,
parts=[TextPart(text=result)],
)
await context.addmessage(response)
await context.complete()
3. Error Handling
Penanganan error yang baik sangat penting dalam sistem multi-agent:
from a2a.client import A2AClient
from a2a.types import (
TaskSendParams,
Message,
TextPart,
Role,
TaskState,
)
import httpx
async def robusttaskexecution(client: A2AClient, message: str):
"""Eksekusi task dengan error handling yang komprehensif"""
try:
task = await client.sendtask(
TaskSendParams(
message=Message(
role=Role.USER,
parts=[TextPart(text=message)],
)
)
)
if task.state == TaskState.FAILED:
errormsg = "Unknown error"
if task.messages:
for part in task.messages[-1].parts:
if hasattr(part, "text"):
errormsg = part.text
print(f"Task gagal: {errormsg}")
return None
return task
except httpx.ConnectError:
print("Tidak dapat terhubung ke agent. Pastikan agent sedang berjalan.")
return None
except httpx.TimeoutException:
print("Timeout saat menunggu respons dari agent.")
return None
except Exception as e:
print(f"Error tidak terduga: {e}")
return None
4. Agent Discovery dengan Registry
Dalam sistem produksi, Anda mungkin memiliki banyak agent. Registry membantu mengelola dan menemukan agent yang tepat:
from a2a.client import A2AClient
from a2a.types import AgentCard
from dataclasses import dataclass
@dataclass
class RegisteredAgent:
url: str
card: AgentCard
client: A2AClient
class AgentRegistry:
def init(self):
self.agents: dict[str, RegisteredAgent] = {}
async def register(self, url: str) -> AgentCard:
"""Register agent baru berdasarkan URL"""
client = A2AClient(url=url)
card = await client.getagentcard()
self.agents[card.name] = RegisteredAgent(
url=url, card=card, client=client
)
return card
def findbyskill(self, skilltag: str) -> list[RegisteredAgent]:
"""Cari agent berdasarkan skill tag"""
results = []
for agent in self.agents.values():
for skill in agent.card.skills:
if skilltag in skill.tags:
results.append(agent)
break
return results
def findbyname(self, name: str) -> RegisteredAgent | None:
"""Cari agent berdasarkan nama"""
return self.agents.get(name)
def listall(self) -> list[AgentCard]:
"""List semua agent yang terdaftar"""
return [a.card for a in self.agents.values()]
Penggunaan
async def main():
registry = AgentRegistry()
await registry.register("http://localhost:8001")
await registry.register("http://localhost:8002")
await registry.register("http://localhost:8003")
researchagents = registry.findbyskill("research")
print(f"Ditemukan {len(researchagents)} agent dengan skill 'research'")
for agent in researchagents:
print(f" - {agent.card.name}: {agent.card.description}")
Integrasi A2A dengan LLM
Dalam prakteknya, A2A agent biasanya menggunakan LLM untuk memproses task. Berikut contoh integrasi dengan Anthropic Claude:
from a2a.server import TaskHandler, TaskContext
from a2a.types import (
TaskState,
Message,
TextPart,
Role,
)
import anthropic
import os
class LLMResearchHandler(TaskHandler):
def init(self):
self.llm = anthropic.Anthropic(apikey=os.getenv("ANTHROPICAPIKEY"))
async def handletask(self, context: TaskContext) -> None:
lastmessage = context.task.messages[-1]
query = ""
for part in lastmessage.parts:
if hasattr(part, "text"):
query = part.text
await context.updatestate(TaskState.WORKING)
llmresponse = self.llm.messages.create(
model="claude-sonnet-4-6",
maxtokens=2048,
system=(
"Kamu adalah research agent yang ahli dalam mengumpulkan "
"dan menganalisis informasi. Berikan hasil riset yang "
"terstruktur dan informatif."
),
messages=[{"role": "user", "content": query}],
)
resulttext = llmresponse.content[0].text
response = Message(
role=Role.AGENT,
parts=[TextPart(text=resulttext)],
)
await context.addmessage(response)
await context.complete()
Best Practices
1. Desain Agent Card yang Informatif
Agent Card adalah kontrak publik agent Anda. Pastikan deskripsi skill akurat dan contoh penggunaan jelas. Agent lain mengandalkan informasi ini untuk menentukan apakah agent Anda cocok untuk task mereka.
# Baik - deskripsi spesifik dan terukur
AgentSkill(
id="summarize-pdf",
name="PDF Summarizer",
description="Meringkas dokumen PDF hingga 50 halaman. Output berupa ringkasan terstruktur dengan poin-poin utama, max 500 kata.",
tags=["summarization", "pdf", "document"],
examples=[
"Ringkas laporan keuangan Q3 2026.pdf",
"Buat executive summary dari whitepaper ini",
],
)
Kurang baik - terlalu umum
AgentSkill(
id="process",
name="Process",
description="Memproses dokumen",
tags=["document"],
)
2. Implementasikan Timeout dan Retry
Dalam sistem terdistribusi, kegagalan adalah hal yang normal. Selalu implementasikan timeout dan retry strategy:
from a2a.client import A2AClient
from a2a.types import TaskSendParams, Message, TextPart, Role
import asyncio
async def sendwithretry(
client: A2AClient,
message: str,
maxretries: int = 3,
timeout: float = 30.0,
):
for attempt in range(maxretries):
try:
task = await asyncio.waitfor(
client.sendtask(
TaskSendParams(
message=Message(
role=Role.USER,
parts=[TextPart(text=message)],
)
)
),
timeout=timeout,
)
return task
except asyncio.TimeoutError:
print(f"Timeout pada percobaan {attempt + 1}/{maxretries}")
if attempt == maxretries - 1:
raise
await asyncio.sleep(2 attempt)
except Exception as e:
print(f"Error pada percobaan {attempt + 1}: {e}")
if attempt == maxretries - 1:
raise
await asyncio.sleep(2 attempt)
3. Logging dan Observability
Pastikan setiap interaksi antar agent ter-log dengan baik untuk debugging:
import logging
from a2a.server import TaskHandler, TaskContext
from a2a.types import TaskState, Message, TextPart, Role
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger("a2a.agent")
class ObservableTaskHandler(TaskHandler):
async def handletask(self, context: TaskContext) -> None:
taskid = context.task.id
logger.info(f"[{taskid}] Task received - State: {context.task.state}")
try:
await context.updatestate(TaskState.WORKING)
logger.info(f"[{taskid}] Processing started")
result = await self.process(context)
response = Message(
role=Role.AGENT,
parts=[TextPart(text=result)],
)
await context.addmessage(response)
await context.complete()
logger.info(f"[{taskid}] Task completed successfully")
except Exception as e:
logger.error(f"[{taskid}] Task failed: {e}")
errormsg = Message(
role=Role.AGENT,
parts=[TextPart(text=f"Error: {str(e)}")],
)
await context.addmessage(errormsg)
await context.fail()
async def process(self, context: TaskContext) -> str:
return "Processed result"
4. Keamanan
Selalu validasi input dan implementasikan autentikasi antar agent:
from a2a.server import A2AServer, TaskHandler, TaskContext
from a2a.types import AgentCard, AgentCapabilities
server = A2AServer(
agentcard=AgentCard(
name="Secure Agent",
description="Agent dengan autentikasi",
url="https://secure-agent.example.com",
version="1.0.0",
capabilities=AgentCapabilities(),
authentication={
"schemes": ["bearer"],
"credentials": "API key required",
},
skills=[],
),
taskhandler=handler,
)
5. Gunakan Artifacts untuk Output Terstruktur
Untuk output yang bukan sekadar teks (file, gambar, data), gunakan Artifacts:
from a2a.types import Artifact, FilePart
import base64
async def handletask(self, context):
# Generate file (misalnya chart PNG)
chartbytes = generatechart()
artifact = Artifact(
name="sales-chart-q3.png",
description="Grafik penjualan Q3 2026",
parts=[
FilePart(
file={
"name": "sales-chart-q3.png",
"mimeType": "image/png",
"bytes": base64.b64encode(chartbytes).decode(),
}
)
],
)
await context.addartifact(artifact)
await context.complete()
Contoh Use Case: Pipeline Analisis Data Multi-Agent
Berikut contoh real-world di mana 3 agent bekerja sama untuk menganalisis data:
# pipeline.py
import asyncio
from a2a.client import A2AClient
from a2a.types import TaskSendParams, Message, TextPart, Role
async def dataanalysispipeline(dataseturl: str):
# Agent 1: Data Collector - mengambil dan membersihkan data
collector = A2AClient(url="http://localhost:8001")
# Agent 2: Analyst - menganalisis data
analyst = A2AClient(url="http://localhost:8002")
# Agent 3: Reporter - membuat laporan
reporter = A2AClient(url="http://localhost:8003")
print("Step 1: Collecting and cleaning data...")
collecttask = await collector.sendtask(
TaskSendParams(
message=Message(
role=Role.USER,
parts=[TextPart(text=f"Ambil dan bersihkan data dari: {dataseturl}")],
)
)
)
cleaneddata = ""
if collecttask.messages:
for part in collecttask.messages[-1].parts:
if hasattr(part, "text"):
cleaneddata = part.text
print("Step 2: Analyzing data...")
analysistask = await analyst.sendtask(
TaskSendParams(
message=Message(
role=Role.USER,
parts=[TextPart(text=f"Analisis data berikut:\n{cleaneddata}")],
)
)
)
analysisresult = ""
if analysistask.messages:
for part in analysistask.messages[-1].parts:
if hasattr(part, "text"):
analysisresult = part.text
print("Step 3: Generating report...")
reporttask = await reporter.sendtask(
TaskSendParams(
message=Message(
role=Role.USER,
parts=[
TextPart(
text=(
f"Buat laporan dari analisis berikut:\n{analysisresult}"
)
)
],
)
)
)
if reporttask.messages:
for part in reporttask.messages[-1].parts:
if hasattr(part, "text"):
print(f"\nLaporan Final:\n{part.text}")
return reporttask
if name == "main":
asyncio.run(
dataanalysis_pipeline("https://example.com/sales-data-2026.csv")
)
Kesimpulan
Google A2A Protocol membuka era baru dalam pengembangan sistem AI multi-agent. Dengan standar komunikasi yang terbuka dan terstruktur, developer kini bisa membangun sistem di mana agent-agent spesialis berkolaborasi untuk menyelesaikan tugas yang kompleks.
Poin-poin penting yang perlu diingat: