Google'ın Agent Development Kit'i (ADK): Demo Projesiyle Rehber

Proje Genel Bakış: ADK ve A2A ile Yapay Zekâ Destekli Seyahat Planlayıcı

Bu proje, aşağıdakileri yapan bir seyahat planlayıcı oluşturur:

• Girdi olarak varış noktası, tarihler ve bütçeyi alır.
• Üç ayrı ajanı çağırır:
• flight_agent:  Uçuş seçenekleri önerir.
• stay_agent: Bütçe dâhilinde otel bulur.
• activities_agent: İlgi çekici aktiviteler önerir.
• Ardından tüm istekleri orkestre etmek için merkezi bir host_agent kullanır.
• Son olarak kullanıcı etkileşimi için bir Streamlit arayüzü kullanır.

Tüm ajanlar ayrı FastAPI sunucuları olarak barındırılır ve bir /run uç noktası sunar. İletişim, paylaşılan A2A uyumlu istemci aracılığıyla gerçekleştirilir.

Not: Basit tutmak için bu proje tamamen yerel makinenizde çalışır; ancak her ajanı ve arayüzü Render, Railway veya Google Cloud Run gibi bulut platformlarına kolayca dağıtabilirsiniz.

Adım 1: Önkoşullar

Şu kütüphaneleri yükleyerek başlayalım:

pip install google-adk litellm fastapi uvicorn httpx pydantic openai streamlit

Ardından OpenAI API anahtarınızı ayarlayın—başka bir model sağlayıcısı da kullanabilirsiniz. OpenAI API anahtarınızı nasıl ayarlayacağınıza dair bilgi için GPT-4o API üzerine bu giriş niteliğindeki eğitimi öneririm.

export OPENAI_API_KEY="your_key_here"

Adım 2: Paylaşılan Şema ve Yardımcılar

Zeki ajanlar oluşturmadan önce, birbirleriyle konuşmaları için ortak bir dil tanımlamamız gerekir. Bizim kurulumumuzda bu şu şekilde yapılır:

• Girdi için paylaşılan bir şema (Pydantic ile tanımlanır)
• Ajanları çağırmak için bir REST istemci yardımcısı
• Tüm ajanlarda /run uç noktasını standartlaştıran bir REST sunucu sarmalayıcısı

Bunlar kodu modüler tutmak için shared/ ve common/ klasörlerine yerleştirilir. Her birine bakalım.

Bir shared/schemas.py dosyası oluşturma

Pydantic kullanarak bir TravelRequest şeması tanımlıyoruz. Bu, tüm ajanların gelen isteklerin yapısı üzerinde uzlaşmasını sağlar; bu yapı varış noktası, seyahat tarihleri ve kullanıcı bütçesini içerir.

from pydantic import BaseModel
class TravelRequest(BaseModel):
    destination: str
    start_date: str
    end_date: str
    budget: float

Bu sınıf şunlara yardımcı olur:

• Tüm ajanlar için girdiyi tutarlı tutmak.
• FastAPI ile otomatik doğrulama eklemek.
• Kodun tekrar kullanımını basitleştirmek.

Bir common/a2a_client.py dosyası oluşturma

Bu hafif asenkron yardımcı, herhangi bir ajanın (özellikle host) /run uç noktasını çağırarak A2A protokolü aracılığıyla başka bir ajanı çağırmasına olanak tanır.

import httpx
async def call_agent(url, payload):
    async with httpx.AsyncClient() as client:
        response = await client.post(url, json=payload, timeout=60.0)
        response.raise_for_status()
        return response.json()

Bu yardımcı, httpx kullanarak başka bir ajanın /run uç noktasına asenkron bir POST isteği gönderir.  İsteğin başarısız olması hâlinde bir hata yükseltir ve ayrıştırılmış JSON yanıtını döndürür.

Bu yardımcının host_agent içinde flight_agent, stay_agent ve activities_agent çağrılarında kullanılacağını göreceğiz.

Bir common/a2a_server.py dosyası oluşturma

Her ajan için özel bir FastAPI rotası yazmak yerine, create_app(agent) işlevini kullanarak genelleştiriyoruz; bu işlev şunları ele alır:

• /run üzerinde ajanın sunulması
• Bir seyahat isteğinin alınması
• Yapılandırılmış bir yanıtın döndürülmesi

from fastapi import FastAPI
import uvicorn
def create_app(agent):
    app = FastAPI()
    @app.post("/run")
    async def run(payload: dict):
        return await agent.execute(payload)
    return app

Bu yardımcı, sağlanan ajana yürütmeyi devreden standart bir /run rotasına sahip bir FastAPI uygulaması oluşturur.  Yapılandırılmış JSON girişi kullanan tüm hizmetler için tutarlı bir ajanlar arası (A2A) arayüz sağlar.

Birlikte ele alındığında bu paylaşılan bileşenler, çoklu ajan sistemimizi daha sürdürülebilir, yeniden kullanılabilir ve Google’ın basit, yapılandırılmış ajanlar arası mesajlaşma felsefesi olan A2A ile uyumlu hâle getirir.

Adım 3: ADK ve A2A ile Çoklu Ajanlı Sistemin İnşası

Artık paylaşılan sözleşmeler ve yardımcılar hazır olduğuna göre, tek tek ajanları oluşturmaya başlayalım. Bunu gerçekten modüler ve çoklu ajanlı bir sisteme dönüştürmek için Google’ın A2A protokolünü—ajanların tutarlı ve birlikte çalışabilir biçimde iletişim kurmasını sağlayan basit HTTP tabanlı arayüzü—kullanacağız.

A2A (Agent-to-Agent), ajanlar yerel Python işlevleri olsa da ağlar arasında barındırılsa da tak-çalıştır koordinasyon sağlar. Her ajan, ortak bir şemaya sahip bir /run uç noktası sunar ve bir servis gibi davranır.

Demo’muzda dört ajan var:

• host_agent: Diğer tüm ajanları orkestre eder
• flight_agent: Uygun uçuşları bulur
• stay_agent: Konaklama önerir
• activities_agent: Yerel etkinlikler için önerilerde bulunur

Tüm ajanlar benzer şekilde yapılandırılmıştır; 3 dosya ve bir alt klasörle:

agents/
├── host_agent/
│   │   ├── agent.py              # Optional if host logic is minimal
│   │   ├── task_manager.py       # Calls other agents and aggregates responses
│   │   ├── __main__.py           # Starts FastAPI app via common/a2a_server.py
│   │   └── .well-known/
│   │       └── agent.json        # A2A Agent Card metadata
├── flight_agent/
├── stay_agent/
└── activities_agent/

Her ajan, google.adk.agents.Agent, bir LiteLlm model sarmalayıcı ve yürütme için Runner kullanır. activities_agent klasörü içinde aşağıdaki dosyaları oluşturarak başlayın ve aynılarını flight_agent ve stay_agent için de tekrarlayın.

Bir agent.py dosyası oluşturma

Şimdi, kullanıcının seyahat planına göre ilgi çekici yerel deneyimler oluşturmaktan sorumlu olacak activities_agent mantığını tanımlayalım. 

Adım 1: İçe aktarımlar

Ajana yapılandırma ve çalıştırma için gerekli modülleri içe aktararak başlıyoruz.

from google.adk.agents import Agent
from google.adk.models.lite_llm import LiteLlm
from google.adk.runners import Runner
from google.adk.sessions import InMemorySessionService
from google.genai import types
import json

Bu ajan, Google ADK’nin Agent, ' Runner, ' ve LiteLlm gibi bileşenlerini kullanır ve durumu InMemorySessionService ile yönetir. Types kitaplığı, yapılandırılmış istemler oluşturmak için kullanılır.

Adım 2: Activities ajanı 

Şimdi, ADK’nın Agent sınıfını kullanarak ajanın kendisini oluşturuyoruz.

activities_agent = Agent(
    name="activities_agent",
    model=LiteLlm("openai/gpt-4o"),
    description="Suggests interesting activities for the user at a destination.",
    instruction=(
        "Given a destination, dates, and budget, suggest 2-3 engaging tourist or cultural activities. "
        "For each activity, provide a name, a short description, price estimate, and duration in hours. "
        "Respond in plain English. Keep it concise and well-formatted."
    )
)

Instruction parametresi, LLM’in davranışını yönlendiren sistem istemini tanımlar. Bu örnekte sade İngilizce kullanılsa da daha kolay ayrıştırma için çıktıyı yapılandırılmış JSON olarak döndürecek şekilde instruction’ı uyarlayabilirsiniz.

Adım 3: Oturum yönetimi

Sırada, kullanıcı etkileşimlerini takip etmek için bir Runner ve oturum bilgisini yapılandırıyoruz.

session_service = InMemorySessionService()
runner = Runner(
    agent=activities_agent,
    app_name="activities_app",
    session_service=session_service
)
USER_ID = "user_activities"
SESSION_ID = "session_activities"

Runner, belirli bir uygulama oturumu için ajanın yürütmesini yönetir. InMemorySessionService sınıfı ise bağlamı bellekte saklar. Ardından kullanıcı ve oturum kimliklerini tanımlarız. Üretimde bunlar dinamik veya kullanıcıya özgü olabilir. Bu, LLM ajanına herhangi bir istem göndermeden önce yeni bir ADK oturumunun var olmasını sağlar.

Adım 4: Ajan mantığını yürütme

execute() işlevi gelen istekleri işler, bir istem oluşturur, modeli çağırır ve çıktıyı ayrıştırır.

async def execute(request):
    session_service.create_session(
        app_name="activities_app",
        user_id=USER_ID,
        session_id=SESSION_ID
    )
    prompt = (
        f"User is flying to {request['destination']} from {request['start_date']} to {request['end_date']}, "
        f"with a budget of {request['budget']}. Suggest 2-3 activities, each with name, description, price estimate, and duration. "
        f"Respond in JSON format using the key 'activities' with a list of activity objects."
    )
    message = types.Content(role="user", parts=[types.Part(text=prompt)])
    async for event in runner.run_async(user_id=USER_ID, session_id=SESSION_ID, new_message=message):
        if event.is_final_response():
            response_text = event.content.parts[0].text
            try:
                parsed = json.loads(response_text)
                if "activities" in parsed and isinstance(parsed["activities"], list):
                    return {"activities": parsed["activities"]}
                else:
                    print("'activities' key missing or not a list in response JSON")
                    return {"activities": response_text}  # fallback to raw text
            except json.JSONDecodeError as e:
                print("JSON parsing failed:", e)
                print("Response content:", response_text)
                return {"activities": response_text}  # fallback to raw text

execute() işlevi, varış noktası, tarihler ve bütçe gibi gelen istek parametrelerini kullanarak dinamik bir istem oluşturur. Kaputun altında şunlar olur:

• İstem, modelden bir aktiviteler listesi içeren yapılandırılmış bir JSON nesnesi döndürmesini ister.
• Bir Content nesnesi oluşturulur ve ADK Runner’a iletilir; Runner, akış üreteci kullanarak modelin nihai yanıtını asenkron olarak bekler.
• Nihai yanıt alındığında ajan ham metin çıktısını çıkarır ve JSON olarak ayrıştırmaya çalışır.
• Ayrıştırma başarılı olur ve beklenen activities anahtarı mevcutsa, yapılandırılmış veri döndürülür.
• Anahtar eksikse veya hatalıysa, arayüzün yine de kullanılabilir çıktısı olması için geri dönüş olarak ham metin döndürülür.
• Bu çift yönlü işleme yaklaşımı, LLM yapılandırılmış JSON yerine düz metin döndürdüğünde zarif bir şekilde bozulmayı sağlar.

Bu strateji, özellikle model çıktıları sıcaklık veya istem yorumlamasına bağlı olarak biraz değiştiğinde sağlamlığı ve kullanıcı deneyimini artırır.

Bir task_manager.py dosyası oluşturma

agent.py içinde execute() mantığını tanımladıktan sonra, şimdi bunu task_manager.py kullanarak ADK uyumlu sunucu kurulumuna bağlıyoruz.

from .agent import execute
async def run(payload):
    return await execute(payload)

Bu dosya, daha önce tanımlanan execute() işlevi etrafında ince bir sarmalayıcı görevi görür. run() yöntemini özellikle __main__.py içindeki sunucu betiğine dış modüller için kullanılabilir kılar.

Bir __main__.py dosyası oluşturma

__main__.py dosyası, ajanın /run uç noktasında hizmet vereceği şekilde 8003 portunda bir FastAPI sunucusu başlatır.

from common.a2a_server import create_app
from .task_manager import run
app = create_app(agent=type("Agent", (), {"execute": run}))
if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, port=8003)

Burada olanlar şunlar:

• create_app() (common/a2a_server.py’den), ajanımızı standart A2A uyumlu bir FastAPI arayüzüne sarar.
• ADK’nın run()u doğru şekilde çağırabilmesi için dinamik olarak bir execute() yöntemi olan bir nesne oluşturuyoruz.
• Bu ayrım, çekirdek ajan mantığını yeniden kullanırken durumsuz API arayüzlerini korumamıza olanak tanır.

Bir .well-known/agent.json dosyası oluşturma

Bu JSON dosyasını, A2A (Agent-to-Agent) protokolüne göre ajanın kimliğini ve amacını tanımlamak için kullanıyoruz.

{
    "name": "activity_agent",
    "description": "Agent providing activity details."
  }

Not: .well-known/agent.json dosyası bu projede ajanlarımız tarafından doğrudan kullanılmasa da A2A spesifikasyonuna uygundur ve LangGraph, CrewAI veya Google’ın ajan kayıt defteri gibi orkestratörlerle keşif, içgörü ve gelecekteki uyumluluk açısından önemlidir.

Benzer mantık flight_agent ve stay_agent için de kullanılır.

Adım 4: host_agent ile Koordinasyon

host_agent, demoda merkezi bir planlayıcı gibi davranır. host_agent, çoklu ajan sistemlerinde denetleyici (controller) desenine örnektir. Karar alma ile yürütmeyi birbirinden ayırır; her alt ajanın kendi alanına odaklanmasını sağlarken koordinasyon mantığını merkezileştirir. Bu, yalnızca test ve ölçeklemeyi basitleştirmekle kalmaz; aynı zamanda dağıtık sistemlerde gerçek dünya mikro hizmet mimarisini de yansıtır.

Aynı yükü üç ajanın her birine, sundukları /run API’leri üzerinden gönderir ve sonuçları birleştirir. host_agent klasörüne aşağıdaki dosyaları ekleyelim.

Bir agent.py dosyası oluşturma

Temel içe aktarımlar ile başlayalım.

from google.adk.agents import Agent
from google.adk.models.lite_llm import LiteLlm
from google.adk.runners import Runner
from google.adk.sessions import InMemorySessionService
from google.genai import types

Bu içe aktarma bloğu, Google ADK kullanarak LLM tabanlı bir ajanı tanımlamak ve çalıştırmak için gereken tüm çekirdek yapı taşlarını getirir: Agent sınıfı, hafif LLM sarmalayıcı, yürütmeyi yöneten Runner ve bellek içi oturum yönetimi.

host_agent = Agent(
    name="host_agent",
    model=LiteLlm("openai/gpt-4o"),
    description="Coordinates travel planning by calling flight, stay, and activity agents.",
    instruction="You are the host agent responsible for orchestrating trip planning tasks. "
                "You call external agents to gather flights, stays, and activities, then return a final result."
)
session_service = InMemorySessionService()
runner = Runner(
    agent=host_agent,
    app_name="host_app",
    session_service=session_service
)
USER_ID = "user_host"
SESSION_ID = "session_host"

Yukarıdaki kod, tüm seyahat planını koordine etmekten sorumlu üst düzey bir ADK ajanını tanımlar. Bu uygulamada alt ajanları LLM içinden çağırmasak da sistem istemi, LLM’in gelecekte araç kullanımı ve meta-akıl yürütmeyi üstlenebileceği bir genişletmeye zemin hazırlar.

async def execute(request):
    # Ensure session exists
    session_service.create_session(
        app_name="host_app",
        user_id=USER_ID,
        session_id=SESSION_ID
    )
    prompt = (
        f"Plan a trip to {request['destination']} from {request['start_date']} to {request['end_date']} "
        f"within a total budget of {request['budget']}. Call the flights, stays, and activities agents for results."
    )
    message = types.Content(role="user", parts=[types.Part(text=prompt)])
    async for event in runner.run_async(user_id=USER_ID, session_id=SESSION_ID, new_message=message):
        if event.is_final_response():
            return {"summary": event.content.parts[0].text}

Bu execute() işlevi, host ajanın LLM’ine ana giriş noktası görevi görür ve şu adımları izler:

• Bir oturum başlatır (gerekirse bellek desteği için)
• Dinamik olarak bir kullanıcı istemi oluşturur
• İsteği ADK’nın runner.run_async() yöntemiyle modele gönderir
• Son olarak nihai yanıtı bekler ve çıkarır

Bir task_manager.py dosyası oluşturma

Görev yöneticisi, uzak ajanları çağırarak ve tüm seyahat planlama iş akışını ele alarak orkestrasyon mantığını yürütür. Pratik uygulaması için, her alt ajan için hizmet URL’lerini tanımlıyoruz. Bu uç noktalar A2A /run protokolüne uyar ve ortak TravelRequest` JSON şeması bekler.

from common.a2a_client import call_agent
FLIGHT_URL = "http://localhost:8001/run"
STAY_URL = "http://localhost:8002/run"
ACTIVITIES_URL = "http://localhost:8003/run"

Şimdi, yükü tanımlayalım.

async def run(payload):
    #Print what the host agent is sending
    print("Incoming payload:", payload)
    flights = await call_agent(FLIGHT_URL, payload)
    stay = await call_agent(STAY_URL, payload)
    activities = await call_agent(ACTIVITIES_URL, payload)
    # Log outputs
    print("flights:", flights)
    print("stay:", stay)
    print("activities:", activities)
    # Ensure all are dicts before access
    flights = flights if isinstance(flights, dict) else {}
    stay = stay if isinstance(stay, dict) else {}
    activities = activities if isinstance(activities, dict) else {}
    return {
        "flights": flights.get("flights", "No flights returned."),
        "stay": stay.get("stays", "No stay options returned."),
        "activities": activities.get("activities", "No activities found.")
    }

Bu işlev, yükü her bir alt hizmete iletmek için call_agent() yardımcı işlevini kullanır ve geliştirme sırasında görünürlük için girdileri ve çıktıları günlüğe kaydeder. Gerçek orkestrasyon mantığının yaşadığı yer esasen burasıdır.

Bir __main__.py dosyası oluşturma

__main__.py dosyası, host ajanı saran FastAPI sunucusu için giriş noktası görevi görür. 

from common.a2a_server import create_app
from .task_manager import run
app = create_app(agent=type("Agent", (), {"execute": run}))
if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, port=8000)

Ana dosya şunları yapar:

• Standart bir /run uç noktası olan bir FastAPI uygulaması oluşturmak için common/a2a_server.py içindeki create_app()i kullanır.
• Daha sonra, dahili olarak task_manager.run() işlevine delege eden bir execute() yöntemine sahip basit bir ajan benzeri nesneyi iletir.
• Son olarak, FastAPI sunucusunu belirtilen bir bağlantı noktasında (genellikle 8000) uvicorn ile başlatır.

Bu, host ajanın arayüzünü diğer alt ajanlarla hizalar ve sistem genelinde tutarlılığı korur.

Bir .well-known/agent.json dosyası oluşturma

Bu dosya, merkezi bir düğümün görevleri devredip birleştirdiği klasik bir çoklu ajan deseninde görev yapar. 

{
  "name": "host_agent",
  "description": "Coordinates travel planning among specialized agents."
}

Zorunlu olmasa da, daha önce açıklandığı gibi tüm ajan dizinlerine bunu eklemek iyi bir uygulamadır.

Adım 5: Streamlit ile Arayüz Oluşturma

Son olarak, kullanıcıların tercihlerini girebilecekleri ve yapılandırılmış bir gezi planı alabilecekleri basit bir uygulama oluşturalım. Kök dizinde bir travel_ui.py dosyası oluşturun ve aşağıdaki kodu ekleyin.

import streamlit as st
import requests

UI desteği için Streamlit ve requests gibi temel kütüphaneleri içe aktarıyoruz.

st.set_page_config(page_title="ADK-Powered Travel Planner", page_icon="✈️")
st.title("🌍 ADK-Powered Travel Planner")
origin = st.text_input("Where are you flying from?", placeholder="e.g., New York")
destination = st.text_input("Destination", placeholder="e.g., Paris")
start_date = st.date_input("Start Date")
end_date = st.date_input("End Date")
budget = st.number_input("Budget (in USD)", min_value=100, step=50)
if st.button("Plan My Trip ✨"):
    if not all([origin, destination, start_date, end_date, budget]):
        st.warning("Please fill in all the details.")
    else:
        payload = {
            "origin": origin,
            "destination": destination,
            "start_date": str(start_date),
            "end_date": str(end_date),
            "budget": budget
        }
        response = requests.post("http://localhost:8000/run", json=payload)
        if response.ok:
            data = response.json()
            st.subheader("✈️ Flights")
            st.markdown(data["flights"])
            st.subheader("🏨 Stays")
            st.markdown(data["stay"])
            st.subheader("🗺️ Activities")
            st.markdown(data["activities"])
        else:
            st.error("Failed to fetch travel plan. Please try again.")

Streamlit uygulaması, ADK ile oluşturulan çoklu ajanlı seyahat planlayıcıyla etkileşim için kullanıcı dostu bir arayüz sağlar. Yukarıdaki kodda değindiğimiz birkaç nokta:

• text_input, date_input ve number_input kullanarak kalkış noktası, varış noktası, tarihler ve bütçeyi toplar.
• “Plan My Trip” tıklandığında, hiçbir alanın boş bırakılmadığından emin olmak için girişi doğrular.
• Geçerliyse, bir JSON yükü oluşturur ve http://localhost:8000/run adresindeki host_agent’a bir POST isteği gönderir.
• host_agent, tüm alt ajanları (uçuş, konaklama, aktivite) çağırır, yanıtları birleştirir ve tek bir seyahat planı döndürür.
• Yanıt, uçuşlar, konaklamalar ve aktiviteler için ayrı başlıklar altında st.markdown() yöntemiyle ayrıştırılıp görüntülenir.
• Arka uç başarısız olursa, st.error() kullanılarak bir hata mesajı gösterilir.

Şimdi, yerelde terminalinizde aşağıdaki komutu çalıştırın:

uvicorn agents.host_agent.__main__:app --port 8000 &
uvicorn agents.flight_agent.__main__:app --port 8001 &
uvicorn agents.stay_agent.__main__:app --port 8002 &      
uvicorn agents.activities_agent.__main__:app --port 8003 &
streamlit run travel_ui.py

Bir kullanıcı “Plan My Trip”e tıkladığında, host ajan devreye girer, ajanları çalıştırır ve sonuçları arayüzde gösterir:

Genel dosya yapınız aşağıdakine benzer olacaktır:

ADK_demo/
├── agents/
│   ├── host_agent/
│   │   ├── agent.py              
│   │   ├── task_manager.py      
│   │   ├── __main__.py         
│   │   └── .well-known/
│   │       └── agent.json   
│   │
│   ├── flight_agent/
│   │   ├── agent.py        
│   │   ├── task_manager.py    
│   │   ├── __main__.py         
│   │   └── .well-known/
│   │       └── agent.json        
│   │
│   ├── stay_agent/
│   │   ├── agent.py              
│   │   ├── task_manager.py       
│   │   ├── __main__.py           
│   │   └── .well-known/
│   │       └── agent.json     
│   │
│   └── activities_agent/
│       ├── agent.py              
│       ├── task_manager.py       
│       ├── __main__.py           
│       └── .well-known/
│           └── agent.json       
│
├── common/
│   ├── a2a_client.py             # Utility to send requests to other agents
│   └── a2a_server.py             # Shared FastAPI A2A-compatible server template
│
├── shared/
│   └── schemas.py                # Shared Pydantic schema
│
├── streamlit_app.py             # Frontend UI for user input and response rendering
├── requirements.txt           
└── README.md                    

Ve hepsi bu kadar! Oluşturduğumuz her şeyi bu GitHub projesinde bir araya getirdim.

Sonuç

Yalnızca birkaç FastAPI uygulaması ve ADK ajanıyla, aşağıdakileri yapan iş birliğine dayalı bir seyahat planlayıcı oluşturduk:

• A2A protokolü üzerinden iletişim kurar
• Uçuşlar, konaklamalar ve aktiviteler için LLM ajanları kullanır
• Sonuçları temiz bir Streamlit arayüzünde birleştirip gösterir

Tüm ajanlar kaputun altında aynı modeli kullansa da bu sistem davranış olarak çoklu ajandır; yani ajanların farklı rolleri, izole sorumlulukları ve yapılandırılmış iletişimi vardır.

Başlamak için birkaç kaynak:

• A2A GitHub
• ADK ile hava durumu botu oluşturun
• A2A teknik dokümantasyonu