Google ADK Vollständiger Leitfaden 2026: Intelligente KI-Agenten mit Code entwickeln

title: Google ADK Vollständiger Leitfaden 2026: Intelligente KI-Agenten mit Code entwickeln date: 2026-03-27 authors: [kevinpeng] slug: google-adk-agent-development-kit-2026-de categories: - KI-Assistenten tags: - Google ADK - KI-Agent - Open-Source-Framework - Python cover: https://res.makeronsite.com/freeaitool.com/047-google-adk-agent-development-kit-2026-cover.webp description: Google ADK (Agent Development Kit) 2026 vollständiges Tutorial: Installation und Konfiguration, Kernkonzepte, Code-Beispiele, Best Practices, um Entwicklern zu helfen, schnell produktionsreife KI-Agent-Anwendungen zu erstellen. lang: de

Was ist Google ADK?

Google ADK (Agent Development Kit) ist ein quelloffenes KI-Agent-Entwicklungsframework von Google, das für Entwickler konzipiert ist, die KI-Agenten in reale Anwendungen integrieren möchten. Im Gegensatz zu Frameworks wie LangChain und LlamaIndex verfolgt ADK einen „Code-First"-Ansatz, der das Verhalten von Agenten so vorhersagbar und testbar macht wie herkömmliche Software.

Kernfunktionen

Code-First: Agentenverhalten mit purem Python definieren, keine komplexen YAML-Konfigurationen erforderlich
Typsicher: Volle Nutzung von Python-Typhinweisen mit IDE-Autovervollständigung und Fehlerprüfung
Testbarkeit: Agentenlogik kann wie normale Funktionen unit-getestet werden
Produktionsreif: Eingebaute Protokollierung, Überwachung, Fehlerbehandlung und weitere Produktionsfunktionen
Multi-Modell-Unterstützung: Unterstützt Gemini, GPT-4, Claude und andere gängige große Sprachmodelle

Anwendungsszenarien

Kundenservice-Chatbots
Automatisierte Workflow-Assistenten
Datenanalyse und Berichtserstellung
Code-Review und Programmierunterstützung
Unternehmensinterne Wissens-QA-Systeme

Installation und Konfiguration

Systemanforderungen

Python 3.10 oder höher
pip-Paketmanager
Google Cloud-Konto (bei Verwendung des Gemini-Modells)

Installationsschritte

# Virtuelle Umgebung erstellen (empfohlen)
python3 -m venv adk-env
source adk-env/bin/activate  # Linux/macOS
# adk-env\Scripts\activate  # Windows

# Google ADK installieren
pip install google-adk

# Zusätzliche Abhängigkeiten installieren (nach Bedarf)
pip install google-adk[cli]  # Enthält CLI-Tools
pip install google-adk[testing]  # Enthält Test-Tools

API-Schlüssel konfigurieren

# Methode 1: Umgebungsvariable verwenden (für Entwicklung empfohlen)
export GEMINI_API_KEY="your-api-key-here"

# Methode 2: Google Cloud-Anmeldungsdatei verwenden
export GOOGLE_APPLICATION_CREDENTIALS="/path/to/service-account.json"

# Methode 3: Direkt im Code konfigurieren (für Produktion nicht empfohlen)

Kernkonzepte

1. Agent (Agent)

Der Agent ist die Kernkomponente von ADK und empfängt Benutzereingaben, ruft Werkzeuge auf und generiert Antworten.

from google.adk import Agent
from google.adk.models import Gemini

# Grundlegenden Agent erstellen
agent = Agent(
    name="customer_support",
    model=Gemini(model="gemini-2.0-flash"),
    instruction="Du bist ein professioneller Kundenservice-Assistent, der Benutzern bei Produktproblemen hilft.",
)

2. Tools (Werkzeuge)

Werkzeuge sind externe Funktionen, die der Agent aufrufen kann, um konkrete Aufgaben auszuführen.

from google.adk import Tool
from google.adk.tools import FunctionTool

# Werkzeugfunktion definieren
def search_knowledge_base(query: str) -> str:
    """Relevante Informationen aus der Wissensdatenbank suchen"""
    # Die tatsächliche Implementierung ruft eine Datenbank oder API auf
    return f"Suchergebnisse für '{query}'..."

# Werkzeug erstellen
search_tool = FunctionTool(
    func=search_knowledge_base,
    name="search_kb",
    description="Produktdatenbank durchsuchen",
)

# Werkzeug zum Agent hinzufügen
agent.tools = [search_tool]

3. Sessions (Sitzungen)

Sitzungen verwalten den Interaktionsverlauf zwischen Benutzer und Agent und unterstützen mehrstufige Gespräche.

from google.adk import Session

# Sitzung erstellen
session = Session(
    agent=agent,
    user_id="user_123",
)

# Nachricht senden
response = await session.send("Mein Produkt startet nicht, was soll ich tun?")
print(response.text)

4. Events (Ereignisse)

Das Ereignissystem unterstützt asynchrone Nachrichtenverarbeitung und gestreamte Antworten.

from google.adk import Event

async def handle_event(event: Event):
    if event.type == "user_message":
        response = await session.send(event.content)
        await event.reply(response.text)

Praxisbeispiele

Beispiel 1: Einfacher QA-Bot

from google.adk import Agent, Session, Runner
from google.adk.models import Gemini

# Agent erstellen
agent = Agent(
    name="faq_bot",
    model=Gemini(model="gemini-2.0-flash"),
    instruction="""Du bist ein FAQ-Bot, der Fragen zu Produkten beantwortet.
    - Antworte kurz und verständlich
    - Wenn du die Antwort nicht weißt, sag es ehrlich
    - Gib relevante Hilfeempfehlungen""",
)

# Interaktive Sitzung starten
async def main():
    runner = Runner(agent=agent)
    await runner.run_interactive()

# python3 faq_bot.py

Beispiel 2: Datenanalyse-Assistent mit Werkzeugen

from google.adk import Agent, Tool
from google.adk.tools import FunctionTool
from google.adk.models import Gemini
import pandas as pd

# Datenanalyse-Werkzeuge definieren
def load_csv(file_path: str) -> dict:
    """CSV-Datei laden und grundlegende Informationen zurückgeben"""
    df = pd.read_csv(file_path)
    return {
        "rows": len(df),
        "columns": list(df.columns),
        "dtypes": df.dtypes.astype(str).to_dict(),
    }

def calculate_stats(file_path: str, column: str) -> dict:
    """Statistische Informationen für eine bestimmte Spalte berechnen"""
    df = pd.read_csv(file_path)
    numeric_col = pd.to_numeric(df[column], errors="coerce")
    return {
        "mean": float(numeric_col.mean()),
        "median": float(numeric_col.median()),
        "std": float(numeric_col.std()),
        "min": float(numeric_col.min()),
        "max": float(numeric_col.max()),
    }

# Werkzeuge erstellen
tools = [
    FunctionTool(func=load_csv, name="load_csv", description="CSV-Datei laden"),
    FunctionTool(func=calculate_stats, name="calc_stats", description="Statistiken berechnen"),
]

# Agent erstellen
agent = Agent(
    name="data_analyst",
    model=Gemini(model="gemini-2.0-flash"),
    instruction="Du bist ein Datenanalyse-Assistent, der Benutzern bei der Analyse von CSV-Datendateien hilft.",
    tools=tools,
)

Beispiel 3: Multi-Agent-Kooperationssystem

from google.adk import Agent, Runner
from google.adk.models import Gemini

# Mehrere spezialisierte Agenten erstellen
researcher = Agent(
    name="researcher",
    model=Gemini(model="gemini-2.0-flash"),
    instruction="Du bist für die Informationsbeschaffung und Forschung zuständig und lieferst detaillierte Fakten und Daten.",
)

writer = Agent(
    name="writer",
    model=Gemini(model="gemini-2.0-flash"),
    instruction="Du bist dafür zuständig, Forschungsergebnisse in einen strukturierten und gut lesbaren Bericht zusammenzufassen.",
)

reviewer = Agent(
    name="reviewer",
    model=Gemini(model="gemini-2.0-flash"),
    instruction="Du überprüfst die Qualität des Berichts und stellst Genauigkeit und Vollständigkeit sicher.",
)

# Mehrere Agenten mit einem Workflow orchestrieren
async def collaborative_workflow(user_query: str):
    # Forschungsphase
    research_result = await researcher.run(user_query)

    # Schreibphase
    draft = await writer.run(f"Verfasse einen Bericht basierend auf folgenden Forschungsergebnissen: {research_result}")

    # Überprüfungsphase
    final_report = await reviewer.run(f"Überprüfe und verbessere den folgenden Bericht: {draft}")

    return final_report

Erweiterte Funktionen

Gestreamte Antworten

from google.adk import Agent, Session
from google.adk.models import Gemini

agent = Agent(
    name="streaming_bot",
    model=Gemini(model="gemini-2.0-flash"),
)

session = Session(agent=agent)

# Gestreamte Antwort verarbeiten
async for chunk in session.send_stream("Erzähle eine Geschichte über KI"):
    print(chunk.text, end="", flush=True)

Benutzerdefinierte Middleware

from google.adk import Middleware

class LoggingMiddleware(Middleware):
    """Protokollierungs-Middleware, die alle Anfragen und Antworten protokolliert"""

    async def on_request(self, request):
        print(f"[REQUEST] {request.user_id}: {request.content}")
        return request

    async def on_response(self, response):
        print(f"[RESPONSE] {response.text[:100]}...")
        return response

# Middleware hinzufügen
agent.middleware = [LoggingMiddleware()]

Fehlerbehandlung und Wiederholungsversuche

from google.adk import Agent
from google.adk.models import Gemini
from google.adk.retry import RetryConfig

agent = Agent(
    name="robust_bot",
    model=Gemini(model="gemini-2.0-flash"),
    retry_config=RetryConfig(
        max_retries=3,
        retry_delay=1.0,
        retry_on=[TimeoutError, ConnectionError],
    ),
)

Best Practices

1. Prompt-Engineering

# Richtig: Klare, spezifische Anweisungen
agent = Agent(
    instruction="""Du bist ein professioneller technischer Support-Assistent.

    Antwortregeln:
    1. Zuerst bestätigen, dass du das Problem des Benutzers verstanden hast
    2. Schritt-für-Schritt-Lösung anbieten
    3. Bei komplexen Problemen Kontakt zum menschlichen Support empfehlen
    4. Freundlichen und professionellen Ton beibehalten""",
)

# Vermeiden: Vage, allgemeine Anweisungen
agent = Agent(
    instruction="Benutzern bei der Lösung ihrer Probleme helfen",  # Zu vage
)

2. Werkzeug-Design

# Richtig: Einzelverantwortung, klare Dokumentation
def get_order_status(order_id: str) -> dict:
    """
    Bestellstatus abfragen

    Args:
        order_id: Bestellnummer (Format: ORD-XXXXXX)

    Returns:
        Dictionary mit Informationen zu status, estimated_delivery etc.
    """
    pass

# Vermeiden: Multifunktional, zu viele Parameter
def handle_order(action: str, order_id: str, user_id: str, 
                 items: list, address: dict, payment: dict) -> dict:
    # Zu komplex, schwer wartbar
    pass

3. Teststrategie

import pytest
from google.adk import Agent, Session

@pytest.fixture
def test_agent():
    return Agent(
        name="test_bot",
        model=Gemini(model="gemini-2.0-flash"),
        instruction="Du bist ein Test-Assistent",
    )

@pytest.mark.asyncio
async def test_agent_response(test_agent):
    session = Session(agent=test_agent)
    response = await session.send("Hallo")
    assert response.text is not None
    assert len(response.text) > 0

4. Leistungsoptimierung

# Verbindungspool verwenden
from google.adk.models import Gemini

model = Gemini(
    model="gemini-2.0-flash",
    max_concurrent_requests=10,
    timeout=30.0,
)

# Häufige Antworten zwischenspeichern
from functools import lru_cache

@lru_cache(maxsize=100)
def get_faq_answer(question_hash: str) -> str:
    # Cache-Logik
    pass

Bereitstellungsleitfaden

Lokaler Entwicklungsserver

from google.adk import Agent, Runner
from google.adk.models import Gemini

agent = Agent(
    name="web_bot",
    model=Gemini(model="gemini-2.0-flash"),
)

# Webserver starten
runner = Runner(agent=agent)
runner.serve(host="0.0.0.0", port=8000)

# Zugriff unter http://localhost:8000

Docker-Bereitstellung

FROM python:3.11-slim

WORKDIR /app

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY . .

EXPOSE 8000

CMD ["python", "main.py"]

Google Cloud Run

# cloud-run.yaml
apiVersion: serving.knative.dev/v1
kind: Service
metadata:
  name: adk-agent
spec:
  template:
    spec:
      containers:
      - image: gcr.io/your-project/adk-agent
        env:
        - name: GEMINI_API_KEY
          valueFrom:
            secretKeyRef:
              name: api-keys
              key: gemini

Häufig gestellte Fragen

F1: Was ist der Unterschied zwischen ADK und LangChain?

A: ADK legt Wert auf Code-First und Typsicherheit und ist für Entwickler mit Programmiererfahrung geeignet. LangChain bietet umfangreiche vorgefertigte Komponenten und YAML-Konfiguration und ist für schnelles Prototyping geeignet.

F2: Welche großen Sprachmodelle werden unterstützt?

A: Die Google Gemini-Modellreihe wird nativ unterstützt. Über benutzerdefinierte Provider können auch OpenAI GPT, Anthropic Claude, lokale Modelle und andere integriert werden.

F3: Wie debuggt man das Agentenverhalten?

A: Verwende den eingebauten Debug-Modus von ADK:

from google.adk import Runner

runner = Runner(agent=agent, debug=True)
# Detaillierte Protokolle werden in der Konsole ausgegeben

F4: Was muss man in der Produktionsumgebung beachten?

A: - API-Schlüssel mit Umgebungsvariablen verwalten - Angemessene Ratenbegrenzungen konfigurieren - Protokollierung und Überwachung implementieren - Fehlerbehandlung und Wiederholungsmechanismen hinzufügen - Ausreichende Lasttests durchführen

Zusammenfassung

Google ADK bietet Entwicklern ein leistungsstarkes und flexibles Werkzeug zum Erstellen produktionsreifer KI-Agent-Anwendungen. Durch den Code-First-Ansatz kommt die Agentenentwicklung herkömmlichen Softwareentwicklungspraktiken näher, was Tests, Wartung und Erweiterung erleichtert.

Nächste Schritte

Die offizielle Dokumentation lesen
Das GitHub-Beispiel-Repository ansehen
Der Entwickler-Community beitreten
Das erste eigene Agent-Projekt entwickeln

Ressourcen: