Google ADK-handledning: Bygg AI-agenter från noll till produktion

Google ADK-handledning: Bygg AI-agenter från noll till produktion

Googles Agent Development Kit (ADK) är det ramverk som äntligen gör multi-agent-system tillgängliga. Om du har byggt AI-agenter med LangChain eller CrewAI och känt att du kämpar mot ramverket snarare än med det, så tar den här Google ADK-handledningen dig igenom allt -- från din första agent till driftsättning på Cloud Run.

Vad är Google ADK (och varför ska du bry dig)?

Googles Agent Development Kit (ADK) är ett öppen källkod Python-ramverk för att bygga, utvärdera och driftsätta AI-agenter. Släppt 2025 är det optimerat för Gemini men stöder 100+ modeller via LiteLLM. ADK:s starkaste kort är inbyggd multi-agent-orkestrering -- agenter som delegerar uppgifter till andra agenter utan limkod.

Efter att ha byggt agenter med LangChain, CrewAI och nu ADK är här vad som sticker ut: ADK är åsiktsfullt på rätt ställen. Det ger dig en projektstruktur, ett inbyggt dev-UI och ett driftsättningskommando. Du sitter inte och syr ihop fem bibliotek för att få igång en grundläggande agent.

Om LangChain är en schweizisk armékniv för allmänt bruk är ADK Googles specialbyggda verktygslåda för multi-agent-arbetsflöden. CrewAI är närmare i filosofin -- rollbaserade agenter som samarbetar -- men ADK går längre med inbyggd utvärdering, inbyggd Gemini-optimering och ett-kommando Cloud Run-driftsättning. För en djupare genomgång, kolla in vår jämförelse av agentramverk.

Vem är ADK till för? Python-utvecklare som vill ha strukturerade multi-agent-system. Team som redan använder Google Cloud eller Gemini. Alla som är trötta på att skriva boilerplate-orkestreringskod.

Så här ser ramverken ut i jämförelse:

Kortversionen: om du vill ha den snabbaste vägen från "idé" till "driftsatt multi-agent-system" är ADK svårt att slå just nu.

Förutsättningar och Google ADK-installation

För att komma igång med Google ADK behöver du Python 3.9+, en Gemini API-nyckel (gratisnivå tillgänglig på Google AI Studio), och paketet google-adk. Installera med pip install google-adk, ange din API-nyckel som en miljövariabel, och du är redo att bygga din första agent på under 5 minuter.

Din installationschecklista:

• Python 3.9+ (3.10+ rekommenderas för fullt stöd för typledtrådar)
• En Gemini API-nyckel -- hämta en gratis på aistudio.google.com. Gratisnivån ger dig 15 förfrågningar per minut, vilket räcker gott för utveckling.
• pip (eller uv om du föredrar hastighet -- uv pip install google-adk fungerar också)

Installera paketet och ange din nyckel:

pip install google-adk

# Ange din API-nyckel (lägg till i .bashrc/.zshrc för beständighet)
export GOOGLE_API_KEY="din-api-nyckel-här"

ADK förväntar sig en specifik mappstruktur. Varje agent lever i sin egen paketmapp:

my_agent/
  __init__.py    # Exporterar root_agent
  agent.py       # Agentdefinition
.env             # Valfritt: GOOGLE_API_KEY=din-nyckel

Mappnamnet blir agentens paketnamn, så välj något beskrivande. Kalla det inte test eller agent -- du förvirrar Pythons importsystem.

Proffstips: Om du använder uv, skapa en virtuell miljö först med uv venv && source .venv/bin/activate. Det är märkbart snabbare än vanlig pip för beroendelösning.

Bygg din första Google ADK-agent

Din första ADK-agent behöver bara tre saker: ett namn, en modell (som gemini-2.0-flash) och en instruktionssträng. Definiera den i agent.py, placera den i en mapp med en __init__.py, och kör adk web för att chatta med den i ett webbläsargränssnitt. Hela uppbyggnaden tar ungefär 10 rader Python.

Skapa en mapp som heter my_agent och lägg till två 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"
)

Sedan init-filen som exporterar din agent:

# my_agent/__init__.py
from .agent import root_agent

Det variabelnamnet spelar roll -- ADK letar specifikt efter root_agent. Missar du det får du ett felmeddelande om "agent not found" som inte förklarar varför.

Kör det nu. Du har två alternativ:

# CLI-läge -- chatta i terminalen
adk run my_agent

# Webb-UI-läge -- öppnar ett webbläsargränssnitt
adk web my_agent

adk web-gränssnittet är genuint användbart. Det visar hela konversationsspåret, vilka verktyg agenten anropade, vad modellen tog emot och vad den returnerade. Tänk på det som Chrome DevTools för din agent. När du börjar bygga multi-agent-system senare blir det här oumbärligt för att förstå delegeringsflödet.

Prova att ändra instruktionen för att se hur beteendet förändras. Gör den till en pirat. Låt den bara svara på haiku. Att få en känsla för hur instruktioner formar beteende är grunden för allt annat i den här handledningen.

Lägga till egna verktyg i din Google ADK-agent

ADK-agenter blir användbara när du ger dem verktyg. Definiera en Python-funktion med en tydlig dokumentationssträng så omvandlar ADK automatiskt den till ett verktyg agenten kan anropa. Dokumentationssträngen är avgörande -- den talar om för modellen vad verktyget gör och när den ska använda det. ADK levereras också med inbyggda verktyg som Google Search och kodkörning.

Verktyg är agentens händer. Utan dem kan din agent bara prata. Med dem kan den kontrollera databaser, anropa API:er, köra beräkningar och interagera med externa system. Om du vill förstå hur funktionsanrop fungerar under huven har vi en separat djupdykning om det.

Egna funktionsverktyg

Här är ett praktiskt exempel -- ett verktyg som slår upp aktiekurser:

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

Lägg märke till typledtrådarna och dokumentationssträngen. De är inte valfria trevligheter -- ADK använder dem för att generera verktygschemat som modellen ser. Hoppar du över dokumentationssträngen vet modellen inte när den ska anropa din funktion. Hoppar du över typledtrådarna får du ett signaturfel.

Inbyggda verktyg (Google Search, kodkörning)

ADK levereras med verktyg du kan använda direkt utan att skriva någon kod:

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 låter agenten söka på webben i realtid. code_execution ger den en sandlåde-Python-miljö för att köra beräkningar. Dessa två täcker ett förvånansvärt stort antal användningsfall.

Multi-agent-system: Hur Google ADK-agenter delegerar arbete

ADK:s multi-agent-system använder en rotagent som delegerar uppgifter till specialiserade underagenter. Varje underagent hanterar ett område -- forskning, skrivande, kodning. Rotlagenten avgör vilken underagent som ska anropas baserat på användarens förfrågan. Du kan också använda mönstret agent-som-verktyg, där en agent anropar en annan som om det vore en funktion. Googles officiella blogg om multi-agent-system går djupare in på arkitekturmönstren.

Tänk på det som en projektledare som delegerar till specialister. Rotagenten läser användarens förfrågan, räknar ut vilken specialist som ska hantera det och skickar vidare. Specialisterna vet ingenting om varandra -- de gör bara sitt jobb och rapporterar tillbaka.

RotAgent + underagenter-mönstret

Här är ett fungerande exempel med en rotAgent som delegerar till en forskningsagent och en skrivagent:

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

# Underagent 1: hanterar forskning
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"
)

# Underagent 2: hanterar skrivande
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"
)

# RotAgent: delegerar till rätt underagent
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"
)

Fältet description på varje underagent är hur rotAgenten förstår vad de kan göra. Skriv tydliga beskrivningar -- vaga leder till dåliga routningsbeslut.

Mönstret agent-som-verktyg

Ibland vill du ha mer kontroll över hur en agent anropar en annan. Mönstret agent-som-verktyg omsluter en underagent som ett anropbart verktyg:

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

Använd underagenter när du vill att rotAgenten helt ska delegera kontrollen. Använd agent-som-verktyg när du vill att den anropande agenten ska hålla i ratten och bara använda underagentens utdata som indata. Om du bygger system där agenter behöver delat sammanhang, se vår kompletta guide till agentminnesarkitekturer.

Arbetsflödesagenter: Sekventiell, parallell och loop

Utöver LLM-driven delegering erbjuder ADK tre typer av arbetsflödesagenter för deterministisk orkestrering: SequentialAgent kör underagenter en efter en, ParallelAgent kör dem samtidigt och LoopAgent upprepar en sekvens tills ett villkor uppfylls. Dessa är användbara när du behöver förutsägbar exekveringsordning istället för att låta LLM besluta.

Skillnaden är viktig. LLM-driven delegering (mönstret sub_agents ovan) låter modellen välja vem som ska anropas. Arbetsflödesagenter ger dig programmatisk kontroll. Använd arbetsflödesagenter när exekveringsordningen är känd i förväg.

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

# Tre agenter som måste köras i ordning
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: forskning -> utkast -> granskning
content_pipeline = SequentialAgent(
    name="content_pipeline",
    sub_agents=[research_agent, draft_agent, review_agent],
    description="Runs a complete content creation pipeline"
)

För oberoende uppgifter som kan köras samtidigt sparar ParallelAgent verklig tid:

# Tre datahämtare som körs parallellt
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"
)

Hantera tillstånd och minne

ADK hanterar agenttillstånd på två nivåer: sessionstillstånd (data inom en konversation, som användarpreferenser som samlats in mitt i en chatt) och minnestjänster (data som kvarstår mellan konversationer). Sessionstillstånd är ett enkelt nyckel-värde-lager som nås via context.state. Minne använder tjänster som InMemoryMemoryService eller VertexAIMemoryBankService för produktion.

Sessionstillståndet är det enklare alternativet. Det är en ordbok kopplad till varje 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"
)

För minne mellan konversationer -- den typen där din agent minns en användare från förra veckan -- behöver du en minnestjänst:

from google.adk.memory import InMemoryMemoryService

# För utveckling (data förloras vid omstart)
memory_service = InMemoryMemoryService()

# För produktion, använd VertexAIMemoryBankService
# memory_service = VertexAIMemoryBankService(project="your-project")

När behöver du minne kontra sessionstillstånd? Om det gäller en enda konversation (kundvagn, aktuell uppgiftskontext), använd sessionstillstånd. Om det behöver överleva mellan konversationer (användarpreferenser, tidigare interaktioner), använd en minnestjänst. Kolla in vår kompletta guide till agentminnesarkitekturer för produktionsmönster.

Callbacks: Styr agentbeteende

ADK-callbacks låter dig fånga upp och ändra agentbeteende på fyra punkter: before_model_callback (före LLM-anrop), after_model_callback (efter LLM-svar), before_tool_callback (före verktygskörning) och after_tool_callback (efter verktygsresultat). Använd dem för indatavalidering, säkerhetsfiltrering, loggning eller för att ändra svar innan de når användaren.

Callbacks är där du lägger till skyddsräcken. Tänk på dem som mellanprogramvara för din agent -- varje förfrågan och svar passerar genom dem, och du kan inspektera, ändra eller blockera vad 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 är den viktigaste för produktion. Den körs före varje LLM-anrop och ger dig en chans att blockera promptinjektioner, validera indata eller lägga till systemkontext. Om du returnerar ett svarsobjekt hoppar ADK över modellen helt. Returnera None för att låta förfrågan gå igenom. För fler mönster, se djupare mönster för LLM-säkerhetsskyddsräcken.

Testa och utvärdera dina ADK-agenter

ADK inkluderar ett inbyggt utvärderingsramverk med två utvärderartyper: ResponseEvaluator kontrollerar om agentens slutliga svar är korrekt, och TrajectoryEvaluator verifierar att agenten tog rätt steg -- anropade rätt verktyg i rätt ordning. Skriv testfall som JSON-filer och kör dem med pytest för att fånga regressioner innan driftsättning.

Varför bry sig om att testa agenter? För att de är icke-deterministiska. Samma indata kan ge olika utdata, och en liten ändring av din instruktion kan bryta verktygskallning på subtila sätt. I vår erfarenhet är agenter som klarar trajektoribedömning mycket mer tillförlitliga i produktion än de som bara testats på slutlig utdatakvalitet. För bredare utvärderingsstrategier, se vår guide till LLM-utvärderingsstrategier.

Dina testfall går 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 sedan utvärderingar med pytest. ADK Python-förrådet har den fullständiga API-referensen för utvärdering:

# 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ätt dina trösklar baserat på kritikalitet -- 80% svarsnoggrannhet kan vara okej för en kreativ skrivagent, men du vill ha 95%+ för allt som hanterar finansiell data.

Driftsätt din Google ADK-agent till produktion

Driftsätt din ADK-agent till Google Cloud Run med ett kommando: adk deploy cloud_run --project DITT_PROJEKT --region us-central1. ADK paketerar din kod, bygger en container och startar en serverlös slutpunkt. För hanterad hosting, använd Vertex AI Agent Engine. För anpassad infrastruktur stöder ADK också Docker-containerisering.

Vi har driftsatt ADK-agenter på Cloud Run för interna verktyg, och kall starttider är förvånansvärt snabba -- under 3 sekunder för en grundläggande agent. För produktionssystem, överväg att para ihop din driftsättning med övervakningsverktyg för produktionsagenter.

Driftsätt till Cloud Run (rekommenderas för de flesta)

Cloud Run är den enklaste vägen. Ett kommando, och din agent är live med en HTTPS-slutpunkt:

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

Flaggan --with_ui driftsätter ADK Web-gränssnittet tillsammans med din agent, så du får ett webbläsarbaserat chatt för testning i produktion. Bakom kulisserna bygger ADK en containeravbild, pushar den till Google Artifact Registry och skapar en Cloud Run-tjänst. Det fullständiga driftsättningsflödet är dokumenterat i Googles Cloud Run-snabbstart för ADK.

För anpassad infrastruktur, här är 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

För enterprise-team som behöver hanterad skalning, övervakning och versionshantering tar Vertex AI Agent Engine hand om infrastrukturen helt. Du byter flexibilitet mot bekvämlighet -- inga containers att hantera, automatisk skalning, inbyggd analys.

Kostnadshänsyn

Verkliga siffror du bör känna till:

• Gemini API gratisnivå: 15 förfrågningar per minut, 1 miljon tokens/dag. Tillräckligt för utveckling och lättviktiga demos.
• Gemini 2.0 Flash (betald): $0,10 per miljon inmatade tokens, $0,40 per miljon utmatade tokens. Billigt nog för produktion.
• Cloud Run gratisnivå: 2 miljoner förfrågningar/månad, 360 000 GB-sekunder beräkning. En grundläggande agent som hanterar 1 000 förfrågningar/dag håller sig väl inom gratisnivån.
• Optimeringstips: Använd gemini-2.0-flash (inte gemini-2.0-pro) för underagenter som gör enkel routing eller formatering. Reservera de mer kapabla modellerna för agenter som gör komplex resonemang.

Hur Techsy arbetar med AI-agentutveckling

På Techsy har vi byggt multi-agent-system för kunder med ADK, LangGraph och CrewAI. Ramverksvalet beror på din stack: om du redan använder Google Cloud eliminerar ADK en hel del integrationsfriktion. Om du behöver multi-leverantörs LLM-stöd från dag ett ger LangGraph dig mer flexibilitet.

Vår typiska samarbetsform börjar med arkitekturkonsultation -- att kartlägga ditt användningsfall mot rätt agentmönster -- följt av prototyputveckling och Cloud Run-driftsättning. Vi har sett att team sparar 2-3 veckor genom att få arkitekturen rätt från början istället för att refaktorera senare.

Bygger du AI-agenter för ditt team? Få en kostnadsfri konsultation -- vi hjälper dig att välja rätt ramverk och driftsättningsstrategi.

Vanliga fel och felsökning

Det här är de fel vi stöter på mest när vi börjar med ADK. Spara dig felsökningstiden:

Felsökningstips: adk web är din bästa vän här. Det visar det fullständiga konversationsspåret -- varje modell-anrop, verktygsanrop och agentdelegering -- i realtid. När något går fel i ett multi-agent-system visar webb-UI:t dig exakt var kedjan bröts.

Vanliga frågor

Vad är Google ADK?

Googles Agent Development Kit (ADK) är ett öppen källkod Python-ramverk för att bygga, utvärdera och driftsätta AI-agenter. Det är optimerat för Google Gemini-modeller men stöder 100+ LLM:er via LiteLLM-integration. ADK:s kärna är inbyggd multi-agent-orkestrering med inbyggda verktyg, ett dev-UI och ett-kommando Cloud Run-driftsättning.

Är Google ADK gratis att använda?

Ja. ADK självt är öppen källkod under Apache 2.0-licensen. Du behöver en Gemini API-nyckel, som har en gratisnivå som erbjuder 15 förfrågningar per minut och 1 miljon tokens per dag. Driftsättningskostnader i molnet beror på ditt hostingval -- Cloud Runs gratisnivå täcker 2 miljoner förfrågningar per månad.

Vad är skillnaden mellan Google ADK och LangChain?

ADK är Googles åsiktsfulla ramverk optimerat för Gemini med inbyggd multi-agent-orkestrering och inbyggda driftsättningsverktyg. LangChain är modell-agnostiskt med bredare tredjepartsintegrationer men avsevärt mer komplexitet. ADK är bättre för Gemini-först-team som vill ha snabb driftsättning; LangChain passar multi-leverantörs-upplägg som behöver maximal flexibilitet.

Stöder Google ADK multi-agent-system?

Ja, och det är ADK:s flaggskeppsfunktion. Du skapar en rotAgent som delegerar till specialiserade underagenter baserat på användarförfrågningar. ADK erbjuder också SequentialAgent, ParallelAgent och LoopAgent för deterministisk arbetsflödesorkestrering. Mönstret agent-som-verktyg låter agenter anropa andra agenter som anropbara funktioner.

Hur driftsätter jag en Google ADK-agent?

Kör adk deploy cloud_run --project DITT_PROJEKT --region us-central1 för serverlös driftsättning till Google Cloud Run. Lägg till --with_ui för att inkludera det webbläsarbaserade chattgränssnittet. Du kan också driftsätta till Vertex AI Agent Engine för hanterad hosting, eller bygga en Docker-container för anpassad infrastruktur.

Kan Google ADK använda andra modeller än Gemini?

Ja. ADK stöder 100+ modeller via LiteLLM-integration, inklusive Anthropic Claude, OpenAI GPT-4, Meta Llama och Mistral. Ange modellparametern till LiteLLM-modellsträngen -- till exempel litellm/anthropic/claude-3-sonnet eller litellm/openai/gpt-4o. Gemini-modeller fungerar direkt utan LiteLLM-prefixet.

Vad är ADK Web UI?

Ett webbläsarbaserat felsökningsgränssnitt som startas med adk web din_agent_mapp. Det visar konversationsspår i realtid, verktygsanrop, agentdelegationskedjor och tillståndsändringar allt eftersom de sker. Webb-UI:t är oumbärligt för felsökning av multi-agent-system eftersom det visar exakt vilken underagent som hanterade varje förfrågan.

Stöder Google ADK MCP (Model Context Protocol)?

Ja. ADK har inbyggt stöd för Model Context Protocol, vilket gör det möjligt för agenter att ansluta till vilken MCP-kompatibel verktygsserver som helst för externa verktyg och datakällor. Det gör ADK-agenter interoperabla med det växande MCP-ekosystemet. För bakgrund om protokollet, se vår MCP-guide.

Hur testar jag ADK-agenter?

ADK levereras med inbyggda utvärderare: ResponseEvaluator för att kontrollera utdatakvalitet mot förväntade svar, och TrajectoryEvaluator för att verifiera att agenten anropade rätt verktyg i rätt ordning. Skriv testfall som JSON-filer som definierar indata, förväntade utdata och förväntade verktygsanropssekvenser, kör dem sedan med pytest.

Vilken Python-version kräver Google ADK?

ADK kräver Python 3.9 eller högre. Python 3.10+ rekommenderas för fullt stöd för typledtrådar, vilket spelar roll eftersom ADK använder typledtrådar för att generera verktygsscheman. Python 3.11 eller 3.12 erbjuder också meningsfulla prestandaförbättringar för agentarbetsbelastningar. Installera med pip install google-adk.