Google ADK-guide: Byg AI-agenter fra nul til produktion

Google ADK-guide: Byg AI-agenter fra nul til produktion

Googles Agent Development Kit (ADK) er det framework, der endelig gør multi-agent-systemer tilgængelige. Hvis du har bygget AI-agenter med LangChain eller CrewAI og haft følelsen af at kæmpe mod frameworket mere end at bygge med det, så tager denne Google ADK-guide dig gennem alt — fra din første agent til at deploye den på Cloud Run.

Hvad er Google ADK (og hvorfor skal du bryde dig om det)?

Googles Agent Development Kit (ADK) er et open source Python-framework til at bygge, evaluere og deploye AI-agenter. Det blev udgivet i 2025, er optimeret til Gemini, men understøtter 100+ modeller via LiteLLM. ADK's killer feature er native multi-agent-orkestrering — agenter, der delegerer opgaver til andre agenter uden limkode.

Efter at have bygget agenter med LangChain, CrewAI og nu ADK, er det her, der skiller sig ud: ADK er holdningsbaseret de rigtige steder. Det giver dig en projektstruktur, en indbygget dev-UI og en deploy-kommando. Du lapper ikke fem biblioteker sammen for at få en basal agent til at køre.

Hvis LangChain er en alt-i-en schweizerkniv, er ADK Googles specialbyggede værktøjskasse til multi-agent-workflows. CrewAI er tættere på i filosofien — rollebaserede agenter, der samarbejder — men ADK går længere med indbygget evaluering, native Gemini-optimering og Cloud Run-deployment med én kommando. For en dybere gennemgang, se vores dybdegående sammenligning af agent-frameworks.

Hvem er ADK til? Python-udviklere, der vil have strukturerede multi-agent-systemer. Teams, der allerede er på Google Cloud eller Gemini. Alle, der er trætte af at skrive boilerplate-orkestreringslogik.

Sådan klarer frameworkene sig ved første øjekast:

Den korte version: hvis du vil have den hurtigste vej fra "idé" til "deployet multi-agent-system", er ADK svær at slå lige nu.

Forudsætninger og installation af Google ADK

For at komme i gang med Google ADK skal du bruge Python 3.9+, en Gemini API-nøgle (gratis niveau tilgængeligt på Google AI Studio) og google-adk-pakken. Installer med pip install google-adk, sæt din API-nøgle som en miljøvariabel, og du er klar til at bygge din første agent på under 5 minutter.

Her er din setup-tjekliste:

• Python 3.9+ (3.10+ anbefales for fuld type hint-understøttelse)
• En Gemini API-nøgle — snup en gratis på aistudio.google.com. Det gratis niveau giver dig 15 requests i minuttet, hvilket er rigeligt til udvikling.
• pip (eller uv, hvis du foretrækker hastighed — uv pip install google-adk virker også)

Installer pakken og sæt din nøgle:

pip install google-adk

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

ADK forventer en bestemt mappestruktur. Hver agent bor i sin egen pakke-mappe:

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

Mappenavnet bliver din agents pakkenavn, så vælg noget beskrivende. Kald den ikke test eller agent — så forvirrer du Pythons importsystem.

Pro tip: Hvis du bruger uv, så opret først et virtuelt miljø med uv venv && source .venv/bin/activate. Det er mærkbart hurtigere end almindelig pip til afhængighedsopløsning.

Byg din første Google ADK-agent

Din første ADK-agent kræver kun tre ting: et navn, en model (som gemini-2.0-flash) og en instruktionsstreng. Definér den i agent.py, placer den i en mappe med en __init__.py, og kør adk web for at chatte med den i en browser-UI. Hele setuppet tager omkring 10 linjer Python.

Opret en mappe kaldet my_agent og tilføj to filer. Først agentdefinitionen:

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

Derefter init-filen, der eksporterer din agent:

# my_agent/__init__.py
from .agent import root_agent

Det variabelnavn betyder noget — ADK leder specifikt efter root_agent. Overser du det, får du en "agent not found"-fejl, der ikke forklarer hvorfor.

Kør den nu. Du har to muligheder:

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

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

adk web-grænsefladen er genuint nyttig. Den viser dig det fulde konversationsspor — hvilke værktøjer agenten kaldte, hvad modellen modtog, og hvad den returnerede. Tænk på den som Chrome DevTools for din agent. Når du begynder at bygge multi-agent-systemer senere, bliver den essentiel for at forstå delegeringsflowet.

Prøv at ændre instruktionen for at se, hvordan adfærden ændrer sig. Gør den til en pirat. Få den til kun at svare i haiku. At få en fornemmelse for, hvordan instruktioner former adfærd, er fundamentet for alt andet i denne guide.

Tilføj egne værktøjer til din Google ADK-agent

ADK-agenter bliver nyttige, når du giver dem værktøjer. Definér en Python-funktion med en klar docstring, og ADK konverterer den automatisk til et værktøj, agenten kan kalde. Docstringen er afgørende — den fortæller modellen, hvad værktøjet gør, og hvornår det skal bruges. ADK leveres også med indbyggede værktøjer som Google Search og kodeeksekvering.

Værktøjer er en agents hænder. Uden dem kan din agent kun tale. Med dem kan den tjekke databaser, kalde API'er, køre beregninger og interagere med eksterne systemer. Hvis du vil forstå, hvordan function calling virker under kølerhjelmen, har vi en separat dybdegående artikel om det.

Brugerdefinerede funktionsværktøjer

Her er et praktisk eksempel — et værktøj, der slår aktiekurser op:

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

Bemærk type hints og docstringen. Det er ikke valgfrit pynt — ADK bruger dem til at generere det værktøjsskema, modellen ser. Spring docstringen over, og modellen ved ikke, hvornår den skal kalde din funktion. Spring type hints over, og du får en signaturfejl.

Indbyggede værktøjer (Google Search, kodeeksekvering)

ADK leveres med værktøjer, du kan smide ind uden at skrive kode:

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 lader agenten forespørge på nettet i realtid. code_execution giver den et sandkasset Python-miljø til at køre beregninger. De to alene dækker et overraskende antal use cases.

Multi-agent-systemer: Hvordan Google ADK-agenter delegerer arbejde

ADK's multi-agent-system bruger en rod-agent, der delegerer opgaver til specialiserede underagenter. Hver underagent håndterer ét domæne — research, skrivning, kodning. Rod-agenten afgør, hvilken underagent der skal kaldes, baseret på brugerens forespørgsel. Du kan også bruge agent-som-værktøj-mønstret, hvor én agent kalder en anden, som var den en funktion. Googles officielle blog om multi-agent-systemer går dybere med de arkitektoniske mønstre.

Tænk på det som en projektleder, der delegerer til specialister. Rod-agenten læser brugerens forespørgsel, finder ud af, hvilken specialist der skal håndtere den, og router derefter. Specialisterne kender ikke til hinanden — de passer bare deres arbejde og rapporterer tilbage.

Mønster: Rod-agent + underagenter

Her er et fungerende eksempel med en rod-agent, der delegerer til en research-agent og en skrive-agent:

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

description-feltet på hver underagent er sådan, rod-agenten forstår, hvad de kan. Skriv klare beskrivelser — vage beskrivelser fører til dårlige routingbeslutninger.

Mønster: Agent-som-værktøj

Nogle gange vil du have mere kontrol over, hvordan én agent kalder en anden. Agent-som-værktøj-mønstret wrapper en underagent som et kaldsbart værktøj:

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

Brug underagenter, når du vil have rod-agenten til at delegere kontrollen fuldt ud. Brug agent-som-værktøj, når du vil have den kaldende agent til at blive i førersædet og blot bruge underagentens output som input. Hvis du bygger systemer, hvor agenter har brug for delt kontekst, så se vores omfattende guide til agenthukommelsesarkitekturer.

Workflow-agenter: Sekventiel, parallel og loop

Ud over LLM-drevet delegering tilbyder ADK tre workflow-agenttyper til deterministisk orkestrering: SequentialAgent kører underagenter én efter én, ParallelAgent kører dem samtidigt, og LoopAgent gentager en sekvens, indtil en betingelse er opfyldt. De er nyttige, når du har brug for en forudsigelig eksekveringsrækkefølge frem for at lade LLM'en bestemme.

Forskellen betyder noget. LLM-drevet delegering (sub_agents-mønstret ovenfor) lader modellen vælge, hvem der skal kaldes. Workflow-agenter giver dig programmatisk kontrol. Brug workflow-agenter, når eksekveringsrækkefølgen er kendt på forhånd.

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

For uafhængige opgaver, der kan køre samtidigt, sparer ParallelAgent reel tid:

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

Håndtering af tilstand og hukommelse

ADK håndterer agenttilstand på to niveauer: sessionstilstand (data inden for en konversation, som brugerpræferencer indsamlet midt i chatten) og hukommelsestjenester (data, der består på tværs af konversationer). Sessionstilstand er et simpelt nøgle-værdi-lager, der tilgås via context.state. Hukommelse bruger tjenester som InMemoryMemoryService eller VertexAIMemoryBankService til produktion.

Sessionstilstand er den simpleste. Det er en dictionary, der er knyttet til hver konversation:

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

For hukommelse på tværs af konversationer — den slags, hvor din agent husker en bruger fra sidste tirsdag — har du brug for en hukommelsestjeneste:

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

Hvornår har du brug for hukommelse kontra sessionstilstand? Hvis det er inden for én konversation (indkøbskurv, nuværende opgavekontekst), så brug sessionstilstand. Hvis det skal overleve mellem konversationer (brugerpræferencer, tidligere interaktioner), så brug en hukommelsestjeneste. Tjek vores omfattende guide til agenthukommelsesarkitekturer for produktionsmønstre.

Callbacks: Styring af agentadfærd

ADK-callbacks lader dig opfange og ændre agentadfærd på fire punkter: before_model_callback (før LLM-kald), after_model_callback (efter LLM-svar), before_tool_callback (før værktøjseksekvering) og after_tool_callback (efter værktøjsresultat). Brug dem til inputvalidering, sikkerhedsfiltrering, logning eller ændring af svar, før de når brugeren.

Callbacks er dér, du tilføjer guardrails. Tænk på dem som middleware for din agent — hver forespørgsel og hvert svar passerer gennem dem, og du kan inspicere, ændre eller blokere hvad som helst.

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 er den vigtigste til produktion. Den kører før hvert LLM-kald og giver dig mulighed for at blokere prompt injections, validere input eller tilføje systemkontekst. Hvis du returnerer et svarobjekt, springer ADK modellen helt over. Returnér None for at lade forespørgslen passere. For flere mønstre, se dybere mønstre for LLM-sikkerheds-guardrails.

Test og evaluering af dine ADK-agenter

ADK inkluderer et indbygget evalueringsframework med to evaluatortyper: ResponseEvaluator tjekker, om agentens endelige svar er korrekt, og TrajectoryEvaluator verificerer, at agenten tog de rigtige skridt — kaldte de rigtige værktøjer i den rigtige rækkefølge. Skriv testcases som JSON-filer og kør dem med pytest for at fange regressioner før deployment.

Hvorfor teste agenter overhovedet? Fordi de er ikke-deterministiske. Det samme input kan producere forskellige outputs, og en lille ændring i din instruktion kan ødelægge værktøjskald på subtile måder. I vores erfaring er agenter, der består trajectory-evaluering, langt mere pålidelige i produktion end dem, der kun testes på den endelige outputkvalitet. For bredere evalueringsstrategier, se vores guide til LLM-evalueringsstrategier.

Dine testcases lægges i en JSON-fil:

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

Kør derefter evalueringer med pytest. ADK Python-repositoryet har den fulde evaluerings-API-reference:

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

Kør med pytest test_agent.py -v. Sæt dine tærskler baseret på kritikalitet — 80 % svarnøjagtighed er måske fint for en kreativ skrive-agent, men du vil have 95 %+ for alt, der håndterer finansielle data.

Deploy af din Google ADK-agent til produktion

Deploy din ADK-agent til Google Cloud Run med én kommando: adk deploy cloud_run --project YOUR_PROJECT --region us-central1. ADK pakker din kode, bygger en container og starter et serverless endpoint. For managed hosting, brug Vertex AI Agent Engine. For brugerdefineret infrastruktur understøtter ADK også Docker-containerisering.

Vi har deployet ADK-agenter på Cloud Run til interne værktøjer, og cold start-tiderne er overraskende hurtige — under 3 sekunder for en basal agent. For produktionssystemer, overvej at parre dit deployment med overvågningsværktøjer til produktionsagenter.

Deploy til Cloud Run (anbefalet til de fleste)

Cloud Run er den simpleste vej. Én kommando, og din agent er live med et HTTPS-endpoint:

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

--with_ui-flaget deployer ADK-webgrænsefladen sammen med din agent, så du får en browserbaseret chat til test i produktion. Bag kulisserne bygger ADK et container-image, pusher det til Google Artifact Registry og opretter en Cloud Run-tjeneste. Det fulde deployment-flow er dokumenteret i Googles Cloud Run-quickstart for ADK.

For brugerdefineret infrastruktur, her er en minimal 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"]

Alternativ: Vertex AI Agent Engine

For enterprise-teams, der har brug for managed scaling, overvågning og versionering, håndterer Vertex AI Agent Engine infrastrukturen helt. Du bytter fleksibilitet for bekvemmelighed — ingen containere at styre, automatisk scaling, indbygget analyse.

Omkostningsovervejelser

Reelle tal, du bør kende:

• Gemini API gratis niveau: 15 requests i minuttet, 1 million tokens/dag. Nok til udvikling og lette demoer.
• Gemini 2.0 Flash (betalt): $0,10 per million input-tokens, $0,40 per million output-tokens. Billigt nok til produktion.
• Cloud Run gratis niveau: 2 millioner requests/måned, 360.000 GB-sekunders beregning. En basal agent, der håndterer 1.000 requests/dag, holder sig godt inden for det gratis niveau.
• Optimeringstip: Brug gemini-2.0-flash (ikke gemini-2.0-pro) til underagenter, der laver simpel routing eller formatering. Gem de mere kapable modeller til agenter, der laver kompleks ræsonnering.

Hvordan Techsy griber AI-agentudvikling an

Hos Techsy har vi bygget multi-agent-systemer for kunder med ADK, LangGraph og CrewAI. Valget af framework afhænger af din stack: hvis du allerede er på Google Cloud, eliminerer ADK en masse integrationsfriktion. Hvis du har brug for multi-provider LLM-understøttelse fra dag ét, giver LangGraph dig mere fleksibilitet.

Vores typiske engagement starter med arkitekturrådgivning — kortlægning af din use case til de rigtige agentmønstre — efterfulgt af prototypeudvikling og Cloud Run-deployment. Vi har fundet ud af, at teams sparer 2-3 uger ved at få arkitekturen rigtig fra starten i stedet for at refactorere senere.

Bygger du AI-agenter til dit team? Få en gratis konsultation — vi hjælper dig med at vælge det rigtige framework og den rigtige deploymentstrategi.

Almindelige fejl og fejlfinding

Det er de fejl, vi oftest støder på, når vi kommer i gang med ADK. Spar dig selv for debugging-tiden:

Debugging-tip: adk web er din bedste ven her. Den viser det fulde konversationsspor — hvert modelkald, værktøjskald og agentdelegering — i realtid. Når noget går galt i et multi-agent-system, viser web-UI'en dig præcis, hvor kæden brast.

FAQ

Hvad er Google ADK?

Googles Agent Development Kit (ADK) er et open source Python-framework til at bygge, evaluere og deploye AI-agenter. Det er optimeret til Google Gemini-modeller, men understøtter 100+ LLM'er gennem LiteLLM-integration. ADK's kerne styrke er native multi-agent-orkestrering med indbyggede værktøjer, en dev-UI og Cloud Run-deployment med én kommando.

Er Google ADK gratis at bruge?

Ja. Selve ADK er open source under Apache 2.0-licensen. Du skal bruge en Gemini API-nøgle, som har et gratis niveau med 15 requests i minuttet og 1 million tokens om dagen. Cloud-deployment-omkostninger afhænger af dit hostingvalg — Cloud Runs gratis niveau dækker 2 millioner requests om måneden.

Hvad er forskellen mellem Google ADK og LangChain?

ADK er Googles holdningsbaserede framework optimeret til Gemini med native multi-agent-orkestrering og indbyggede deployment-værktøjer. LangChain er modelagnostisk med bredere tredjepartsintegrationer, men markant mere kompleksitet. ADK er bedre til Gemini-først-teams, der vil have hurtig deployment; LangChain passer til multi-provider-setups, der kræver maksimal fleksibilitet.

Understøtter Google ADK multi-agent-systemer?

Ja, og det er ADK's flagskibsfunktion. Du opretter en rod-agent, der delegerer til specialiserede underagenter baseret på brugerforespørgsler. ADK tilbyder også SequentialAgent, ParallelAgent og LoopAgent til deterministisk workflow-orkestrering. Agent-som-værktøj-mønstret lader agenter kalde andre agenter som kaldbare funktioner.

Hvordan deployer jeg en Google ADK-agent?

Kør adk deploy cloud_run --project YOUR_PROJECT --region us-central1 for serverless deployment til Google Cloud Run. Tilføj --with_ui for at inkludere den browserbaserede chatgrænseflade. Du kan også deploye til Vertex AI Agent Engine for managed hosting eller bygge en Docker-container for brugerdefineret infrastruktur.

Kan Google ADK bruge andre modeller end Gemini?

Ja. ADK understøtter 100+ modeller gennem LiteLLM-integration, inklusive Anthropic Claude, OpenAI GPT-4, Meta Llama og Mistral. Sæt modelparameteren til LiteLLM-modelstrengen, for eksempel litellm/anthropic/claude-3-sonnet eller litellm/openai/gpt-4o. Gemini-modeller virker native uden LiteLLM-præfikset.

Hvad er ADK-web-UI'en?

En browserbaseret debugging-grænseflade, der startes med adk web your_agent_folder. Den viser konversationsspor i realtid, værktøjskald, agentdelegeringskæder og tilstandsændringer, som de sker. Web-UI'en er essentiel for debugging af multi-agent-systemer, fordi den viser præcis, hvilken underagent der håndterede hver forespørgsel.

Understøtter Google ADK MCP (Model Context Protocol)?

Ja. ADK har native Model Context Protocol-understøttelse, så agenter kan forbinde til enhver MCP-kompatibel værktøjsserver for eksterne værktøjer og datakilder. Det gør ADK-agenter interoperable med det voksende MCP-økosystem. For baggrund om protokollen, se vores MCP-guide.

Hvordan tester jeg ADK-agenter?

ADK leveres med indbyggede evaluatorer: ResponseEvaluator til at tjekke outputkvalitet mod forventede svar og TrajectoryEvaluator til at verificere, at agenten kaldte de rigtige værktøjer i den rigtige rækkefølge. Skriv testcases som JSON-filer, der definerer input, forventede outputs og forventede værktøjskaldsekvenser, og kør dem derefter med pytest.

Hvilken Python-version kræver Google ADK?

ADK kræver Python 3.9 eller højere. Python 3.10+ anbefales for fuld type hinting-understøttelse, hvilket betyder noget, fordi ADK bruger type hints til at generere værktøjsskemaer. Python 3.11 eller 3.12 tilbyder også meningsfulde ydelsesforbedringer til agent-workloads. Installer med pip install google-adk.