Google ADK tutoriál: Tvorba AI agentů od nuly do produkce

Google ADK tutoriál: Tvorba AI agentů od nuly do produkce

Google Agent Development Kit (ADK) je framework, díky kterému jsou multi-agentní systémy konečně přístupné. Pokud jste dosud stavěli AI agenty s LangChain nebo CrewAI a měli pocit, že s frameworkem spíš bojujete, než abyste s ním stavěli, tento Google ADK tutoriál vás provede vším — od prvního agenta až po nasazení na Cloud Run.

Co je Google ADK (a proč by vás měl zajímat)?

Agent Development Kit (ADK) od Googlu je open-source Python framework pro tvorbu, evaluaci a nasazování AI agentů. Vyšel v roce 2025, je optimalizovaný pro Gemini, ale přes LiteLLM podporuje více než 100 modelů. Zabijáckou funkcí ADK je nativní orchestrace multi-agentů — agenti delegují úkoly na jiné agenty bez nutnosti psát propojovací kód.

Poté, co jsme stavěli agenty s LangChain, CrewAI a teď ADK, je zřejmé jedno: ADK má jasné názory tam, kde to dává smysl. Dává vám strukturu projektu, vestavěné vývojářské UI a příkaz pro nasazení. Nesesazujete dohromady pět knihoven, jen abyste rozjeli základního agenta.

Pokud je LangChain univerzální švýcarský nůž, ADK je účelová sada nástrojů od Googlu pro multi-agentní workflow. CrewAI je filozofií blíž — role-based agenti, kteří spolupracují — ale ADK jde dál díky vestavěné evaluaci, nativní optimalizaci pro Gemini a nasazení na Cloud Run jedním příkazem. Podrobnější rozbor najdete v našem detailním srovnání agentských frameworků.

Pro koho je ADK? Pro Python vývojáře, kteří chtějí strukturované multi-agentní systémy. Pro týmy, které už jedou na Google Cloud nebo Gemini. Pro každého, koho unavuje psát boilerplate orchestrační logiku.

Zde je přehledné srovnání frameworků:

Krátká verze: pokud chcete nejrychlejší cestu od „nápadu" k „nasazenému multi-agentnímu systému", ADK se právě teď těžko hledá konkurence.

Předpoklady a instalace Google ADK

Pro začátek s Google ADK potřebujete Python 3.9+, klíč Gemini API (bezplatná úroveň je dostupná na Google AI Studio) a balíček google-adk. Nainstalujte pomocí pip install google-adk, nastavte API klíč jako proměnnou prostředí a můžete stavět prvního agenta během 5 minut.

Zde je váš instalační checklist:

• Python 3.9+ (doporučeno 3.10+ pro plnou podporu type hints)
• Klíč Gemini API — získejte zdarma na aistudio.google.com. Bezplatná úroveň vám dá 15 požadavků za minutu, což na vývoj bohatě stačí.
• pip (nebo uv, pokud preferujete rychlost — funguje i uv pip install google-adk)

Nainstalujte balíček a nastavte klíč:

pip install google-adk

# Set your API key (add to .bashrc/.zshrc for persistence)
export GOOGLE_API_KEY="your-api-key-here"

ADK očekává specifickou strukturu složek. Každý agent žije ve vlastní adresářové složce (package):

my_agent/
  __init__.py    # Exports root_agent
  agent.py       # Agent definition
.env             # Optional: GOOGLE_API_KEY=your-key

Název složky se stane názvem balíčku vašeho agenta, takže zvolte něco popisného. Nenazývejte ho test nebo agent — zmátli byste importní systém Pythonu.

Tip pro pokročilé: Pokud používáte uv, vytvořte si nejdřív virtuální prostředí pomocí uv venv && source .venv/bin/activate. Při řešení závislostí je znatelně rychlejší než běžný pip.

Stavba prvního agenta Google ADK

Váš první ADK agent potřebuje jen tři věci: jméno, model (např. gemini-2.0-flash) a řetězec s instrukcemi. Definujte ho v agent.py, umístěte do složky se souborem __init__.py a spusťte adk web pro chatování v prohlížečovém UI. Celé nastavení zabere asi 10 řádků Pythonu.

Vytvořte složku s názvem my_agent a přidejte dva soubory. Nejprve definice agenta:

# my_agent/agent.py
from google.adk.agents import LlmAgent

root_agent = LlmAgent(
    name="my_assistant",
    model="gemini-2.0-flash",
    instruction="""You are a helpful coding assistant. 
    You explain concepts clearly and provide working code examples.
    Keep responses concise but thorough.""",
    description="A coding assistant that explains concepts and writes code"
)

Poté init soubor, který vašeho agenta exportuje:

# my_agent/__init__.py
from .agent import root_agent

Na názvu této proměnné záleží — ADK hledá konkrétně root_agent. Pokud to přehlédnete, dostanete chybu „agent not found", která nevysvětluje proč.

Teď ho spusťte. Máte dvě možnosti:

# CLI mode -- chat in your terminal
adk run my_agent

# Web UI mode -- opens a browser interface
adk web my_agent

Rozhraní adk web je opravdu užitečné. Ukazuje kompletní trasu konverzace — které nástroje agent zavolal, co model obdržel a co vrátil. Představte si ho jako Chrome DevTools pro vašeho agenta. Až začnete stavět multi-agentní systémy, stane se nezbytným pro pochopení toku delegování.

Zkuste upravit instrukce a sledujte, jak se změní chování. Udělejte z něj piráta. Nechte ho odpovídat jen v haiku. Získat cit pro to, jak instrukce formují chování, je základ pro vše ostatní v tomto tutoriálu.

Přidání vlastních nástrojů do agenta Google ADK

Agenti ADK se stanou užitečnými, když jim dáte nástroje. Definujte Python funkci se srozumitelným docstringem a ADK ji automaticky převede na nástroj, který může agent volat. Docstring je zásadní — říká modelu, co nástroj dělá a kdy ho použít. ADK také obsahuje vestavěné nástroje jako Google Search a spouštění kódu.

Nástroje jsou ruce agenta. Bez nich umí váš agent jen mluvit. S nimi dokáže kontrolovat databáze, volat API, provádět výpočty a interagovat s externími systémy. Pokud chcete pochopit, jak funguje function calling pod kapotou, máme k tomu samostatný detailní článek.

Vlastní funkční nástroje

Zde je praktický příklad — nástroj, který vyhledává ceny akcií:

# my_agent/agent.py
from google.adk.agents import LlmAgent

def get_stock_price(ticker: str) -> dict:
    """Get the current stock price for a given ticker symbol.
    
    Args:
        ticker: The stock ticker symbol (e.g., 'AAPL', 'GOOGL', 'MSFT')
    
    Returns:
        A dictionary with the ticker and its current price.
    """
    # In production, you'd call a real API here
    mock_prices = {"AAPL": 198.50, "GOOGL": 175.20, "MSFT": 425.80}
    price = mock_prices.get(ticker.upper(), None)
    if price:
        return {"ticker": ticker.upper(), "price": price, "currency": "USD"}
    return {"error": f"Ticker {ticker} not found"}

root_agent = LlmAgent(
    name="finance_assistant",
    model="gemini-2.0-flash",
    instruction="You help users check stock prices. Use the get_stock_price tool when asked about any stock.",
    tools=[get_stock_price],
    description="A financial assistant that looks up stock prices"
)

Všimněte si type hints a docstringu. Nejsou to volitelné ozdoby — ADK je používá k vygenerování schématu nástroje, které model vidí. Vynechte docstring a model nebude vědět, kdy vaši funkci zavolat. Vynechte type hints a dostanete chybu signatury.

Vestavěné nástroje (Google Search, spouštění kódu)

ADK obsahuje nástroje, které můžete použít bez psaní jakéhokoli kódu:

from google.adk.agents import LlmAgent
from google.adk.tools import google_search, code_execution

root_agent = LlmAgent(
    name="research_agent",
    model="gemini-2.0-flash",
    instruction="You research topics using Google Search and can run Python code to analyze data.",
    tools=[google_search, code_execution],
    description="A research agent with search and code execution capabilities"
)

google_search umožňuje agentovi dotazovat se na web v reálném čase. code_execution mu dává sandboxované Python prostředí pro výpočty. Jen tyto dva pokrývají překvapivé množství případů užití.

Multi-agentní systémy: Jak agenti Google ADK delegují práci

Multi-agentní systém ADK používá kořenového agenta (root agent), který deleguje úkoly na specializované dílčí agenty. Každý dílčí agent se stará o jednu doménu — výzkum, psaní, kódování. Kořenový agent rozhoduje, kterého dílčího agenta zavolá, na základě požadavku uživatele. Můžete také použít vzor agent-jako-nástroj, kdy jeden agent volá jiného, jako by to byla funkce. Oficiální blog Googlu o multi-agentních systémech zachází do větší hloubky architektonických vzorů.

Představte si to jako projektového manažera, který deleguje na specialisty. Kořenový agent přečte požadavek uživatele, zjistí, který specialista by ho měl zpracovat, a podle toho ho směruje. Specialisté o sobě navzájem nevědí — jen dělají svou práci a reportují zpět.

Vzor kořenový agent + dílčí agenti

Zde je funkční příklad s kořenovým agentem, který deleguje na výzkumného agenta a agenta pro psaní:

from google.adk.agents import LlmAgent
from google.adk.tools import google_search

# Sub-agent 1: handles research
research_agent = LlmAgent(
    name="researcher",
    model="gemini-2.0-flash",
    instruction="You research topics thoroughly using Google Search. Return factual, well-sourced information.",
    tools=[google_search],
    description="Researches topics and returns factual information"
)

# Sub-agent 2: handles writing
writing_agent = LlmAgent(
    name="writer",
    model="gemini-2.0-flash",
    instruction="You write clear, engaging content based on provided information. Focus on readability and accuracy.",
    description="Writes polished content from research notes"
)

# Root agent: delegates to the right sub-agent
root_agent = LlmAgent(
    name="content_manager",
    model="gemini-2.0-flash",
    instruction="""You manage content creation. 
    - When the user wants information gathered, delegate to the researcher.
    - When the user wants content written or edited, delegate to the writer.
    - You can chain both: research first, then write.""",
    sub_agents=[research_agent, writing_agent],
    description="Manages content creation by delegating to research and writing specialists"
)

Pole description u každého dílčího agenta je způsob, jakým kořenový agent chápe, co umí. Pište srozumitelné popisy — vágní vedou ke špatným rozhodnutím o směrování.

Vzor agent-jako-nástroj

Někdy chcete větší kontrolu nad tím, jak jeden agent volá jiného. Vzor agent-jako-nástroj zabalí dílčího agenta jako volatelný nástroj:

from google.adk.tools import agent_tool

research_tool = agent_tool.AgentTool(agent=research_agent)

root_agent = LlmAgent(
    name="writer_with_research",
    model="gemini-2.0-flash",
    instruction="You write articles. Use the research tool to gather facts before writing.",
    tools=[research_tool],
    description="A writer that can research topics on demand"
)

Dílčí agenty použijte, když chcete, aby kořenový agent plně delegoval kontrolu. Agent-jako-nástroj použijte, když chcete, aby volající agent zůstal u volantu a jen využil výstup dílčího agenta jako vstup. Pokud stavíte systémy, kde agenti potřebují sdílený kontext, podívejte se na našeho komplexního průvodce architekturami paměti agentů.

Workflow agenti: sekvenční, paralelní a smyčka

Kromě delegování řízeného LLM nabízí ADK tři typy workflow agentů pro deterministickou orchestraci: SequentialAgent spouští dílčí agenty jednoho po druhém, ParallelAgent je spouští současně a LoopAgent opakuje sekvenci, dokud není splněna podmínka. Hodí se, když potřebujete předvídatelné pořadí provádění, místo aby rozhodovalo LLM.

Na tomto rozlišení záleží. Delegování řízené LLM (výše uvedený vzor sub_agents) nechává model vybrat, koho zavolat. Workflow agenti vám dávají programovou kontrolu. Použijte workflow agenty, když je pořadí provádění známé předem.

from google.adk.agents import SequentialAgent, ParallelAgent, LlmAgent

# Three agents that must run in order
research_agent = LlmAgent(name="researcher", model="gemini-2.0-flash",
    instruction="Research the given topic.", description="Researches topics")
    
draft_agent = LlmAgent(name="drafter", model="gemini-2.0-flash",
    instruction="Write a draft based on the research.", description="Writes drafts")
    
review_agent = LlmAgent(name="reviewer", model="gemini-2.0-flash",
    instruction="Review the draft for accuracy and clarity.", description="Reviews content")

# Pipeline: research -> draft -> review
content_pipeline = SequentialAgent(
    name="content_pipeline",
    sub_agents=[research_agent, draft_agent, review_agent],
    description="Runs a complete content creation pipeline"
)

Pro nezávislé úkoly, které mohou běžet současně, ParallelAgent ušetří reálný čas:

# Three data fetchers that run concurrently
fetch_news = LlmAgent(name="news_fetcher", model="gemini-2.0-flash",
    instruction="Fetch latest tech news.", description="Fetches news")
    
fetch_stocks = LlmAgent(name="stock_fetcher", model="gemini-2.0-flash",
    instruction="Fetch stock market summary.", description="Fetches stocks")
    
fetch_weather = LlmAgent(name="weather_fetcher", model="gemini-2.0-flash",
    instruction="Fetch weather forecast.", description="Fetches weather")

morning_briefing = ParallelAgent(
    name="morning_briefing",
    sub_agents=[fetch_news, fetch_stocks, fetch_weather],
    description="Gathers morning briefing data in parallel"
)

Správa stavu a paměti

ADK spravuje stav agenta na dvou úrovních: stav relace (data v rámci konverzace, jako jsou preference uživatele shromážděné během chatu) a služby paměti (data, která přetrvávají napříč konverzacemi). Stav relace je jednoduché úložiště klíč-hodnota přístupné přes context.state. Paměť využívá služby jako InMemoryMemoryService nebo VertexAIMemoryBankService pro produkci.

Stav relace je ten jednodušší. Je to slovník připojený ke každé konverzaci:

from google.adk.agents import LlmAgent

def save_preference(key: str, value: str, context) -> str:
    """Save a user preference to session state.
    
    Args:
        key: The preference name (e.g., 'language', 'theme')
        value: The preference value
        context: The ADK context object
    
    Returns:
        Confirmation message
    """
    context.state[key] = value
    return f"Saved preference: {key} = {value}"

def get_preference(key: str, context) -> str:
    """Retrieve a user preference from session state.
    
    Args:
        key: The preference name to look up
        context: The ADK context object
    
    Returns:
        The preference value or a not-found message
    """
    value = context.state.get(key, "Not set")
    return f"{key} = {value}"

root_agent = LlmAgent(
    name="personalized_assistant",
    model="gemini-2.0-flash",
    instruction="You remember user preferences. Save them when told, recall them when asked.",
    tools=[save_preference, get_preference],
    description="An assistant that remembers user preferences"
)

Pro paměť napříč konverzacemi — ten druh, kdy si váš agent pamatuje uživatele z minulého úterý — potřebujete službu paměti:

from google.adk.memory import InMemoryMemoryService

# For development (data lost on restart)
memory_service = InMemoryMemoryService()

# For production, use VertexAIMemoryBankService
# memory_service = VertexAIMemoryBankService(project="your-project")

Kdy potřebujete paměť a kdy stav relace? Pokud jde o jednu konverzaci (nákupní košík, kontext aktuálního úkolu), použijte stav relace. Pokud to musí přežít mezi konverzacemi (uživatelské preference, minulá interakce), použijte službu paměti. Produkční vzory najdete v našem komplexním průvodci architekturami paměti agentů.

Callbacky: Řízení chování agenta

Callbacky ADK vám umožňují zachytit a upravit chování agenta ve čtyřech bodech: before_model_callback (před voláním LLM), after_model_callback (po odpovědi LLM), before_tool_callback (před spuštěním nástroje) a after_tool_callback (po výsledku nástroje). Použijte je pro validaci vstupu, bezpečnostní filtrování, logování nebo úpravu odpovědí předtím, než dorazí k uživateli.

Callbacky jsou místo, kam přidáváte guardrails. Představte si je jako middleware pro vašeho agenta — každý požadavek a odpověď jimi prochází a vy můžete cokoliv zkontrolovat, upravit nebo zablokovat.

from google.adk.agents import LlmAgent

def safety_filter(callback_context, llm_request):
    """Block requests containing harmful content patterns."""
    user_message = str(llm_request)
    blocked_patterns = ["ignore your instructions", "pretend you are"]
    
    for pattern in blocked_patterns:
        if pattern.lower() in user_message.lower():
            # Return a response directly, skipping the model call
            return {"blocked": True, "reason": "Request matched safety filter"}
    
    # Return None to proceed normally
    return None

def log_tool_usage(callback_context, tool_name, tool_result):
    """Log every tool call for monitoring."""
    print(f"[TOOL LOG] {tool_name}: {tool_result}")
    return None  # Don't modify the result

root_agent = LlmAgent(
    name="safe_assistant",
    model="gemini-2.0-flash",
    instruction="You are a helpful assistant.",
    before_model_callback=safety_filter,
    after_tool_callback=log_tool_usage,
    description="A safety-filtered assistant with tool logging"
)

before_model_callback je nejdůležitější pro produkci. Běží před každým voláním LLM a dává vám šanci zablokovat prompt injection, validovat vstupy nebo přidat systémový kontext. Pokud vrátíte objekt odpovědi, ADK model zcela přeskočí. Vraťte None pro propuštění požadavku. Další vzory najdete v hlubších vzorech pro bezpečnostní guardrails LLM.

Testování a evaluace agentů ADK

ADK obsahuje vestavěný evaluační framework se dvěma typy evaluátorů: ResponseEvaluator kontroluje, zda je finální odpověď agenta správná, a TrajectoryEvaluator ověřuje, zda agent provedl správné kroky — zavolal správné nástroje ve správném pořadí. Testovací případy pište jako JSON soubory a spouštějte je s pytest, abyste odchytili regrese před nasazením.

Proč se obtěžovat s testováním agentů? Protože jsou nedeterminističtí. Stejný vstup může produkovat různé výstupy a malá změna instrukce může jemně rozbít volání nástrojů. Podle našich zkušeností jsou agenti, kteří projdou trajektoriovou evaluací, v produkci mnohem spolehlivější než ti testovaní jen na kvalitě finálního výstupu. Širší evaluační strategie najdete v našem průvodci evaluačními strategiemi LLM.

Testovací případy patří do JSON souboru:

[
  {
    "input": "What's the stock price of AAPL?",
    "expected_output": "198.50",
    "expected_trajectory": [
      {"tool_name": "get_stock_price", "args": {"ticker": "AAPL"}}
    ]
  },
  {
    "input": "Compare AAPL and GOOGL prices",
    "expected_output": "AAPL.*198.*GOOGL.*175",
    "expected_trajectory": [
      {"tool_name": "get_stock_price", "args": {"ticker": "AAPL"}},
      {"tool_name": "get_stock_price", "args": {"ticker": "GOOGL"}}
    ]
  }
]

Poté spusťte evaluace s pytest. Python repozitář ADK má kompletní referenci evaluačního API:

# test_agent.py
import pytest
from google.adk.evaluation import ResponseEvaluator, TrajectoryEvaluator

def test_stock_agent_response():
    evaluator = ResponseEvaluator(agent=root_agent)
    results = evaluator.evaluate("test_cases.json")
    
    assert results.pass_rate >= 0.8, f"Response pass rate too low: {results.pass_rate}"

def test_stock_agent_trajectory():
    evaluator = TrajectoryEvaluator(agent=root_agent)
    results = evaluator.evaluate("test_cases.json")
    
    assert results.pass_rate >= 0.9, f"Trajectory pass rate too low: {results.pass_rate}"

Spusťte pomocí pytest test_agent.py -v. Práh nastavte podle kritičnosti — 80% přesnost odpovědí může stačit pro agenta na kreativní psaní, ale pro cokoliv, co pracuje s finančními daty, budete chtít 95 %+.

Nasazení agenta Google ADK do produkce

Nasaďte svého ADK agenta na Google Cloud Run jedním příkazem: adk deploy cloud_run --project YOUR_PROJECT --region us-central1. ADK zabalí váš kód, sestaví kontejner a spustí serverless endpoint. Pro spravovaný hosting použijte Vertex AI Agent Engine. Pro vlastní infrastrukturu ADK také podporuje Docker kontejnerizaci.

Nasadili jsme ADK agenty na Cloud Run pro interní nástroje a časy cold startu jsou překvapivě rychlé — pod 3 sekundy pro základního agenta. Pro produkční systémy zvažte doplnění nasazení o monitorovací nástroje pro produkční agenty.

Nasazení na Cloud Run (doporučeno pro většinu)

Cloud Run je nejjednodušší cesta. Jeden příkaz a váš agent žije s HTTPS endpointem:

adk deploy cloud_run \
  --project your-gcp-project-id \
  --region us-central1 \
  --service-name my-agent-service \
  --with_ui

Příznak --with_ui nasadí webové rozhraní ADK spolu s vaším agentem, takže získáte prohlížečový chat pro testování v produkci. V pozadí ADK sestaví obraz kontejneru, nahraje ho do Google Artifact Registry a vytvoří službu Cloud Run. Kompletní tok nasazení je zdokumentovaný v Cloud Run quickstartu Googlu pro ADK.

Pro vlastní infrastrukturu zde je minimální Dockerfile:

FROM python:3.11-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY . .
EXPOSE 8080
CMD ["adk", "api_server", "--port", "8080", "my_agent"]

Alternativa: Vertex AI Agent Engine

Pro enterprise týmy, které potřebují spravované škálování, monitoring a verzování, Vertex AI Agent Engine řeší infrastrukturu zcela. Vyměníte flexibilitu za pohodlí — žádné kontejnery ke správě, automatické škálování, vestavěná analytika.

Cenové aspekty

Reálná čísla, která byste měli znát:

• Bezplatná úroveň Gemini API: 15 požadavků za minutu, 1 milion tokenů/den. Dost na vývoj a lehká dema.
• Gemini 2.0 Flash (placený): 0,10 $ za milion vstupních tokenů, 0,40 $ za milion výstupních tokenů. Dost levný na produkci.
• Bezplatná úroveň Cloud Run: 2 miliony požadavků/měsíc, 360 000 GB-sekund výpočtu. Základní agent zpracovávající 1 000 požadavků/den zůstává hluboko v bezplatné úrovni.
• Tip pro optimalizaci: Použijte gemini-2.0-flash (ne gemini-2.0-pro) pro dílčí agenty, kteří dělají jednoduché směrování nebo formátování. Schopnější modely si nechte pro agenty dělající složité uvažování.

Jak Techsy přistupuje k vývoji AI agentů

V Techsy jsme stavěli multi-agentní systémy pro klienty pomocí ADK, LangGraph a CrewAI. Volba frameworku závisí na vašem stacku: pokud už jedete na Google Cloud, ADK eliminuje spoustu integračního tření. Pokud potřebujete podporu LLM od více poskytovatelů od prvního dne, LangGraph vám dá větší flexibilitu.

Naše typická spolupráce začíná architektonickými konzultacemi — mapováním vašeho případu užití na správné vzory agentů — následovaným vývojem prototypu a nasazením na Cloud Run. Zjistili jsme, že týmy ušetří 2–3 týdny tím, že architekturu zvládnou správně hned zkraje, místo aby ji později refaktorovaly.

Stavíte AI agenty pro svůj tým? Získejte bezplatnou konzultaci — pomůžeme vám vybrat správný framework a strategii nasazení.

Časté chyby a řešení problémů

Toto jsou chyby, na které narážíme nejčastěji při začátcích s ADK. Ušetřete si čas s laděním:

Tip pro ladění: adk web je tady váš nejlepší přítel. Ukazuje kompletní trasu konverzace — každé volání modelu, vyvolání nástroje a delegování agenta — v reálném čase. Když se v multi-agentním systému něco pokazí, webové UI vám ukáže přesně, kde se řetězec přetrhl.

FAQ

Co je Google ADK?

Google Agent Development Kit (ADK) je open-source Python framework pro tvorbu, evaluaci a nasazování AI agentů. Je optimalizovaný pro modely Google Gemini, ale přes integraci LiteLLM podporuje více než 100 LLM. Klíčovou silnou stránkou ADK je nativní orchestrace multi-agentů s vestavěnými nástroji, vývojářským UI a nasazením na Cloud Run jedním příkazem.

Je Google ADK zdarma?

Ano. Samotné ADK je open-source pod licencí Apache 2.0. Potřebujete klíč Gemini API, který má bezplatnou úroveň nabízející 15 požadavků za minutu a 1 milion tokenů denně. Náklady na cloudové nasazení závisí na vaší volbě hostingu — bezplatná úroveň Cloud Run pokrývá 2 miliony požadavků měsíčně.

Jaký je rozdíl mezi Google ADK a LangChain?

ADK je direktivní framework od Googlu optimalizovaný pro Gemini s nativní orchestrací multi-agentů a vestavěnými nástroji pro nasazení. LangChain je modelově agnostický se širšími integracemi třetích stran, ale výrazně větší složitostí. ADK je lepší pro týmy s prioritou Gemini, které chtějí rychlé nasazení; LangChain vyhovuje multi-provider setupům vyžadujícím maximální flexibilitu.

Podporuje Google ADK multi-agentní systémy?

Ano, a je to vlajková funkce ADK. Vytvoříte kořenového agenta, který deleguje na specializované dílčí agenty na základě požadavků uživatele. ADK také nabízí SequentialAgent, ParallelAgent a LoopAgent pro deterministickou orchestraci workflow. Vzor agent-jako-nástroj umožňuje agentům volat jiné agenty jako volatelné funkce.

Jak nasadím agenta Google ADK?

Spusťte adk deploy cloud_run --project YOUR_PROJECT --region us-central1 pro serverless nasazení na Google Cloud Run. Přidejte --with_ui pro zahrnutí prohlížečového chatovacího rozhraní. Můžete také nasadit na Vertex AI Agent Engine pro spravovaný hosting, nebo sestavit Docker kontejner pro vlastní infrastrukturu.

Umí Google ADK používat i jiné modely než Gemini?

Ano. ADK podporuje více než 100 modelů přes integraci LiteLLM, včetně Anthropic Claude, OpenAI GPT-4, Meta Llama a Mistral. Nastavte parametr modelu na modelový řetězec LiteLLM, například litellm/anthropic/claude-3-sonnet nebo litellm/openai/gpt-4o. Modely Gemini fungují nativně bez prefixu LiteLLM.

Co je webové UI ADK?

Prohlížečové ladicí rozhraní spouštěné pomocí adk web your_agent_folder. Zobrazuje trasu konverzace v reálném čase, volání nástrojů, řetězce delegování agentů a změny stavu tak, jak se dějí. Webové UI je nezbytné pro ladění multi-agentních systémů, protože ukazuje přesně, který dílčí agent zpracoval každý požadavek.

Podporuje Google ADK MCP (Model Context Protocol)?

Ano. ADK má nativní podporu Model Context Protocol, což umožňuje agentům připojit se k jakémukoli serveru nástrojů kompatibilnímu s MCP pro externí nástroje a datové zdroje. Díky tomu jsou agenti ADK interoperabilní s rostoucím ekosystémem MCP. Pro pozadí o protokolu viz náš průvodce MCP.

Jak testovat agenty ADK?

ADK obsahuje vestavěné evaluátory: ResponseEvaluator pro kontrolu kvality výstupu proti očekávaným odpovědím a TrajectoryEvaluator pro ověření, že agent zavolal správné nástroje ve správném pořadí. Testovací případy pište jako JSON soubory definující vstupy, očekávané výstupy a očekávané sekvence volání nástrojů a poté je spusťte s pytest.

Jakou verzi Pythonu Google ADK vyžaduje?

ADK vyžaduje Python 3.9 nebo vyšší. Doporučen je Python 3.10+ pro plnou podporu type hintů, na čemž záleží, protože ADK používá type hints ke generování schémat nástrojů. Python 3.11 nebo 3.12 také nabízejí smysluplná zlepšení výkonu pro agentské workloady. Nainstalujte pomocí pip install google-adk.