Was ist Google ADK (Agent Development Kit)? Ein praktischer Leitfaden

Google ADK ist ein Open-Source-Framework zum Entwickeln, Evaluieren und Bereitstellen von KI-Agenten. Es treibt echte Agenten in Google-Produkten wie Agentspace an. Wenn Sie bereits Stacks wie das OpenAI Agents SDK geprüft haben, deckt ADK ähnliche Bereiche ab, ist aber eng mit Gemini und Vertex AI verzahnt. Dieser Leitfaden zeigt, wie ADK aufgebaut ist, wie Sie Agenten und Tools implementieren und wo Apidog beim Testen der APIs hilft, die Ihr Agent aufruft.

Apidog noch heute ausprobieren

Was Google ADK ist

ADK steht für Agent Development Kit. Google stellte es im April 2025 auf der Google Cloud Next als Open-Source-Toolkit für den gesamten Agenten-Lebenszyklus vor:

1. Agenten definieren
2. Tools anbinden
3. mehrere Agenten orchestrieren
4. Verhalten evaluieren
5. Agenten in Produktion bereitstellen

ADK startete mit Python. Google hat seitdem Java hinzugefügt; Unterstützung für Go und TypeScript soll folgen. Das Framework wird intern für Agenten in Agentspace und der Customer Engagement Suite verwendet. Es ist also nicht nur ein Demo-SDK, sondern auf produktive Workloads ausgelegt.

ADK ist modellunabhängig, aber für Google optimiert. Es funktioniert besonders gut mit Gemini und Modellen aus dem Vertex AI Model Garden. Über LiteLLM können Sie auch Anbieter wie Anthropic, Meta oder Mistral anbinden. Praktisch bedeutet das: Sie bekommen eine enge Gemini-Integration, ohne Ihr Agenten-Design hart an ein einzelnes Modell zu koppeln.

Wo ADK im Gemini- und Vertex-AI-Ökosystem sitzt

Trennen Sie beim Design drei Ebenen:

• Modell: Gemini oder ein anderes Modell über Vertex AI Model Garden oder LiteLLM übernimmt Reasoning und Textgenerierung.
• Framework: ADK ist die Code-Ebene für Agenten, Tools, Zustände und Multi-Agenten-Workflows.
• Runtime: Vertex AI Agent Engine ist die verwaltete Laufzeitumgebung für Produktion. Alternativ können Sie in Cloud Run oder einer beliebigen Container-Runtime bereitstellen.

ADK ist damit die entwicklerorientierte Schicht. Gemini liefert die Modellintelligenz, Vertex AI Agent Engine stellt eine skalierbare Runtime bereit. Sie können alle drei zusammen nutzen oder ADK lokal ausführen und woanders deployen.

Kernkonzepte

Die meisten ADK-Projekte bestehen aus denselben Bausteinen: Agenten, Tools, Runner, Evaluierung und Deployment.

Agenten

Die Grundeinheit ist ein LLM-gestützter Agent. In Python importieren Sie ihn aus google.adk.agents. Die Klasse heißt LlmAgent; Agent ist ein Alias dafür.

Ein minimaler Agent braucht:

• name
• model
• instruction
• tools

from google.adk.agents import Agent

def get_exchange_rate(base: str, target: str) -> dict:
    """Gibt den Wechselkurs zwischen zwei Währungen zurück."""
    # Hier würden Sie Ihre echte Devisen-API aufrufen.
    return {
        "base": base,
        "target": target,
        "rate": 1.08
    }

currency_agent = Agent(
    name="currency_exchange_agent",
    model="gemini-2.0-flash",
    instruction=(
        "Sie helfen Benutzern, zwischen Währungen umzurechnen. "
        "Bleiben Sie bei den Fakten und verwenden Sie verfügbare Tools."
    ),
    tools=[get_exchange_rate],
)

Das ist bereits ein funktionsfähiger einzelner Agent. Die instruction definiert sein Verhalten. Die Tool-Liste legt fest, welche Funktionen er aufrufen darf.

Tools

Tools sind die Schnittstelle zwischen Agent und Außenwelt. Ein Agent generiert nicht nur Text, sondern ruft Funktionen auf, die echte Arbeit erledigen: APIs abfragen, Daten validieren, Dateien erzeugen oder interne Services ansprechen.

In ADK kann eine normale Python-Funktion ein Tool sein:

def search_flights(origin: str, destination: str, date: str) -> dict:
    """Sucht verfügbare Flüge für Start, Ziel und Reisedatum."""
    # Hier REST-API aufrufen.
    return {
        "origin": origin,
        "destination": destination,
        "date": date,
        "options": []
    }

Achten Sie besonders auf:

• sprechende Funktionsnamen
• präzise Typ-Hinweise
• klare Docstrings
• stabile Rückgabeformate

Der Docstring ist nicht nur Dokumentation für Menschen. Er hilft dem Modell zu entscheiden, wann und wie das Tool verwendet werden soll.

ADK bringt außerdem integrierte Tools wie google_search und Code-Ausführung mit. Zusätzlich unterstützt es das Model Context Protocol (MCP), um externe Tool-Server anzubinden. Sie können auch LangChain- oder LlamaIndex-Komponenten umschließen oder einen anderen Agenten als Tool verwenden.

In produktiven Projekten rufen diese Tools oft REST-APIs auf. Genau diese API-Verträge sollten Sie separat testen und mocken.

Multi-Agenten-Systeme

Ein einzelner Agent reicht für viele Fälle aus. ADK ist aber für hierarchische Agenten-Systeme ausgelegt. Sie können spezialisierte Agenten bauen und über einen Koordinator verbinden.

ADK unterstützt Workflow-Agenten für deterministischere Abläufe:

• SequentialAgent: führt Unteragenten nacheinander aus
• ParallelAgent: führt Unteragenten parallel aus
• LoopAgent: wiederholt einen Ablauf, bis eine Bedingung erfüllt ist

Ein typisches Muster:

1. Koordinator analysiert die Nutzeranfrage.
2. Koordinator wählt den passenden Unteragenten.
3. Unteragent ruft ein Tool oder eine API auf.
4. Koordinator fasst Ergebnisse zusammen.

Runner

In Produktion rufen Sie einen Agenten nicht einfach direkt als Funktion auf. Der Runner ist ADKs Ausführungs-Engine. Er übernimmt:

• Sitzungsverwaltung
• Ereignisfluss
• Statusaktualisierung
• Modellaufrufe
• Tool-Aufrufe
• Koordination zwischen Agenten

Während der Entwicklung können Sie mit der CLI starten:

adk run

Das startet eine interaktive Terminalsitzung.

Für Debugging ist besonders hilfreich:

adk web

Damit öffnen Sie eine lokale Browser-Oberfläche, chatten mit Ihrem Agenten und prüfen Schritt für Schritt, welche Tools aufgerufen werden.

Evaluierung und Bereitstellung

ADK enthält einen Evaluierungsrahmen. Damit prüfen Sie nicht nur die finale Antwort, sondern auch erwartete Trajektorien: also welche Schritte, Tools und Zwischenentscheidungen ein Agent verwendet.

Das ist wichtig, weil sich Agentenverhalten ändern kann, wenn Sie Folgendes anpassen:

• Prompt
• Modell
• Tool-Beschreibung
• API-Antwortformat
• Routing zwischen Unteragenten

Für Deployment haben Sie zwei Hauptwege:

• Verwaltet: Vertex AI Agent Engine als skalierbare Runtime.
• Portabel: Agent in einen Container packen und z. B. in Cloud Run oder einer anderen Containerplattform ausführen.

Beispiel: kleiner Reiseplaner mit Unteragenten

Das folgende Beispiel zeigt ein einfaches Multi-Agenten-Setup. Ein Koordinator delegiert an zwei Spezialisten: einen Flug-Agenten und einen Hotel-Agenten.

from google.adk.agents import Agent

def search_flights(origin: str, destination: str, date: str) -> dict:
    """Sucht Flugoptionen für Start, Ziel und Datum."""
    # Hier echte Flug-API aufrufen.
    return {
        "origin": origin,
        "destination": destination,
        "date": date,
        "flights": []
    }

def search_hotels(destination: str, check_in: str, check_out: str) -> dict:
    """Sucht Hoteloptionen am Zielort für den angegebenen Zeitraum."""
    # Hier echte Hotel-API aufrufen.
    return {
        "destination": destination,
        "check_in": check_in,
        "check_out": check_out,
        "hotels": []
    }

flights = Agent(
    name="flight_agent",
    model="gemini-2.0-flash",
    instruction="Finden Sie Flugoptionen für die Route und Daten des Benutzers.",
    tools=[search_flights],
)

hotels = Agent(
    name="hotel_agent",
    model="gemini-2.0-flash",
    instruction="Finden Sie Hoteloptionen in der Nähe des Ziels.",
    tools=[search_hotels],
)

trip_planner = Agent(
    name="trip_planner",
    model="gemini-2.0-flash",
    instruction=(
        "Planen Sie eine Reise. "
        "Delegieren Sie die Flug- und Hotelsuche an Ihre Unteragenten."
    ),
    sub_agents=[flights, hotels],
)

Der Koordinator entscheidet, welcher Unteragent zuständig ist. Jeder Unteragent kapselt eine fachliche Aufgabe und ruft bei Bedarf seine API über ein Tool auf.

Für die Entwicklung:

adk web

Dann können Sie prüfen:

• ob der richtige Unteragent gewählt wird
• ob die Tool-Parameter korrekt sind
• ob die API-Antworten stabil verarbeitet werden
• ob der Koordinator die Ergebnisse sinnvoll zusammenführt

ADK vs. OpenAI Agents SDK

Beide Frameworks sind code-first und unterstützen Tools, Übergaben und Tracing. Der größte Unterschied liegt im Ökosystem.

Bereich	Google ADK	OpenAI Agents SDK
Standardmodell	Gemini über Vertex AI	OpenAI-Modelle
Andere Modelle	Vertex AI Model Garden, LiteLLM	LiteLLM und andere
Sprachen	Python, Java; Go und TypeScript sollen folgen	Python, JavaScript/TypeScript
Multi-Agenten	Unteragenten plus sequentielle, parallele und schleifenbasierte Workflow-Agenten	Agenten als Tools und Übergaben
Verwaltete Runtime	Vertex AI Agent Engine	Eigenverantwortlich
Tool-Protokoll	MCP, integrierte Tools, Funktions-Tools	MCP, Funktions-Tools

Wenn Ihr Stack bereits auf Google Cloud läuft, ist ADK mit Vertex AI naheliegend. Wenn Sie OpenAI-zentriert arbeiten, passt das OpenAI Agents SDK besser. Da beide MCP unterstützen, können Tool-Server in vielen Fällen gemeinsam genutzt werden.

Wann Sie ADK verwenden sollten

ADK passt gut, wenn:

• Sie auf Google Cloud entwickeln.
• Sie Gemini und Vertex AI Agent Engine nutzen möchten.
• Sie Multi-Agenten-Orchestrierung mit klaren Ablaufmustern brauchen.
• Sie Evaluierung direkt im Framework verankern wollen.
• Sie Modelle austauschbar halten möchten.
• Sie Vertex AI Model Garden oder LiteLLM als Ausweichpfade benötigen.

ADK ist weniger sinnvoll, wenn:

• ein einzelner Prompt mit ein oder zwei Funktionsaufrufen ausreicht
• Sie fest in einem anderen Modell-Ökosystem verankert sind
• Sie keine Multi-Agenten-Struktur oder Evaluierung benötigen

Ein Agenten-Framework bringt Struktur. Diese Struktur lohnt sich vor allem, wenn Ihr Use Case komplex genug ist.

Wo Apidog passt: APIs testen und mocken, die Ihr Agent aufruft

ADK orchestriert Agenten. Es validiert aber nicht automatisch die externen APIs, von denen Ihre Tools abhängen. Genau dort sollten Sie früh testen.

Jedes nützliche Tool ruft irgendwann etwas auf:

• einen LLM-Endpunkt
• eine Zahlungs-API
• einen internen Microservice
• eine Drittanbieter-Datenquelle
• eine eigene Backend-API

Wenn diese API ein unerwartetes Format zurückgibt, arbeitet Ihr Agent mit schlechten Eingaben. Das Ergebnis ist oft schwer zu debuggen, weil der Fehler erst später im Agenten-Transkript sichtbar wird.

Wichtig: Apidog ist kein Agenten-Framework und ersetzt ADK nicht. Es sitzt eine Ebene darunter: bei den APIs, die Ihre Tools aufrufen.

Praktischer Workflow mit ADK und Apidog

1. API-Vertrag definieren

Bevor Sie ein Tool in ADK verwenden, definieren Sie den erwarteten Request und Response der API.

Beispiel für eine Flug-API:

{
  "origin": "BER",
  "destination": "MAD",
  "date": "2026-07-10"
}

Erwartete Antwort:

{
  "flights": [
    {
      "airline": "Example Air",
      "departure": "2026-07-10T08:00:00Z",
      "arrival": "2026-07-10T11:00:00Z",
      "price": 220
    }
  ]
}

2. Endpunkt mocken

Erstellen Sie eine Mock-API, bevor die echte API stabil ist. So können Sie den Agenten entwickeln, ohne:

• Tokens zu verbrennen
• Rate Limits zu treffen
• instabile Testdaten zu verwenden
• echte Zahlungen oder Buchungen auszulösen

Ihr ADK-Tool ruft dann zunächst den Mock-Endpunkt auf:

import requests

def search_flights(origin: str, destination: str, date: str) -> dict:
    """Sucht Flugoptionen für Start, Ziel und Datum."""
    response = requests.post(
        "https://your-mock-endpoint.example.com/flights/search",
        json={
            "origin": origin,
            "destination": destination,
            "date": date
        },
        timeout=10
    )
    response.raise_for_status()
    return response.json()

3. Response-Form prüfen

Nutzen Sie API-Assertions, um sicherzustellen, dass die API genau die Felder liefert, die Ihr Agent erwartet.

Prüfen Sie zum Beispiel:

• flights existiert
• flights ist ein Array
• jedes Element enthält airline, departure, arrival, price
• price ist numerisch
• Fehlerfälle liefern ein konsistentes Format

So fangen Sie Vertragsbrüche im API-Test ab, nicht erst im Agentenlauf.

4. Fehlerfälle simulieren

Agenten müssen mit schlechten Antworten umgehen können. Mocken Sie deshalb gezielt:

• leere Ergebnisse
• Timeouts
• 401/403-Fehler
• 429 Rate Limits
• 500-Fehler
• unvollständige JSON-Antworten

Dann prüfen Sie in adk web, ob Ihr Agent sinnvoll reagiert:

• fragt er nach fehlenden Parametern?
• erklärt er API-Probleme verständlich?
• vermeidet er Halluzinationen?
• bricht er kontrolliert ab?

5. Umgebungen trennen

Verwalten Sie Entwicklungs-, Staging- und Produktionsschlüssel in Apidog-Umgebungen. Dadurch kann derselbe Tool-Code gegen unterschiedliche Backends laufen, ohne Secrets hart im Code zu speichern.

Wenn Sie tiefer in das Testen von Agenten-Tools einsteigen möchten, lesen Sie den Leitfaden zum Testen der Tool-Aufrufe eines KI-Agenten. Sie können Apidog herunterladen und einen einzelnen Endpunkt in wenigen Minuten mocken.

Häufig gestellte Fragen

Ist Google ADK kostenlos und Open Source?

Ja. ADK ist Open Source in einem Apache-lizenzierten Repository auf GitHub. Sie können es kostenlos lokal ausführen. Kosten entstehen für die Modelle, die Sie aufrufen, und für verwaltete Laufzeitumgebungen wie Vertex AI Agent Engine. Das Framework selbst ist kostenlos.

Funktioniert ADK nur mit Gemini?

Nein. ADK ist für Gemini und Vertex AI optimiert, aber modellunabhängig. Über Vertex AI Model Garden und LiteLLM können Sie auch Modelle von Anbietern wie Anthropic, Meta oder Mistral verwenden. Gemini ist die naheliegende Standardeinstellung, aber keine harte Voraussetzung.

Welche Sprachen unterstützt ADK?

Python war zuerst verfügbar und ist weiterhin die sicherste Wahl, wenn Sie die breiteste Funktionsabdeckung möchten. Google hat seitdem Java hinzugefügt. Unterstützung für Go und TypeScript soll folgen.

Wie teste ich die APIs, von denen mein ADK-Agent abhängt?

Testen Sie diese APIs separat vom Agenten. Mocken Sie LLM- oder Tool-Endpunkte, führen Sie API-Assertions aus und simulieren Sie Fehlerfälle. Apidog deckt diese Schritte ab. Der Leitfaden zum Testen der ChatGPT-API zeigt dasselbe Muster für einen LLM-Endpunkt, den Ihre Tools aufrufen könnten.

Fazit

Google ADK bietet eine produktionsorientierte Grundlage für Agenten und Multi-Agenten-Systeme. Starten Sie klein: ein Agent, klare Instructions, wenige Tools. Nutzen Sie dann adk web, um Tool-Aufrufe und Routing zu debuggen. Wenn Ihr Use Case wächst, ergänzen Sie Unteragenten, Evaluierung und eine passende Runtime wie Vertex AI Agent Engine.

Der kritische Teil liegt oft unterhalb des Agenten: bei den APIs, die Ihre Tools aufrufen. Mocken Sie diese Endpunkte, prüfen Sie Antwortformate und testen Sie Fehlerfälle früh. Genau diese API-Ebene übernimmt Apidog — und dort beginnt häufig die Stabilität Ihres Agenten.