Google ADK-opplæring: Bygg AI-agenter fra null til produksjon

Google ADK-opplæring: Bygg AI-agenter fra null til produksjon

Googles Agent Development Kit (ADK) er rammeverket som endelig gjør multi-agent-systemer tilgjengelige. Har du bygget AI-agenter med LangChain eller CrewAI og følt at du sloss mot rammeverket mer enn du bygget med det? Denne Google ADK-opplæringen tar deg gjennom alt -- fra din første agent til distribusjon på Cloud Run.

Hva er Google ADK (og hvorfor bør du bry deg)?

Googles Agent Development Kit (ADK) er et åpen kildekode Python-rammeverk for å bygge, evaluere og distribuere AI-agenter. Utgitt i 2025, er det optimalisert for Gemini men støtter 100+ modeller via LiteLLM. ADKs store fordel er innebygd multi-agent-orkestrering -- agenter som delegerer oppgaver til andre agenter uten limkode.

Etter å ha bygget agenter med LangChain, CrewAI og nå ADK, er dette det som skiller seg ut: ADK er opinionated på de riktige stedene. Det gir deg en prosjektstruktur, et innebygd dev-grensesnitt og en distribusjonskommando. Du trenger ikke sy sammen fem biblioteker for å få en grunnleggende agent til å kjøre.

Hvis LangChain er en allmenn sveitsisk lommekniv, er ADK Googles spesialbygde verktøykasse for multi-agent-arbeidsflyter. CrewAI er nærmere i filosofi -- rollebaserte agenter som samarbeider -- men ADK går lenger med innebygd evaluering, innebygd Gemini-optimalisering og én-kommando Cloud Run-distribusjon. For en grundigere gjennomgang, sjekk ut vår dybdesammenligning av agent-rammeverk.

Hvem er ADK for? Python-utviklere som vil ha strukturerte multi-agent-systemer. Team som allerede er på Google Cloud eller Gemini. Alle som er lei av å skrive standardorkestreringskode.

Her er en oversikt over rammeverket med et blikk:

Kortversjonen: vil du ha den raskeste veien fra "idé" til "distribuert multi-agent-system", er ADK vanskelig å slå akkurat nå.

Forutsetninger og Google ADK-installasjon

For å starte med Google ADK trenger du Python 3.9+, en Gemini API-nøkkel (gratisplan tilgjengelig på Google AI Studio) og google-adk-pakken. Installer med pip install google-adk, sett API-nøkkelen som en miljøvariabel, og du er klar til å bygge din første agent på under 5 minutter.

Her er sjekklisten din for oppsett:

• Python 3.9+ (3.10+ anbefalt for full type-hint-støtte)
• En Gemini API-nøkkel -- hent én gratis på aistudio.google.com. Gratisplanen gir deg 15 forespørsler per minutt, mer enn nok for utvikling.
• pip (eller uv hvis du foretrekker fart -- uv pip install google-adk fungerer også)

Installer pakken og sett nøkkelen din:

pip install google-adk

# Sett API-nøkkelen din (legg til i .bashrc/.zshrc for å beholde den)
export GOOGLE_API_KEY="din-api-nøkkel-her"

ADK forventer en bestemt mappestruktur. Hver agent bor i sin egen pakkemappe:

my_agent/
  __init__.py    # Eksporterer root_agent
  agent.py       # Agentdefinisjon
.env             # Valgfritt: GOOGLE_API_KEY=din-nøkkel

Mappenavnet blir agentens pakkenavn, så velg noe beskrivende. Ikke kall det test eller agent -- du vil forvirre Pythons importsystem.

Proffips: Bruker du uv, opprett et virtuelt miljø først med uv venv && source .venv/bin/activate. Det er merkbart raskere enn vanlig pip for avhengighetsoppløsning.

Bygg din første Google ADK-agent

Din første ADK-agent trenger bare tre ting: et navn, en modell (som gemini-2.0-flash) og en instruksjonsstreng. Definer den i agent.py, plasser den inne i en mappe med en __init__.py, og kjør adk web for å chatte med den i et nettlesergrensesnitt. Hele oppsettet tar omtrent 10 linjer Python.

Opprett en mappe kalt my_agent og legg til to filer. Først agentdefinisjonen:

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

Deretter init-filen som eksporterer agenten din:

# my_agent/__init__.py
from .agent import root_agent

Det variabelnavnet er viktig -- ADK leter spesifikt etter root_agent. Glemmer du dette, får du en "agent not found"-feil som ikke forklarer hvorfor.

Nå kan du kjøre den. Du har to alternativer:

# CLI-modus -- chat i terminalen din
adk run my_agent

# Web UI-modus -- åpner et nettlesergrensesnitt
adk web my_agent

adk web-grensesnittet er genuint nyttig. Det viser deg den fullstendige samtalesporingen, hvilke verktøy agenten kalte, hva modellen mottok og hva den returnerte. Tenk på det som Chrome DevTools for agenten din. Når du begynner å bygge multi-agent-systemer senere, blir dette uunnværlig for å forstå delegeringsflyten.

Prøv å endre instruksjonen for å se hvordan atferden endres. Gjør den til en pirat. La den bare svare på haiku. Å få en følelse av hvordan instruksjoner former atferd er grunnlaget for alt annet i denne opplæringen.

Legg til egendefinerte verktøy i Google ADK-agenten din

ADK-agenter blir nyttige når du gir dem verktøy. Definer en Python-funksjon med en tydelig docstring, og ADK konverterer den automatisk til et verktøy agenten kan kalle. Docstringen er avgjørende -- den forteller modellen hva verktøyet gjør og når det skal brukes. ADK leveres også med innebygde verktøy som Google Søk og kodekjøring.

Verktøy er en agents hender. Uten dem kan agenten bare snakke. Med dem kan den sjekke databaser, kalle API-er, kjøre beregninger og samhandle med eksterne systemer. Vil du forstå hvordan funksjonskalling fungerer under panseret, har vi en egen dybdedykk om det.

Egendefinerte funksjonsverktøy

Her er et praktisk eksempel -- et verktøy som slår opp aksjepriser:

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

Legg merke til typehintene og docstringen. Disse er ikke valgfrie finurligheter -- ADK bruker dem til å generere verktøysskjemaet som modellen ser. Hopper du over docstringen, vet ikke modellen når den skal kalle funksjonen din. Hopper du over typehintene, får du en signaturfeil.

Innebygde verktøy (Google Søk, kodekjøring)

ADK leveres med verktøy du kan ta i bruk uten å skrive noen 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 lar agenten spørre nettet i sanntid. code_execution gir den et sandkasset Python-miljø for å kjøre beregninger. Disse to dekker alene et overraskende stort antall brukstilfeller.

Multi-agent-systemer: Slik delegerer Google ADK-agenter arbeid

ADKs multi-agent-system bruker en rotagent som delegerer oppgaver til spesialiserte underagenter. Hver underagent håndterer ett domene -- forskning, skriving, koding. Rotagenten bestemmer hvilken underagent som skal kalles basert på brukerens forespørsel. Du kan også bruke agent-som-verktøy-mønsteret, der én agent kaller en annen som om den var en funksjon. Googles offisielle blogg om multi-agent-systemer går dypere inn i arkitekturmønstrene.

Tenk på det som en prosjektleder som delegerer til spesialister. Rotagenten leser brukerens forespørsel, finner ut hvilken spesialist som bør håndtere den, og ruter deretter. Spesialistene vet ikke om hverandre -- de gjør bare jobben sin og rapporterer tilbake.

Rotagent + underagenter-mønster

Her er et fungerende eksempel med en rotagent som delegerer til en forskningsagent og en skriveagent:

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

# Underagent 1: håndterer 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: håndterer skriving
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: delegerer til riktig 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"
)

description-feltet på hver underagent er hvordan rotagenten forstår hva de kan gjøre. Skriv tydelige beskrivelser -- vage beskrivelser fører til dårlige rutingbeslutninger.

Agent-som-verktøy-mønster

Noen ganger vil du ha mer kontroll over hvordan én agent kaller en annen. Agent-som-verktøy-mønsteret pakker inn en underagent som et kallbart verktøy:

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

Bruk underagenter når du vil at rotagenten skal delegere full kontroll. Bruk agent-som-verktøy når du vil at den kallende agenten skal forbli i førersetet og bare bruke underagentens utdata som inndata. Bygger du systemer der agenter trenger delt kontekst, se vår omfattende guide til agent-minnearkitekturer.

Arbeidsflyt-agenter: Sekvensielle, parallelle og løkker

Utover LLM-drevet delegering tilbyr ADK tre arbeidsflyt-agenttyper for deterministisk orkestrering: SequentialAgent kjører underagenter én etter én, ParallelAgent kjører dem samtidig, og LoopAgent gjentar en sekvens til en betingelse er oppfylt. Disse er nyttige når du trenger forutsigbar kjøringsrekkefølge i stedet for å la LLM-en bestemme.

Forskjellen er viktig. LLM-drevet delegering (sub_agents-mønsteret ovenfor) lar modellen velge hvem som skal kalles. Arbeidsflyt-agenter gir deg programmatisk kontroll. Bruk arbeidsflyt-agenter når kjøringsrekkefølgen er kjent på forhånd.

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

# Tre agenter som må kjøre i rekkefølge
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 -> gjennomgang
content_pipeline = SequentialAgent(
    name="content_pipeline",
    sub_agents=[research_agent, draft_agent, review_agent],
    description="Runs a complete content creation pipeline"
)

For uavhengige oppgaver som kan kjøre samtidig, sparer ParallelAgent ekte tid:

# Tre datahentere som kjører parallelt
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åndtere tilstand og minne

ADK håndterer agenttilstand på to nivåer: økt-tilstand (data innen en samtale, som brukerpreferanser samlet midtveis i en chat) og minnetjenester (data som vedvarer på tvers av samtaler). Økt-tilstand er et enkelt nøkkel-verdi-lager tilgjengelig via context.state. Minne bruker tjenester som InMemoryMemoryService eller VertexAIMemoryBankService for produksjon.

Økt-tilstand er den enklere av dem. Det er en ordbok knyttet til hver samtale:

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 minne på tvers av samtaler -- den typen der agenten din husker en bruker fra forrige tirsdag -- trenger du en minnetjeneste:

from google.adk.memory import InMemoryMemoryService

# For utvikling (data går tapt ved omstart)
memory_service = InMemoryMemoryService()

# For produksjon, bruk VertexAIMemoryBankService
# memory_service = VertexAIMemoryBankService(project="your-project")

Når trenger du minne kontra økt-tilstand? Hvis det er innen én samtale (handlekurv, gjeldende oppgavekontekst), bruk økt-tilstand. Hvis det må overleve mellom samtaler (brukerpreferanser, tidligere interaksjoner), bruk en minnetjeneste. Sjekk ut vår omfattende guide til agent-minnearkitekturer for produksjonsmønstre.

Tilbakekall: Kontrollere agentens atferd

ADK-tilbakekall lar deg avskjære og endre agentens atferd på fire punkter: before_model_callback (før LLM-kall), after_model_callback (etter LLM-svar), before_tool_callback (før verktøykjøring) og after_tool_callback (etter verktøyresultat). Bruk dem for inndatavalidering, sikkerhetsfiltrering, logging eller endring av svar før de når brukeren.

Tilbakekall er der du legger til sikringsrekkverk. Tenk på dem som mellomvare for agenten din -- hver forespørsel og svar passerer gjennom dem, og du kan inspisere, endre eller blokkere hva 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 viktigste for produksjon. Den kjøres før hvert LLM-kall, og gir deg muligheten til å blokkere prompt-injeksjoner, validere inndata eller legge til systemkontekst. Returnerer du et responsobjekt, hopper ADK over modellen helt. Returner None for å la forespørselen passere. For flere mønstre, se dypere mønstre for LLM-sikkerhetsrekkverk.

Teste og evaluere ADK-agentene dine

ADK inkluderer et innebygd evalueringsrammeverk med to evaluatortyper: ResponseEvaluator sjekker om agentens endelige svar er riktig, og TrajectoryEvaluator verifiserer at agenten tok de riktige trinnene -- kalte de riktige verktøyene i riktig rekkefølge. Skriv testsaker som JSON-filer og kjør dem med pytest for å fange regresjoner før distribusjon.

Hvorfor bry seg med å teste agenter? Fordi de er ikke-deterministiske. Samme inndata kan gi forskjellige utdata, og en liten endring i instruksjonen din kan bryte verktøykalling på subtile måter. Etter vår erfaring er agenter som består baneevaluering langt mer pålitelige i produksjon enn de som bare testes på endelig utdatakvalitet. For bredere evalueringsstrategier, se vår guide til LLM-evalueringsstrategier.

Testsakene dine 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"}}
    ]
  }
]

Kjør deretter evalueringer med pytest. ADK Python-repositoriet har den fullstendige evaluerings-API-referansen:

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

Kjør med pytest test_agent.py -v. Sett tersklene dine basert på kritikalitet -- 80 % svarsnøyaktighet kan være greit for en kreativ skriveagent, men du vil ha 95 %+ for alt som håndterer finansielle data.

Distribuer Google ADK-agenten din til produksjon

Distribuer ADK-agenten din til Google Cloud Run med én kommando: adk deploy cloud_run --project YOUR_PROJECT --region us-central1. ADK pakker koden din, bygger en container og starter et serverløst endepunkt. For administrert hosting, bruk Vertex AI Agent Engine. For tilpasset infrastruktur støtter ADK også Docker-containerisering.

Vi har distribuert ADK-agenter på Cloud Run for interne verktøy, og oppstartstidene er overraskende raske -- under 3 sekunder for en grunnleggende agent. For produksjonssystemer, vurder å kombinere distribusjonen din med overvåkingsverktøy for produksjonsagenter.

Distribuer til Cloud Run (anbefalt for de fleste)

Cloud Run er den enkleste veien. Én kommando, og agenten din er live med et HTTPS-endepunkt:

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

--with_ui-flagget distribuerer ADK Web-grensesnittet ved siden av agenten din, slik at du får en nettleserbasert chat for testing i produksjon. I bakgrunnen bygger ADK et containerimage, pusher det til Google Artifact Registry og oppretter en Cloud Run-tjeneste. Den fullstendige distribusjonsflyten er dokumentert i Googles Cloud Run-hurtigstart for ADK.

For tilpasset 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 bedriftsteam som trenger administrert skalering, overvåking og versjonering, håndterer Vertex AI Agent Engine infrastrukturen helt. Du bytter fleksibilitet mot bekvemmelighet -- ingen containere å administrere, automatisk skalering, innebygd analyse.

Kostnadshensyn

Reelle tall du bør kjenne til:

• Gemini API gratisplan: 15 forespørsler per minutt, 1 million tokens/dag. Nok for utvikling og lette demoer.
• Gemini 2.0 Flash (betalt): $0,10 per million inndata-tokens, $0,40 per million utdata-tokens. Billig nok for produksjon.
• Cloud Run gratisplan: 2 millioner forespørsler/måned, 360 000 GB-sekunder beregning. En grunnleggende agent som håndterer 1 000 forespørsler/dag forblir godt innenfor gratisplanen.
• Optimaliseringstips: Bruk gemini-2.0-flash (ikke gemini-2.0-pro) for underagenter som gjør enkel ruting eller formatering. Reserver de mer kapable modellene for agenter som gjør kompleks resonnering.

Slik jobber Techsy med AI-agentutvikling

Hos Techsy har vi bygget multi-agent-systemer for kunder ved hjelp av ADK, LangGraph og CrewAI. Valget av rammeverk avhenger av din teknologistabel: er du allerede på Google Cloud, eliminerer ADK mye integrasjonsfrikt. Trenger du støtte for flere LLM-leverandører fra dag én, gir LangGraph deg mer fleksibilitet.

Et typisk prosjekt hos oss starter med arkitekturkonsultasjon -- kartlegging av brukstilfellet ditt mot de riktige agentmønstrene -- etterfulgt av prototypeutvikling og Cloud Run-distribusjon. Vi har erfart at team sparer 2-3 uker ved å få arkitekturen riktig fra start i stedet for å refaktorere senere.

Bygger du AI-agenter for teamet ditt? Få en gratis konsultasjon -- vi hjelper deg å velge riktig rammeverk og distribusjonsstrategi.

Vanlige feil og feilsøking

Dette er feilene vi oftest støter på når vi kommer i gang med ADK. Spar deg selv for feilsøkingstiden:

Feilsøkingstips: adk web er din beste venn her. Det viser den fullstendige samtalesporingen -- hvert modellkall, verktøykalling og agentdelegering -- i sanntid. Når noe går galt i et multi-agent-system, viser web-grensesnittet deg nøyaktig hvor kjeden brøt.

Ofte stilte spørsmål

Hva er Google ADK?

Googles Agent Development Kit (ADK) er et åpen kildekode Python-rammeverk for å bygge, evaluere og distribuere AI-agenter. Det er optimalisert for Google Gemini-modeller men støtter 100+ LLM-er gjennom LiteLLM-integrasjon. ADKs kjernestyrke er innebygd multi-agent-orkestrering med innebygde verktøy, et dev-grensesnitt og én-kommando Cloud Run-distribusjon.

Er Google ADK gratis å bruke?

Ja. ADK er selv åpen kildekode under Apache 2.0-lisensen. Du trenger en Gemini API-nøkkel, som har en gratisplan med 15 forespørsler per minutt og 1 million tokens per dag. Distribusjonskostnader avhenger av valget ditt for hosting -- Cloud Runs gratisplan dekker 2 millioner forespørsler per måned.

Hva er forskjellen mellom Google ADK og LangChain?

ADK er Googles opinionated rammeverk optimalisert for Gemini med innebygd multi-agent-orkestrering og innebygde distribusjonsverktøy. LangChain er modellagnostisk med bredere tredjepartsintegrasjoner men betydelig mer kompleksitet. ADK er bedre for Gemini-først-team som vil ha rask distribusjon; LangChain passer multi-leverandør-oppsett som trenger maksimal fleksibilitet.

Støtter Google ADK multi-agent-systemer?

Ja, og det er ADKs flaggskipfunksjon. Du oppretter en rotagent som delegerer til spesialiserte underagenter basert på brukerforespørsler. ADK tilbyr også SequentialAgent, ParallelAgent og LoopAgent for deterministisk arbeidsflyt-orkestrering. Agent-som-verktøy-mønsteret lar agenter kalle andre agenter som kallbare funksjoner.

Hvordan distribuerer jeg en Google ADK-agent?

Kjør adk deploy cloud_run --project YOUR_PROJECT --region us-central1 for serverløs distribusjon til Google Cloud Run. Legg til --with_ui for å inkludere det nettleserbaserte chat-grensesnittet. Du kan også distribuere til Vertex AI Agent Engine for administrert hosting, eller bygge en Docker-container for tilpasset infrastruktur.

Kan Google ADK bruke andre modeller enn Gemini?

Ja. ADK støtter 100+ modeller gjennom LiteLLM-integrasjon, inkludert Anthropic Claude, OpenAI GPT-4, Meta Llama og Mistral. Sett modellparameteren til LiteLLM-modellstrengen -- for eksempel litellm/anthropic/claude-3-sonnet eller litellm/openai/gpt-4o. Gemini-modeller fungerer naturlig uten LiteLLM-prefikset.

Hva er ADK Web UI?

Et nettleserbasert feilsøkingsgrensesnitt startet med adk web agentmappen-din. Det viser sanntids samtalesporinger, verktøykall, agentdelegeringskjeder og tilstandsendringer mens de skjer. Web UI er avgjørende for feilsøking av multi-agent-systemer fordi det viser nøyaktig hvilken underagent som håndterte hver forespørsel.

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

Ja. ADK har innebygd støtte for Model Context Protocol, som lar agenter koble til alle MCP-kompatible verktøyservere for eksterne verktøy og datakilder. Dette gjør ADK-agenter interoperable med det voksende MCP-økosystemet. For bakgrunn om protokollen, se vår MCP-guide.

Hvordan tester jeg ADK-agenter?

ADK leveres med innebygde evaluatorer: ResponseEvaluator for å sjekke utdatakvalitet mot forventede svar, og TrajectoryEvaluator for å verifisere at agenten kalte de riktige verktøyene i riktig rekkefølge. Skriv testsaker som JSON-filer som definerer innganger, forventede utdata og forventede verktøykallsekvenser, kjør dem deretter med pytest.

Hvilken Python-versjon krever Google ADK?

ADK krever Python 3.9 eller høyere. Python 3.10+ anbefales for full støtte av typehintig, noe som er viktig fordi ADK bruker typehint til å generere verktøysskjemaer. Python 3.11 eller 3.12 gir også meningsfull ytelsesforbedring for agentarbeidsbelastninger. Installer med pip install google-adk.