Tutorial Google A2A Protocol: Membangun Sistem Multi-Agent yang Saling Berkomunikasi

# 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. Bay...

By Ruby Abdullah · · tutorial
A2AMulti-AgentGoogleProtocolPython

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:

  • Vendor lock-in: Agent dari satu platform tidak bisa berkomunikasi dengan agent dari platform lain
  • Kompleksitas integrasi: Setiap pasangan agent membutuhkan konektor khusus
  • Kurangnya standar: Tidak ada cara standar untuk menemukan kemampuan agent
  • Opaque communication: Sulit memantau dan men-debug interaksi antar agent
  • 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

    agentcard = 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,

    )

    writercard = 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:

    Artikel Terkait

    Tutorial CAMEL-AI: Framework Multi-Agent Communication untuk Membangun Sistem AI Kolaboratif

    Tutorial Lengkap CAMEL-AI: Framework Multi-Agent Communication untuk Membangun Sistem AI Kolaboratif Penulis: Ruby Abdul...

    OpenAI Agents SDK: Membangun Sistem Multi-Agent dengan Handoff dan Guardrail

    OpenAI Agents SDK: Membangun Sistem Multi-Agent dengan Handoff dan Guardrail Halo temen-temen, kali ini kita bahas OpenA...

    Tutorial Lengkap Google Agent Development Kit (ADK): Membangun AI Agent dengan Python

    Tutorial Lengkap Google Agent Development Kit (ADK): Membangun AI Agent dengan Python Google Agent Development Kit (ADK)...

    AutoGen: Framework Multi-Agent Conversation dari Microsoft

    AutoGen: Framework Multi-Agent Conversation dari Microsoft AutoGen adalah framework open-source dari Microsoft Research ...