Belajar A2A - ADK & Framework Integration

#Pendahuluan

Di episode 11 kita membahas binding gRPC: definisi protobuf untuk service A2A, keunggulan streaming dan backpressure, serta kapan memilih gRPC dibanding HTTP/JSON. Sekarang kita naik satu level abstraksi. Alih-alih menulis server A2A dari nol dengan a2a-sdk atau a2a-sdk-ts, kita akan menghubungkan framework agent yang sudah populer supaya langsung "berbicara" A2A.

Pertanyaan besarnya sederhana: kalian sudah punya agent yang berjalan di framework favorit, bagaimana caranya membuat agent itu bisa ditemukan dan dipanggil oleh agent lain dari framework yang berbeda? Jawabannya ada di integrasi framework. Google ADK punya dukungan A2A native, sedangkan framework lain membutuhkan adapter pattern.

Roadmap episode ini: kita mulai dari mengenal Google ADK, lalu praktik mengekspos agent ADK sebagai A2A server, memakai remote A2A agent sebagai sub-agent, dan terakhir membedah adapter pattern untuk LangChain, LangGraph, CrewAI, hingga OpenAI Agents SDK.

#Mengenal Google ADK

Google ADK (Agent Development Kit) adalah framework Python resmi dari Google untuk membangun agent, diperkenalkan saat A2A pertama kali didonasikan ke Linux Foundation. ADK dirancang untuk produksi: punya konsep agent, sub-agent, tools, session, dan event-based execution. Sejak pertengahan 2025, ADK mendapat dukungan A2A native, artinya kalian tidak perlu menulis handler JSON-RPC sendiri.

Instalasi ADK dan SDK pendukungnya cukup sekali jalan:

pip install google-adk a2a-sdk uvicorn

Versi A2A SDK yang terpasang akan dideteksi otomatis oleh ADK, baik versi 0.3.x maupun 1.x.x. Artinya kalian tidak perlu menyesuaikan kode saat SDK di-upgrade.

#Mengekspos Agent ADK sebagai A2A Server

Cara paling cepat untuk mengekspos agent ADK adalah util to_a2a. Fungsi ini mengubah agent yang sudah ada menjadi ASGI app yang siap dijalankan dengan uvicorn, sekaligus membuatkan agent card secara otomatis dari metadata agent. Cukup tambahkan import to_a2a dan satu baris a2a_app = to_a2a(agent):

agent.py — ubah agent ADK menjadi A2A app

from google.adk import Agent
from google.adk.tools import google_search
from google.adk.a2a.utils.agent_to_a2a import to_a2a
 
agent = Agent(
    name="fakta_agent",
    model="gemini-2.5-flash-lite",
    description="Agent yang mencari fakta menarik menggunakan Google Search.",
    instruction="Kamu adalah agent yang membantu menemukan fakta menarik dan akurat.",
    tools=[google_search],
)
 
a2a_app = to_a2a(agent)

Jalankan server-nya:

uvicorn agent:a2a_app --host localhost --port 8001

Agent card yang digenerate otomatis bisa diakses di endpoint standar:

curl http://localhost:8001/.well-known/agent-card.json

#Memakai A2A Agent sebagai Sub-Agent

Sekarang kita balik arah: bagaimana caranya agent ADK lain memakai server A2A tersebut? ADK menyediakan komponen RemoteA2aAgent, yaitu sub-agent yang berkomunikasi dengan remote agent lewat protokol A2A. Root agent cukup mencantumkan URL agent card dari remote agent.

supervisor.py — A2A agent sebagai sub-agent

from google.adk import Agent
from google.adk.agents import RemoteA2aAgent
from google.adk.sessions import InMemorySessionService
 
remote = RemoteA2aAgent(
    name="remote_fakta",
    agent_card_url="http://localhost:8001/.well-known/agent-card.json",
)
 
supervisor = Agent(
    name="supervisor",
    model="gemini-2.5-flash",
    instruction="Gunakan sub-agent remote_fakta untuk mencari fakta menarik.",
    sub_agents=[remote],
)
 
session_service = InMemorySessionService()
app = to_a2a(supervisor)

Pola yang dijalankan RemoteA2aAgent di balik layar: supervisor mengekstrak data yang relevan dari session-nya, lalu memanggil remote agent dengan mengirim prompt dan argumen melalui message/send. Remote agent mengelola session-nya sendiri di server, lalu mengembalikan hasil. Inilah prinsip opaque agent: supervisor tidak tahu cara kerja internal remote agent, ia hanya tahu cara berkomunikasi. Jembatan ini juga lintas framework — agent dari framework lain bisa dipanggil sebagai sub-agent ADK selama ia mengekspos endpoint A2A yang sesuai.

#Adapter Pattern untuk Framework Lain

Framework seperti LangChain, LangGraph, dan CrewAI tidak punya dukungan A2A native seperti ADK. Solusinya adalah adapter: lapisan tipis yang menerjemahkan "berikan teks, kembalikan teks" milik framework ke task lifecycle A2A. Komunitas menyediakan pustaka a2a-adapter yang punya adapter siap pakai untuk banyak framework.

Instal dengan ekstra sesuai framework:

pip install "a2a-adapter[langchain]" "a2a-adapter[langgraph]" "a2a-adapter[crewai]"

Contoh mengekspos LangChain runnable sebagai A2A server:

langchain_server.py — adapter LangChain

from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from a2a_adapter import LangChainAdapter, serve_agent
 
chain = ChatPromptTemplate.from_template("Answer: {input}") | ChatOpenAI(model="gpt-4o-mini")
adapter = LangChainAdapter(runnable=chain, input_key="input")
serve_agent(adapter, port=8002)

Untuk LangGraph, tinggal bungkus graph yang sudah dikompilasi:

langgraph_server.py — adapter LangGraph

from a2a_adapter import LangGraphAdapter, serve_agent
 
graph = builder.compile()
adapter = LangGraphAdapter(graph=graph)
serve_agent(adapter, port=9002)

Sedangkan untuk CrewAI, adapter membungkus crew beserta timeout-nya:

crewai_server.py — adapter CrewAI

from a2a_adapter import CrewAIAdapter, serve_agent
 
adapter = CrewAIAdapter(crew=your_crew, timeout=600)
serve_agent(adapter, port=8001)

Semua adapter ini menghasilkan AgentCard otomatis, manajemen task, dukungan SSE streaming (LangChain dan LangGraph mendeteksi streaming otomatis), serta push notification, karena tugas-tugas protokol ditangani penuh oleh A2A SDK.

#Custom Adapter untuk OpenAI Agents SDK

Untuk framework yang tidak punya adapter siap pakai, kalian bisa menulis adapter sendiri. Kontrak minimalnya adalah mengimplementasikan method invoke dari BaseA2AAdapter. Contoh berikut membungkus agent dari OpenAI Agents SDK:

custom_server.py — adapter custom untuk OpenAI Agents SDK

from a2a_adapter import BaseA2AAdapter, serve_agent
 
class OpenAIAgentsAdapter(BaseA2AAdapter):
    async def invoke(self, user_input, context_id=None, **kwargs):
        result = await your_openai_agent.run(user_input)
        return result.final_output
 
adapter = OpenAIAgentsAdapter()
serve_agent(adapter, port=8003)

Perhatikan pembagian tanggung jawab yang rapi. Adapter hanya menjawab satu pertanyaan: "diberi teks, kembalikan teks". Sisanya — task store, SSE, push notification, dan penyajian AgentCard — diurus oleh A2A SDK. Inilah kunci design principle dari adapter pattern: kalian tidak perlu memahami seluruh spesifikasi protokol untuk ikut serta dalam ekosistem A2A.

#Penutup

Pada episode ini kita belajar bahwa A2A tidak mewajibkan kalian menulis server dari nol. Google ADK punya dukungan A2A native lewat to_a2a dan RemoteA2aAgent untuk konsumsi jarak jauh, sedangkan framework lain bisa diintegrasikan lewat adapter pattern seperti yang disediakan pustaka a2a-adapter. Dua arah integrasi ini — mengekspos dan memakai — membuat framework apapun bisa bergabung ke dalam jaringan multi-agent.

Inti yang harus dibawa pulang:

• to_a2a mengubah agent ADK menjadi A2A server sekaligus membuat agent card otomatis.
• RemoteA2aAgent memungkinkan root agent memakai agent remote sebagai sub-agent lintas framework.
• Adapter pattern menerjemahkan kontrak framework menjadi task lifecycle A2A tanpa menulis handler JSON-RPC manual.
• Streaming dan agent card otomatis ditangani A2A SDK, bukan framework asal.
• Adapter custom cukup mengimplementasikan method invoke untuk bergabung ke ekosistem A2A.

Mulai sekarang bayangkan jaringan kalian: beberapa agent dari framework berbeda saling memanggil lewat satu protokol umum. Namun, begitu banyak agent terhubung, pertanyaan keamanan muncul — di mana batas jaringan, siapa yang boleh masuk, dan bagaimana mengamankan tiap node.

Di episode 13 selanjutnya kita akan membahas Secure Multi-Agent Deployment: topologi agent pribadi versus publik, kebijakan egress dan ingress, pemanfaatan service mesh, serta hardening seperti rate limiting, sanitasi input, dan sandboxing eksekusi tool di remote agent. Sampai jumpa!