Google ADK Tutorial: AI-agents bouwen van nul tot productie

Google ADK Tutorial: AI-agents bouwen van nul tot productie

Google's Agent Development Kit (ADK) is het framework dat multi-agent systemen eindelijk behapbaar maakt. Als je AI-agents hebt gebouwd met LangChain of CrewAI en het gevoel had dat je meer tegen het framework vocht dan ermee bouwde, dan legt deze Google ADK tutorial je alles uit -- van je eerste agent tot deployment op Cloud Run.

Wat is Google ADK (en waarom zou je er om geven)?

Google's Agent Development Kit (ADK) is een open-source Python-framework voor het bouwen, evalueren en deployen van AI-agents. Uitgebracht in 2025, is het geoptimaliseerd voor Gemini maar ondersteunt via LiteLLM meer dan 100 modellen. ADK's sterkste troef is native multi-agent-orkestratie -- agents die taken delegeren aan andere agents zonder lijmcode.

Na agents te hebben gebouwd met LangChain, CrewAI en nu ADK, valt het volgende op: ADK is opinionated op de juiste plekken. Het biedt een projectstructuur, een ingebouwde dev-UI en een deploycommando. Je hoeft niet vijf bibliotheken aan elkaar te knopen om een basisagent aan de praat te krijgen.

Als LangChain een algemeen zakmes is, dan is ADK Google's doelgerichte toolkit voor multi-agent workflows. CrewAI staat qua filosofie dichter bij -- rolgebaseerde agents die samenwerken -- maar ADK gaat verder met ingebouwde evaluatie, native Gemini-optimalisatie en deployment naar Cloud Run met één commando. Bekijk voor een grondige vergelijking onze diepgaande vergelijking van agent-frameworks.

Voor wie is ADK bedoeld? Python-ontwikkelaars die gestructureerde multi-agent systemen willen bouwen. Teams die al op Google Cloud of Gemini werken. Iedereen die het zat is om boilerplate-orkestratiecode te schrijven.

Hier is een beknopt overzicht van de frameworks:

De korte versie: als je de snelste weg wilt van "idee" naar "uitgerold multi-agent systeem," is ADK momenteel moeilijk te verslaan.

Vereisten en Google ADK-installatie

Om met Google ADK te starten heb je Python 3.9+, een Gemini API-sleutel (gratis tier beschikbaar bij Google AI Studio) en het pakket google-adk nodig. Installeer met pip install google-adk, stel je API-sleutel in als omgevingsvariabele en je bent klaar om binnen 5 minuten je eerste agent te bouwen.

Dit is je setup-checklist:

• Python 3.9+ (3.10+ aanbevolen voor volledige type hint-ondersteuning)
• Een Gemini API-sleutel -- gratis te verkrijgen bij aistudio.google.com. De gratis tier geeft je 15 verzoeken per minuut, wat ruim genoeg is voor ontwikkeling.
• pip (of uv als je snelheid prefereert -- uv pip install google-adk werkt ook)

Installeer het pakket en stel je sleutel in:

pip install google-adk

# Stel je API-sleutel in (voeg toe aan .bashrc/.zshrc voor persistentie)
export GOOGLE_API_KEY="jouw-api-sleutel-hier"

ADK verwacht een specifieke mappenstructuur. Elke agent heeft zijn eigen pakketmap:

my_agent/
  __init__.py    # Exporteert root_agent
  agent.py       # Agent-definitie
.env             # Optioneel: GOOGLE_API_KEY=jouw-sleutel

De mapnaam wordt de pakketnaam van je agent, dus kies iets beschrijvends. Noem het niet test of agent -- dat verwarrt Python's importsysteem.

Pro-tip: Als je uv gebruikt, maak dan eerst een virtuele omgeving aan met uv venv && source .venv/bin/activate. Dat is merkbaar sneller dan gewone pip voor het oplossen van afhankelijkheden.

Je eerste Google ADK-agent bouwen

Je eerste ADK-agent heeft slechts drie dingen nodig: een naam, een model (zoals gemini-2.0-flash) en een instructiestring. Definieer hem in agent.py, plaats die in een map met een __init__.py en voer adk web uit om er via een browser-UI mee te chatten. De volledige setup duurt ongeveer 10 regels Python.

Maak een map genaamd my_agent en voeg twee bestanden toe. Eerst de agentdefinitie:

# 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"
)

Dan het init-bestand dat je agent exporteert:

# my_agent/__init__.py
from .agent import root_agent

Die variabelenaam is belangrijk -- ADK zoekt specifiek naar root_agent. Mis je dit, dan krijg je een foutmelding "agent not found" die niet uitlegt waarom.

Nu kun je het uitvoeren. Je hebt twee opties:

# CLI-modus -- chat in je terminal
adk run my_agent

# Web-UI-modus -- opent een browserinterface
adk web my_agent

De adk web-interface is echt nuttig. Het toont je de volledige gesprekstrace, welke tools de agent heeft aangeroepen, wat het model ontving en wat het teruggaf. Zie het als Chrome DevTools voor je agent. Wanneer je later multi-agent systemen gaat bouwen, is dit essentieel om de delegatiestroom te begrijpen.

Probeer de instructie aan te passen om te zien hoe het gedrag verandert. Maak er een piraat van. Laat hem alleen in haiku antwoorden. Een goed gevoel krijgen voor hoe instructies gedrag vormgeven is de basis voor alles in deze tutorial.

Aangepaste tools toevoegen aan je Google ADK-agent

ADK-agents worden pas echt nuttig als je ze tools geeft. Definieer een Python-functie met een duidelijke docstring en ADK zet die automatisch om in een tool die de agent kan aanroepen. De docstring is cruciaal -- hij vertelt het model wat de tool doet en wanneer die te gebruiken. ADK levert ook ingebouwde tools zoals Google Zoeken en code-uitvoering.

Tools zijn de handen van een agent. Zonder tools kan je agent alleen maar praten. Met tools kan hij databases raadplegen, API's aanroepen, berekeningen uitvoeren en met externe systemen communiceren. Als je wilt begrijpen hoe function calling onder de motorkap werkt, hebben we daarvoor een aparte diepgaande uitleg.

Aangepaste functietools

Hier is een praktisch voorbeeld -- een tool die aandelenkoersen opzoekt:

# 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"
)

Let op de type hints en de docstring. Dat zijn geen optionele luxe -- ADK gebruikt ze om het toolschema te genereren dat het model te zien krijgt. Laat de docstring weg en het model weet niet wanneer het je functie moet aanroepen. Laat de type hints weg en je krijgt een signatuurfout.

Ingebouwde tools (Google Zoeken, code-uitvoering)

ADK wordt geleverd met tools die je direct kunt gebruiken zonder code te schrijven:

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 laat de agent in realtime het web doorzoeken. code_execution geeft hem een sandbox Python-omgeving om berekeningen uit te voeren. Alleen al deze twee dekken verrassend veel gebruiksscenario's.

Multi-agent systemen: hoe Google ADK-agents werk delegeren

ADK's multi-agent systeem gebruikt een rootagent die taken delegeert aan gespecialiseerde subagents. Elke subagent behandelt één domein -- onderzoek, schrijven, coderen. De rootagent beslist welke subagent wordt aangeroepen op basis van het verzoek van de gebruiker. Je kunt ook het agent-as-tool-patroon gebruiken, waarbij de ene agent de andere aanroept als een functie. Google's officiële blog over multi-agent systemen gaat dieper in op de architectuurpatronen.

Zie het als een projectmanager die delegeert aan specialisten. De rootagent leest het verzoek van de gebruiker, bepaalt welke specialist het moet behandelen en stuurt door. De specialisten weten niets van elkaar -- ze doen gewoon hun werk en rapporteren terug.

Rootagent + subagents-patroon

Hier is een werkend voorbeeld met een rootagent die delegeert aan een onderzoeksagent en een schrijfagent:

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

# Subagent 1: verwerkt onderzoek
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"
)

# Subagent 2: verwerkt schrijven
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"
)

# Rootagent: delegeert naar de juiste subagent
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"
)

Het veld description op elke subagent is hoe de rootagent begrijpt wat ze kunnen. Schrijf duidelijke beschrijvingen -- vage beschrijvingen leiden tot slechte routeringsbeslissingen.

Agent-as-tool-patroon

Soms wil je meer controle over hoe de ene agent de andere aanroept. Het agent-as-tool-patroon wikkelt een subagent in als aanroepbare tool:

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"
)

Gebruik subagents als je wilt dat de rootagent de controle volledig overdraagt. Gebruik agent-as-tool als je wilt dat de aanroepende agent achter het stuur blijft en de uitvoer van de subagent als invoer gebruikt. Als je systemen bouwt waarbij agents gedeelde context nodig hebben, zie dan onze uitgebreide gids over geheugenarchitecturen voor agents.

Workflow-agents: sequentieel, parallel en lus

Naast LLM-gestuurde delegatie biedt ADK drie workflow-agenttypen voor deterministische orkestratie: SequentialAgent voert subagents één voor één uit, ParallelAgent voert ze gelijktijdig uit en LoopAgent herhaalt een reeks totdat aan een voorwaarde is voldaan. Deze zijn nuttig als je een voorspelbare uitvoeringsvolgorde wilt in plaats van de LLM te laten beslissen.

Het verschil is belangrijk. LLM-gestuurde delegatie (het sub_agents-patroon hierboven) laat het model kiezen wie wordt aangeroepen. Workflow-agents geven je programmatische controle. Gebruik workflow-agents als de uitvoeringsvolgorde vooraf bekend is.

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

# Drie agents die in volgorde moeten uitvoeren
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: onderzoek -> concept -> review
content_pipeline = SequentialAgent(
    name="content_pipeline",
    sub_agents=[research_agent, draft_agent, review_agent],
    description="Runs a complete content creation pipeline"
)

Voor onafhankelijke taken die tegelijkertijd kunnen worden uitgevoerd, bespaart ParallelAgent echte tijd:

# Drie data-fetchers die gelijktijdig uitvoeren
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"
)

Toestand en geheugen beheren

ADK beheert de agenttoestand op twee niveaus: sessietoestand (gegevens binnen een gesprek, zoals gebruikersvoorkeuren die tijdens een chat worden verzameld) en geheugenservices (gegevens die over gesprekken heen bewaard blijven). Sessietoestand is een eenvoudige sleutel-waardeopslag die toegankelijk is via context.state. Geheugen gebruikt services zoals InMemoryMemoryService of VertexAIMemoryBankService voor productie.

Sessietoestand is het eenvoudigste. Het is een woordenboek dat aan elk gesprek is gekoppeld:

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"
)

Voor geheugen over gesprekken heen -- het soort waarbij je agent een gebruiker van afgelopen dinsdag herinnert -- heb je een geheugenservice nodig:

from google.adk.memory import InMemoryMemoryService

# Voor ontwikkeling (gegevens verloren bij herstart)
memory_service = InMemoryMemoryService()

# Voor productie, gebruik VertexAIMemoryBankService
# memory_service = VertexAIMemoryBankService(project="jouw-project")

Wanneer heb je geheugen nodig versus sessietoestand? Als het binnen één gesprek valt (winkelwagentje, huidige taakcontext), gebruik dan sessietoestand. Als het gesprekken moet overleven (gebruikersvoorkeuren, eerdere interacties), gebruik dan een geheugenservice. Bekijk onze uitgebreide gids over geheugenarchitecturen voor agents voor productiepatronen.

Callbacks: agentgedrag aansturen

Met ADK-callbacks kun je agentgedrag op vier momenten onderscheppen en aanpassen: before_model_callback (vóór LLM-aanroep), after_model_callback (na LLM-antwoord), before_tool_callback (vóór tooluitvoering) en after_tool_callback (na toolresultaat). Gebruik ze voor invoervalidatie, veiligheidsfiltering, logging of het aanpassen van antwoorden voordat ze de gebruiker bereiken.

Callbacks zijn waar je vangrails toevoegt. Zie ze als middleware voor je agent -- elk verzoek en antwoord gaat er doorheen, en je kunt alles inspecteren, aanpassen of blokkeren.

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"
)

De before_model_callback is de belangrijkste voor productie. Hij wordt uitgevoerd vóór elke LLM-aanroep, waardoor je de kans hebt om prompt-injecties te blokkeren, invoer te valideren of systeemcontext toe te voegen. Als je een antwoordobject retourneert, slaat ADK het model volledig over. Geef None terug om het verzoek door te laten. Voor meer patronen, zie diepgaande patronen voor LLM-veiligheidsvangrails.

Je ADK-agents testen en evalueren

ADK bevat een ingebouwd evaluatieframework met twee evaluatietypen: ResponseEvaluator controleert of het uiteindelijke antwoord van de agent correct is, en TrajectoryEvaluator verifieert of de agent de juiste stappen heeft gezet -- de juiste tools in de juiste volgorde aanriep. Schrijf testcases als JSON-bestanden en voer ze uit met pytest om regressies te onderscheppen vóór deployment.

Waarom zou je agents testen? Omdat ze niet-deterministisch zijn. Dezelfde invoer kan verschillende uitvoer produceren, en een kleine wijziging in je instructie kan tool-aanroepen op subtiele manieren breken. In onze ervaring zijn agents die trajectevaluatie doorstaan, in productie veel betrouwbaarder dan agents die alleen op de kwaliteit van de uiteindelijke uitvoer zijn getest. Voor bredere evaluatiestrategieën, zie onze gids over LLM-evaluatiestrategieën.

Je testcases komen in een JSON-bestand:

[
  {
    "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"}}
    ]
  }
]

Voer vervolgens evaluaties uit met pytest. De ADK Python-repository bevat de volledige evaluatie-API-referentie:

# 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}"

Voer uit met pytest test_agent.py -v. Stel je drempelwaarden in op basis van criticiteit -- 80% responsnauwkeurigheid kan prima zijn voor een creatief schrijfagent, maar voor alles wat financiële gegevens verwerkt wil je 95%+ hebben.

Je Google ADK-agent deployen naar productie

Deploy je ADK-agent naar Google Cloud Run met één commando: adk deploy cloud_run --project JOUW_PROJECT --region us-central1. ADK verpakt je code, bouwt een container en lanceert een serverless endpoint. Voor beheerde hosting gebruik je Vertex AI Agent Engine. Voor eigen infrastructuur ondersteunt ADK ook Docker-containerisatie.

We hebben ADK-agents op Cloud Run gedeployed voor interne tools, en de cold start-tijden zijn verrassend snel -- minder dan 3 seconden voor een basisagent. Voor productiesystemen is het de moeite waard om je deployment te combineren met monitoringtools voor productie-agents.

Deployen naar Cloud Run (aanbevolen voor de meesten)

Cloud Run is het eenvoudigste pad. Één commando en je agent is live met een HTTPS-endpoint:

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

De vlag --with_ui deployt de ADK-webinterface naast je agent, zodat je een browsergebaseerde chat hebt voor testen in productie. Achter de schermen bouwt ADK een containerimage, pusht die naar Google Artifact Registry en maakt een Cloud Run-service aan. De volledige deployment-flow staat gedocumenteerd in Google's Cloud Run quickstart voor ADK.

Voor eigen infrastructuur is hier een minimale 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"]

Alternatief: Vertex AI Agent Engine

Voor enterprise-teams die beheerde schaalbaarheid, monitoring en versiebeheer nodig hebben, handelt Vertex AI Agent Engine de infrastructuur volledig af. Je ruilt flexibiliteit in voor gemak -- geen containers om te beheren, automatische schaalbaarheid en ingebouwde analytics.

Kostenoverwegingen

Cijfers die je moet kennen:

• Gemini API gratis tier: 15 verzoeken per minuut, 1 miljoen tokens per dag. Genoeg voor ontwikkeling en lichte demo's.
• Gemini 2.0 Flash (betaald): $0,10 per miljoen invoertokens, $0,40 per miljoen uitvoertokens. Goedkoop genoeg voor productie.
• Cloud Run gratis tier: 2 miljoen verzoeken per maand, 360.000 GB-seconden rekentijd. Een basisagent die 1.000 verzoeken per dag verwerkt, blijft ruim binnen de gratis tier.
• Optimalisatietip: Gebruik gemini-2.0-flash (niet gemini-2.0-pro) voor subagents die eenvoudige routering of opmaak uitvoeren. Bewaar de krachtigere modellen voor agents die complexe redenering doen.

Hoe Techsy AI-agentsontwikkeling aanpakt

Bij Techsy hebben we multi-agent systemen gebouwd voor klanten met ADK, LangGraph en CrewAI. De frameworkkeuze hangt af van je stack: als je al op Google Cloud werkt, elimineert ADK veel integratiefrictie. Als je van meet af aan multi-provider LLM-ondersteuning nodig hebt, geeft LangGraph meer flexibiliteit.

Onze typische opdracht begint met architectuuradvies -- het in kaart brengen van je gebruiksscenario in de juiste agentpatronen -- gevolgd door prototypeontwikkeling en Cloud Run-deployment. We hebben gemerkt dat teams 2 tot 3 weken besparen door de architectuur upfront goed te krijgen in plaats van later te refactoren.

Wil je AI-agents bouwen voor je team? Vraag een gratis consultatie aan -- we helpen je het juiste framework en de juiste deploymentstrategie te kiezen.

Veelvoorkomende fouten en probleemoplossing

Dit zijn de fouten die we het vaakst tegenkomen bij het beginnen met ADK. Bespaar jezelf de debugging-tijd:

Debugtip: adk web is je beste vriend hier. Het toont de volledige gesprekstrace -- elke modelaanroep, toolaanroep en agentdelegatie -- in realtime. Wanneer er iets misgaat in een multi-agent systeem, laat de web-UI precies zien waar de keten brak.

FAQ

Wat is Google ADK?

Google's Agent Development Kit (ADK) is een open-source Python-framework voor het bouwen, evalueren en deployen van AI-agents. Het is geoptimaliseerd voor Google Gemini-modellen maar ondersteunt via LiteLLM-integratie meer dan 100 LLM's. ADK's kernkracht is native multi-agent-orkestratie met ingebouwde tools, een dev-UI en deployment naar Cloud Run met één commando.

Is Google ADK gratis te gebruiken?

Ja. ADK zelf is open-source onder de Apache 2.0-licentie. Je hebt een Gemini API-sleutel nodig, die een gratis tier heeft met 15 verzoeken per minuut en 1 miljoen tokens per dag. Clouddeploymentkosten hangen af van je hostingkeuze -- de gratis tier van Cloud Run dekt 2 miljoen verzoeken per maand.

Wat is het verschil tussen Google ADK en LangChain?

ADK is Google's opinionated framework geoptimaliseerd voor Gemini met native multi-agent-orkestratie en ingebouwde deploymenttools. LangChain is modelonafhankelijk met bredere integraties van derden maar aanzienlijk meer complexiteit. ADK is beter voor Gemini-first teams die snelle deployment willen; LangChain past bij multi-provider-opstellingen die maximale flexibiliteit nodig hebben.

Ondersteunt Google ADK multi-agent systemen?

Ja, en het is ADK's vlaggenschipfunctie. Je maakt een rootagent die delegeert aan gespecialiseerde subagents op basis van gebruikersverzoeken. ADK biedt ook SequentialAgent, ParallelAgent en LoopAgent voor deterministische workflow-orkestratie. Het agent-as-tool-patroon laat agents andere agents aanroepen als aanroepbare functies.

Hoe deploy ik een Google ADK-agent?

Voer adk deploy cloud_run --project JOUW_PROJECT --region us-central1 uit voor serverless deployment naar Google Cloud Run. Voeg --with_ui toe om de browsergebaseerde chatinterface mee te nemen. Je kunt ook deployen naar Vertex AI Agent Engine voor beheerde hosting, of een Docker-container bouwen voor eigen infrastructuur.

Kan Google ADK andere modellen dan Gemini gebruiken?

Ja. ADK ondersteunt via LiteLLM-integratie meer dan 100 modellen, waaronder Anthropic Claude, OpenAI GPT-4, Meta Llama en Mistral. Stel de modelparameter in op de LiteLLM-modelstring -- bijvoorbeeld litellm/anthropic/claude-3-sonnet of litellm/openai/gpt-4o. Gemini-modellen werken native zonder het LiteLLM-voorvoegsel.

Wat is de ADK Web UI?

Een browsergebaseerde debuginterface die wordt gestart met adk web jouw_agent_map. Het toont realtime gesprekstraces, toolaanroepen, agentdelegatiereeksen en toestandswijzigingen terwijl ze plaatsvinden. De Web UI is essentieel voor het debuggen van multi-agent systemen omdat het precies laat zien welke subagent elk verzoek heeft afgehandeld.

Ondersteunt Google ADK MCP (Model Context Protocol)?

Ja. ADK heeft native ondersteuning voor het Model Context Protocol, waardoor agents verbinding kunnen maken met elke MCP-compatibele toolserver voor externe tools en gegevensbronnen. Dit maakt ADK-agents interoperabel met het groeiende MCP-ecosysteem. Voor achtergrond over het protocol, zie onze MCP-gids.

Hoe test ik ADK-agents?

ADK wordt geleverd met ingebouwde evaluatoren: ResponseEvaluator voor het controleren van uitvoerkwaliteit ten opzichte van verwachte antwoorden, en TrajectoryEvaluator voor het verifiëren dat de agent de juiste tools in de juiste volgorde aanriep. Schrijf testcases als JSON-bestanden met invoer, verwachte uitvoer en verwachte toolaanroepreeksen, en voer ze uit met pytest.

Welke Python-versie vereist Google ADK?

ADK vereist Python 3.9 of hoger. Python 3.10+ wordt aanbevolen voor volledige ondersteuning van type hints, wat belangrijk is omdat ADK type hints gebruikt om toolschema's te genereren. Python 3.11 of 3.12 biedt ook betekenisvolle prestatieverbeteringen voor agentwerklasten. Installeer met pip install google-adk.