Google ADK Tutorial: KI-Agenten von Grund auf bis zur Produktion bauen

Google ADK Tutorial: KI-Agenten von Grund auf bis zur Produktion bauen

Googles Agent Development Kit (ADK) ist das Framework, das Multi-Agenten-Systeme endlich zugänglich macht. Wer bisher Agenten mit LangChain oder CrewAI gebaut hat und dabei mehr gegen das Framework gekämpft hat als damit, findet in diesem Google ADK Tutorial alles -- vom ersten Agenten bis zum Deployment auf Cloud Run.

Was ist Google ADK (und warum lohnt es sich)?

Googles Agent Development Kit (ADK) ist ein Open-Source-Python-Framework zum Entwickeln, Evaluieren und Deployen von KI-Agenten. Es wurde 2025 veröffentlicht, ist für Gemini optimiert, unterstützt aber über 100 Modelle via LiteLLM. ADKs Kernstärke ist die native Multi-Agenten-Orchestrierung -- Agenten, die Aufgaben an andere Agenten delegieren, ohne Klebe-Code.

Nach dem Arbeiten mit LangChain, CrewAI und jetzt ADK fällt folgendes auf: ADK ist an den richtigen Stellen meinungsstark. Es gibt eine vorgegebene Projektstruktur, eine eingebaute Entwicklungs-UI und einen Deployment-Befehl. Kein Zusammenstöpseln von fünf Bibliotheken, nur um einen einfachen Agenten zum Laufen zu bringen.

Wenn LangChain ein Schweizer Taschenmesser für allgemeine Zwecke ist, dann ist ADK Googles zweckgebautes Toolkit für Multi-Agenten-Workflows. CrewAI ist philosophisch näher dran -- rollenbasierte Agenten, die zusammenarbeiten -- aber ADK geht weiter mit integrierter Evaluierung, nativer Gemini-Optimierung und Ein-Befehl-Cloud-Run-Deployment. Für einen ausführlichen Vergleich empfiehlt sich unser Deep-Dive-Vergleich der Agenten-Frameworks.

Für wen ist ADK gedacht? Python-Entwickler, die strukturierte Multi-Agenten-Systeme wollen. Teams, die bereits auf Google Cloud oder Gemini setzen. Alle, die es leid sind, Boilerplate-Orchestrierungslogik zu schreiben.

So schneidet der Vergleich der Frameworks auf einen Blick aus:

Kurz gesagt: Wer den schnellsten Weg von der Idee zum deployen Multi-Agenten-System sucht, kommt aktuell an ADK kaum vorbei.

Voraussetzungen und Google ADK Installation

Für den Start mit Google ADK braucht man Python 3.9+, einen Gemini API-Key (kostenloser Tier verfügbar bei Google AI Studio) und das google-adk-Paket. Installation mit pip install google-adk, API-Key als Umgebungsvariable setzen, und der erste Agent läuft in unter 5 Minuten.

Die Setup-Checkliste:

• Python 3.9+ (3.10+ empfohlen für vollständige Typen-Hint-Unterstützung)
• Ein Gemini API-Key -- kostenfrei holen bei aistudio.google.com. Der kostenlose Tier bietet 15 Anfragen pro Minute, was für die Entwicklung mehr als ausreicht.
• pip (oder uv, wenn Geschwindigkeit wichtig ist -- uv pip install google-adk funktioniert ebenfalls)

Paket installieren und Key setzen:

pip install google-adk

# API-Key setzen (in .bashrc/.zshrc eintragen für dauerhaften Effekt)
export GOOGLE_API_KEY="your-api-key-here"

ADK erwartet eine bestimmte Ordnerstruktur. Jeder Agent lebt in seinem eigenen Package-Verzeichnis:

my_agent/
  __init__.py    # Exportiert root_agent
  agent.py       # Agenten-Definition
.env             # Optional: GOOGLE_API_KEY=your-key

Der Ordnername wird zum Package-Namen des Agenten -- also etwas Beschreibendes wählen. Bloß nicht test oder agent -- das verwirrt Pythons Import-System.

Pro-Tipp: Wer uv nutzt, erstellt zuerst eine virtuelle Umgebung mit uv venv && source .venv/bin/activate. Die Abhängigkeitsauflösung ist spürbar schneller als bei regulärem pip.

Den ersten Google ADK Agenten bauen

Ein erster ADK-Agent braucht nur drei Dinge: einen Namen, ein Modell (wie gemini-2.0-flash) und einen Instruktions-String. In agent.py definieren, in einen Ordner mit __init__.py legen und mit adk web im Browser-UI damit chatten. Das komplette Setup umfasst etwa 10 Zeilen Python.

Einen Ordner namens my_agent anlegen und zwei Dateien hinzufügen. Zuerst die Agenten-Definition:

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

Dann die Init-Datei, die den Agenten exportiert:

# my_agent/__init__.py
from .agent import root_agent

Dieser Variablenname ist entscheidend -- ADK sucht explizit nach root_agent. Fehlt das, kommt ein "agent not found"-Fehler, der den Grund nicht erklärt.

Jetzt ausführen. Es gibt zwei Optionen:

# CLI-Modus -- im Terminal chatten
adk run my_agent

# Web-UI-Modus -- öffnet eine Browser-Oberfläche
adk web my_agent

Die adk web-Oberfläche ist wirklich nützlich. Sie zeigt den vollständigen Konversations-Trace, welche Tools der Agent aufgerufen hat, was das Modell empfangen hat und was es zurückgegeben hat. Man denke daran als Chrome DevTools für den eigenen Agenten. Beim späteren Aufbau von Multi-Agenten-Systemen wird das unverzichtbar, um den Delegationsfluss zu verstehen.

Die Instruktion ändern und beobachten, wie sich das Verhalten verändert. Als Pirat. Nur in Haiku antworten. Ein Gefühl dafür zu entwickeln, wie Instruktionen das Verhalten formen, ist die Basis für alles weitere in diesem Tutorial.

Benutzerdefinierte Tools zum Google ADK Agenten hinzufügen

ADK-Agenten werden erst nützlich, wenn man ihnen Tools gibt. Eine Python-Funktion mit einem klaren Docstring definieren, und ADK konvertiert sie automatisch in ein Tool, das der Agent aufrufen kann. Der Docstring ist entscheidend -- er erklärt dem Modell, was das Tool tut und wann es verwendet werden soll. ADK liefert auch eingebaute Tools wie Google Search und Code-Ausführung mit.

Tools sind die Hände eines Agenten. Ohne sie kann er nur reden. Mit ihnen kann er Datenbanken abfragen, APIs aufrufen, Berechnungen durchführen und mit externen Systemen interagieren. Wer verstehen möchte, wie Function Calling unter der Haube funktioniert, findet bei uns einen separaten Deep-Dive dazu.

Benutzerdefinierte Funktions-Tools

Ein praktisches Beispiel -- ein Tool, das Aktienkurse nachschlägt:

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

Die Typen-Hints und der Docstring sind keine optionalen Schönheiten -- ADK nutzt sie, um das Tool-Schema zu generieren, das das Modell sieht. Den Docstring weglassen, und das Modell weiß nicht, wann es die Funktion aufrufen soll. Typen-Hints weglassen, und es gibt einen Signatur-Fehler.

Eingebaute Tools (Google Search, Code-Ausführung)

ADK enthält Tools, die man direkt nutzen kann, ohne eine Zeile Code zu schreiben:

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 ermöglicht dem Agenten, das Web in Echtzeit abzufragen. code_execution gibt ihm eine abgesicherte Python-Umgebung für Berechnungen. Diese beiden decken überraschend viele Anwendungsfälle ab.

Multi-Agenten-Systeme: Wie Google ADK Agenten Arbeit delegieren

ADKs Multi-Agenten-System nutzt einen Root-Agenten, der Aufgaben an spezialisierte Unteragenten delegiert. Jeder Unteragent ist für eine Domäne zuständig -- Recherche, Schreiben, Coding. Der Root-Agent entscheidet basierend auf der Nutzeranfrage, welchen Unteragenten er aufruft. Es gibt auch das Agent-als-Tool-Muster, bei dem ein Agent einen anderen wie eine Funktion aufruft. Googles offizieller Blog über Multi-Agenten-Systeme geht tiefer in die Architekturmuster.

Man stelle sich das wie einen Projektmanager vor, der an Spezialisten delegiert. Der Root-Agent liest die Nutzeranfrage, erkennt, welcher Spezialist zuständig ist, und leitet entsprechend weiter. Die Spezialisten kennen sich nicht gegenseitig -- sie erledigen ihre Aufgabe und berichten zurück.

Root-Agent + Unteragenten-Muster

Ein funktionierendes Beispiel mit einem Root-Agenten, der an einen Recherche-Agenten und einen Schreib-Agenten delegiert:

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

# Unteragent 1: übernimmt die Recherche
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"
)

# Unteragent 2: übernimmt das Schreiben
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: delegiert an den richtigen Unteragenten
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"
)

Das description-Feld bei jedem Unteragenten erklärt dem Root-Agenten, was sie leisten können. Klare Beschreibungen schreiben -- vage führen zu schlechten Routing-Entscheidungen.

Agent-als-Tool-Muster

Manchmal braucht man mehr Kontrolle darüber, wie ein Agent einen anderen aufruft. Das Agent-als-Tool-Muster verpackt einen Unteragenten als aufrufbares 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"
)

sub_agents nutzen, wenn der Root-Agent die Kontrolle vollständig abgeben soll. Agent-als-Tool nutzen, wenn der aufrufende Agent das Steuer behalten und den Unteragenten-Output nur als Eingabe verwenden soll. Wer Systeme baut, in denen Agenten gemeinsamen Kontext benötigen, findet in unserem umfassenden Leitfaden zu Agenten-Gedächtnisarchitekturen die passenden Muster.

Workflow-Agenten: Sequenziell, Parallel und in Schleifen

Über LLM-gesteuerte Delegation hinaus bietet ADK drei Workflow-Agenten-Typen für deterministische Orchestrierung: SequentialAgent führt Unteragenten nacheinander aus, ParallelAgent führt sie gleichzeitig aus, und LoopAgent wiederholt eine Sequenz, bis eine Bedingung erfüllt ist. Diese sind sinnvoll, wenn eine vorhersehbare Ausführungsreihenfolge gebraucht wird, anstatt das LLM entscheiden zu lassen.

Der Unterschied ist wichtig. LLM-gesteuerte Delegation (das obige sub_agents-Muster) lässt das Modell wählen, wen es aufruft. Workflow-Agenten bieten programmatische Kontrolle. Workflow-Agenten einsetzen, wenn die Ausführungsreihenfolge im Voraus bekannt ist.

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

# Drei Agenten, die in einer bestimmten Reihenfolge laufen müssen
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: recherchieren -> entwerfen -> überprüfen
content_pipeline = SequentialAgent(
    name="content_pipeline",
    sub_agents=[research_agent, draft_agent, review_agent],
    description="Runs a complete content creation pipeline"
)

Für unabhängige Aufgaben, die gleichzeitig ablaufen können, spart ParallelAgent echte Zeit:

# Drei Datenabrufer, die gleichzeitig laufen
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"
)

Zustand und Gedächtnis verwalten

ADK verwaltet den Agenten-Zustand auf zwei Ebenen: Session-Zustand (Daten innerhalb eines Gesprächs, z. B. während des Chats gesammelte Nutzerpräferenzen) und Gedächtnisdienste (Daten, die gesprächsübergreifend erhalten bleiben). Session-Zustand ist ein einfacher Key-Value-Store, auf den via context.state zugegriffen wird. Gedächtnis nutzt Dienste wie InMemoryMemoryService oder VertexAIMemoryBankService für die Produktion.

Der Session-Zustand ist der einfachere Ansatz. Er ist ein Dictionary, das an jedes Gespräch angehängt ist:

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 gesprächsübergreifendes Gedächtnis -- also wenn der Agent einen Nutzer von letztem Dienstag noch kennen soll -- braucht man einen Gedächtnisdienst:

from google.adk.memory import InMemoryMemoryService

# Für die Entwicklung (Daten gehen beim Neustart verloren)
memory_service = InMemoryMemoryService()

# Für die Produktion: VertexAIMemoryBankService nutzen
# memory_service = VertexAIMemoryBankService(project="your-project")

Wann braucht man Gedächtnis vs. Session-Zustand? Wenn es innerhalb eines einzelnen Gesprächs ist (Warenkorb, aktueller Aufgabenkontext), Session-Zustand verwenden. Wenn es gesprächsübergreifend erhalten bleiben soll (Nutzerpräferenzen, vergangene Interaktionen), einen Gedächtnisdienst nutzen. Unser umfassender Leitfaden zu Agenten-Gedächtnisarchitekturen enthält Produktionsmuster.

Callbacks: Agentenverhalten steuern

ADK-Callbacks ermöglichen das Abfangen und Modifizieren des Agentenverhaltens an vier Punkten: before_model_callback (vor dem LLM-Aufruf), after_model_callback (nach der LLM-Antwort), before_tool_callback (vor der Tool-Ausführung) und after_tool_callback (nach dem Tool-Ergebnis). Verwendung für Eingabevalidierung, Sicherheitsfilterung, Logging oder das Anpassen von Antworten, bevor sie den Nutzer erreichen.

Callbacks sind der Ort, an dem man Leitplanken einbaut. Man stelle sie sich als Middleware für den Agenten vor -- jede Anfrage und Antwort läuft durch sie, und man kann alles inspizieren, modifizieren oder blockieren.

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():
            # Direkt eine Antwort zurückgeben, den Modell-Aufruf überspringen
            return {"blocked": True, "reason": "Request matched safety filter"}
    
    # None zurückgeben, um normal fortzufahren
    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  # Das Ergebnis nicht verändern

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

Der before_model_callback ist für die Produktion am wichtigsten. Er läuft vor jedem LLM-Aufruf und gibt die Möglichkeit, Prompt-Injections zu blockieren, Eingaben zu validieren oder Systemkontext hinzuzufügen. Wenn ein Antwortobjekt zurückgegeben wird, überspringt ADK das Modell vollständig. None zurückgeben, um die Anfrage durchzulassen. Weitere Muster gibt es im Artikel über tiefergehende Muster für LLM-Sicherheits-Leitplanken.

ADK-Agenten testen und evaluieren

ADK enthält ein eingebautes Evaluierungs-Framework mit zwei Evaluator-Typen: ResponseEvaluator prüft, ob die finale Antwort des Agenten korrekt ist, und TrajectoryEvaluator verifiziert, dass der Agent die richtigen Schritte unternommen hat -- die richtigen Tools in der richtigen Reihenfolge aufgerufen hat. Testfälle als JSON-Dateien schreiben und mit pytest ausführen, um Regressionen vor dem Deployment zu erkennen.

Warum Agenten überhaupt testen? Weil sie nicht-deterministisch sind. Dieselbe Eingabe kann unterschiedliche Ausgaben produzieren, und eine kleine Änderung an der Instruktion kann das Tool-Calling auf subtile Weise kaputtmachen. In der Praxis sind Agenten, die die Trajektorienevaluierung bestehen, in der Produktion deutlich zuverlässiger als solche, die nur auf finale Ausgabequalität getestet wurden. Für umfassendere Evaluierungsstrategien empfiehlt sich unser Leitfaden zu LLM-Evaluierungsstrategien.

Die Testfälle kommen in eine JSON-Datei:

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

Dann Evaluierungen mit pytest ausführen. Das ADK Python Repository enthält die vollständige Evaluierungs-API-Referenz:

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

Mit pytest test_agent.py -v ausführen. Die Schwellenwerte nach Kritikalität anpassen -- 80 % Antwort-Genauigkeit mag für einen kreativen Schreib-Agenten akzeptabel sein, aber für alles, das mit Finanzdaten umgeht, sollten es 95 %+ sein.

Den Google ADK Agenten in die Produktion deployen

Einen ADK-Agenten mit einem Befehl auf Google Cloud Run deployen: adk deploy cloud_run --project YOUR_PROJECT --region us-central1. ADK verpackt den Code, baut einen Container und startet einen serverlosen Endpunkt. Für verwaltetes Hosting Vertex AI Agent Engine nutzen. Für eigene Infrastruktur unterstützt ADK auch Docker-Containerisierung.

Wir haben ADK-Agenten auf Cloud Run für interne Tools deployed, und die Kaltstart-Zeiten sind überraschend schnell -- unter 3 Sekunden für einen einfachen Agenten. Für Produktionssysteme empfiehlt sich die Kombination mit Monitoring-Tools für Produktions-Agenten.

Auf Cloud Run deployen (für die meisten empfohlen)

Cloud Run ist der einfachste Weg. Ein Befehl, und der Agent ist live mit einem HTTPS-Endpunkt:

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

Das --with_ui-Flag deployed die ADK-Web-Oberfläche zusammen mit dem Agenten, sodass man einen Browser-basierten Chat für Tests in der Produktion bekommt. Hinter den Kulissen baut ADK ein Container-Image, pusht es in die Google Artifact Registry und erstellt einen Cloud Run-Dienst. Der vollständige Deployment-Ablauf ist in Googles Cloud Run-Schnellstart für ADK dokumentiert.

Für eigene Infrastruktur gibt es hier ein minimales 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"]

Alternative: Vertex AI Agent Engine

Für Enterprise-Teams, die verwaltetes Skalieren, Monitoring und Versionierung benötigen, übernimmt Vertex AI Agent Engine die gesamte Infrastruktur. Man tauscht Flexibilität gegen Komfort -- keine Container zu verwalten, automatisches Skalieren, eingebaute Analysen.

Kostenüberlegungen

Wichtige Zahlen, die man kennen sollte:

• Gemini API kostenloser Tier: 15 Anfragen pro Minute, 1 Million Tokens/Tag. Ausreichend für Entwicklung und leichte Demos.
• Gemini 2.0 Flash (kostenpflichtig): $0,10 pro Million Input-Tokens, $0,40 pro Million Output-Tokens. Günstig genug für die Produktion.
• Cloud Run kostenloser Tier: 2 Millionen Anfragen/Monat, 360.000 GB-Sekunden Rechenzeit. Ein einfacher Agent mit 1.000 Anfragen/Tag bleibt gut im kostenlosen Tier.
• Optimierungstipp: gemini-2.0-flash (nicht gemini-2.0-pro) für Unteragenten nutzen, die einfaches Routing oder Formatierung durchführen. Die leistungsfähigeren Modelle für Agenten reservieren, die komplexes Reasoning erledigen.

Wie Techsy an die KI-Agenten-Entwicklung herangeht

Bei Techsy haben wir Multi-Agenten-Systeme für Kunden mit ADK, LangGraph und CrewAI gebaut. Die Framework-Wahl hängt vom Stack ab: Wer bereits auf Google Cloud ist, spart mit ADK viel Integrationsaufwand. Wer von Anfang an Multi-Provider-LLM-Unterstützung braucht, hat mit LangGraph mehr Flexibilität.

Unsere typischen Projekte beginnen mit Architekturberatung -- die Abbildung des Anwendungsfalls auf die richtigen Agenten-Muster -- gefolgt von Prototypentwicklung und Cloud Run-Deployment. Teams sparen erfahrungsgemäß 2-3 Wochen, wenn die Architektur von Anfang an stimmt, statt später umzubauen.

KI-Agenten für Ihr Team bauen? Jetzt kostenloses Beratungsgespräch buchen -- wir helfen dabei, das richtige Framework und die richtige Deployment-Strategie zu wählen.

Häufige Fehler und Fehlerbehebung

Das sind die Fehler, auf die man beim Start mit ADK am häufigsten stößt. Debugging-Zeit sparen:

Debugging-Tipp: adk web ist hier der beste Freund. Es zeigt den vollständigen Konversations-Trace -- jeden Modell-Aufruf, jeden Tool-Aufruf und jede Agenten-Delegation -- in Echtzeit. Wenn in einem Multi-Agenten-System etwas schiefläuft, zeigt die Web-UI genau, wo die Kette gerissen ist.

FAQ

Was ist Google ADK?

Googles Agent Development Kit (ADK) ist ein Open-Source-Python-Framework zum Entwickeln, Evaluieren und Deployen von KI-Agenten. Es ist für Google Gemini-Modelle optimiert, unterstützt aber über 100 LLMs durch LiteLLM-Integration. ADKs Kernstärke ist native Multi-Agenten-Orchestrierung mit eingebauten Tools, einer Entwicklungs-UI und Ein-Befehl-Cloud-Run-Deployment.

Ist Google ADK kostenlos nutzbar?

Ja. ADK selbst ist Open Source unter der Apache-2.0-Lizenz. Man braucht einen Gemini API-Key, der einen kostenlosen Tier mit 15 Anfragen pro Minute und 1 Million Tokens pro Tag bietet. Deployment-Kosten hängen von der Hosting-Wahl ab -- Cloud Runs kostenloser Tier deckt 2 Millionen Anfragen pro Monat ab.

Was ist der Unterschied zwischen Google ADK und LangChain?

ADK ist Googles meinungsstarkes Framework, optimiert für Gemini mit nativer Multi-Agenten-Orchestrierung und eingebauten Deployment-Tools. LangChain ist modell-agnostisch mit breiteren Drittanbieter-Integrationen, aber deutlich mehr Komplexität. ADK eignet sich besser für Gemini-first-Teams, die schnelles Deployment wollen; LangChain passt für Multi-Provider-Setups, die maximale Flexibilität brauchen.

Unterstützt Google ADK Multi-Agenten-Systeme?

Ja, und das ist ADKs Vorzeige-Feature. Man erstellt einen Root-Agenten, der basierend auf Nutzeranfragen an spezialisierte Unteragenten delegiert. ADK bietet auch SequentialAgent, ParallelAgent und LoopAgent für deterministische Workflow-Orchestrierung. Das Agent-als-Tool-Muster ermöglicht es Agenten, andere Agenten als aufrufbare Funktionen zu verwenden.

Wie deploye ich einen Google ADK Agenten?

adk deploy cloud_run --project YOUR_PROJECT --region us-central1 für serverloses Deployment auf Google Cloud Run ausführen. --with_ui hinzufügen, um die Browser-basierte Chat-Oberfläche einzuschließen. Alternativ auf Vertex AI Agent Engine für verwaltetes Hosting deployen oder einen Docker-Container für eigene Infrastruktur bauen.

Kann Google ADK andere Modelle als Gemini nutzen?

Ja. ADK unterstützt über 100 Modelle durch LiteLLM-Integration, darunter Anthropic Claude, OpenAI GPT-4, Meta Llama und Mistral. Den Modell-Parameter auf den LiteLLM-Modell-String setzen -- zum Beispiel litellm/anthropic/claude-3-sonnet oder litellm/openai/gpt-4o. Gemini-Modelle funktionieren nativ ohne das LiteLLM-Präfix.

Was ist die ADK Web UI?

Eine Browser-basierte Debug-Oberfläche, die mit adk web your_agent_folder gestartet wird. Sie zeigt Echtzeit-Konversations-Traces, Tool-Aufrufe, Agenten-Delegationsketten und Zustandsänderungen während sie passieren. Die Web UI ist unverzichtbar für das Debuggen von Multi-Agenten-Systemen, weil sie genau zeigt, welcher Unteragent jede Anfrage behandelt hat.

Unterstützt Google ADK MCP (Model Context Protocol)?

Ja. ADK hat native Model Context Protocol-Unterstützung, sodass Agenten sich mit jedem MCP-kompatiblen Tool-Server für externe Tools und Datenquellen verbinden können. Das macht ADK-Agenten interoperabel mit dem wachsenden MCP-Ökosystem. Hintergrundinformationen zum Protokoll gibt es in unserem MCP-Leitfaden.

Wie teste ich ADK-Agenten?

ADK enthält eingebaute Evaluatoren: ResponseEvaluator zum Prüfen der Ausgabequalität gegen erwartete Antworten, und TrajectoryEvaluator zum Verifizieren, dass der Agent die richtigen Tools in der richtigen Reihenfolge aufgerufen hat. Testfälle als JSON-Dateien schreiben, die Eingaben, erwartete Ausgaben und erwartete Tool-Aufruf-Sequenzen definieren, dann mit pytest ausführen.

Welche Python-Version benötigt Google ADK?

ADK erfordert Python 3.9 oder höher. Python 3.10+ wird für vollständige Typen-Hint-Unterstützung empfohlen, was wichtig ist, weil ADK Typen-Hints zur Generierung von Tool-Schemas nutzt. Python 3.11 oder 3.12 bieten auch spürbare Performance-Verbesserungen für Agenten-Workloads. Installation mit pip install google-adk.