Google ADK-Agenten: Vom einzelnen Gemini-Agenten bis zu Cloud Run-Deployments

Große Sprachmodelle haben verändert, wie Menschen Software nutzen, doch der nächste Schritt hat weniger mit intelligenteren Chats zu tun und mehr mit Systemen, die logisch denken, Tools aufrufen, zusammenarbeiten und ganzheitliche Arbeitsabläufe eigenständig ausführen können. Das ist das Gebiet der agierenden KI. Während eine klassische Anwendung eine Anfrage sendet und auf eine Antwort wartet, entscheidet ein Agent, was als Nächstes getan werden soll: Er kann eine API aufrufen, Informationen abrufen, eine Unteraufgabe an einen Spezialisten weiterleiten oder ein strukturiertes Ergebnis zurückgeben.

Googles Agent Development Kit (ADK) ist ein praktisches Framework zum Erlernen dieses Themas. Es ermöglicht es Ihnen, Agenten auf Gemini-Modellen zu erstellen, Python-Funktionen als Tools bereitzustellen, mehrere Agenten zu koordinieren und sie auf Google Cloud zu deployen. Die folgenden Abschnitte führen von einem einzelnen Agenten bis hin zur Cloud-Deployment-Möglichkeit.

Von Anfragen zu Agenten

Traditionelle LLM-Anwendungen funktionieren nach dem Prinzip von Prompt und Antwort. Man stellt eine Frage, das Modell antwortet – und das ist’s. In einer agierenden Architektur befindet sich das Modell innerhalb eines größeren Ausführungssystems. Es kann Ziele verfolgen, Werkzeuge auswählen, mit APIs kommunizieren und mit anderen Agenten zusammenarbeiten. Die Idee dahinter ist, dass ein Agent mehr ist als nur ein Prompt: Es handelt sich um einen von einem Sprachmodell gesteuerten Softwarekomponenten.

Eine ADK-Anwendung konzentriert sich auf einen root_agent. Die kleinste Version sieht so aus:

from google.adk.agents import Agent

root_agent = Agent(
    name="assistant",
    model="gemini-2.5-flash",
    instruction="You are a helpful assistant"
)

Auch dies ist ein funktionsfähiger Agent mit Namen, Verhalten, einem Modell und der Fähigkeit zum Ausführen. Er kann chatten, kann aber nichts außerhalb von sich selbst berühren, bis er Werkzeuge erhält.

Werkzeuge

Was künstliche Intelligenz in Form von Agenten ausmacht, ist der Einsatz von Werkzeugen. Ohne Werkzeuge erzeugt ein Modell nur Text, während ein Agent mit ihnen echte Logik ausführen kann. In ADK wird eine einfache Python-Funktion sofort zu einem Werkzeug, sobald sie in die Konfiguration des Agents übergeben wird. Ein Rechenagent zeigt, wie das funktioniert:

from google.adk.agents import Agent


def calculator(a: float, b: float, operation: str) -> float:
    if operation == "add":
        return a + b

    if operation == "subtract":
        return a - b

    if operation == "multiply":
        return a * b

    if operation == "divide":
        if b == 0:
            raise Exception("Cannot divide by zero")

        return a / b

    raise Exception("Unsupported operation")


root_agent = Agent(
    name="assistant",
    model="gemini-2.5-flash",
    instruction=(
        "You are a helpful assistant with calculator capabilities. "
        "Use the calculator tool for arithmetic. "
        "Supported operations are add, subtract, multiply, divide."
    ),
    tools=[calculator]
)

Hier versteht das Modell die Anfrage, überlässt aber anstelle dessen, selbst Rechenoperationen durchzuführen, die genaue Berechnung der Funktion. Das LLM übernimmt das Denken, während das Tool die Ausführung vornimmt. Diese Trennung bildet die Grundlage für solide Unternehmensarchitekturen.

Reale Systeme verlassen sich selten auf ein einziges Tool. Ein Assistent kann API-Anfragen stellen, Daten umwandeln, in einer Datenbank suchen, Dokumente abrufen, Richtlinien überprüfen und Ergebnisse zusammenfassen. Ein mehrfachfunktionales Agent kombiniert dabei Rechenoperationen, Einheitenumwandlungen und Wetterabfragen:

from google.adk.agents import Agent


def calculator(a: float, b: float, operation: str) -> float:
    if operation == "add":
        return a + b

    if operation == "subtract":
        return a - b

    if operation == "multiply":
        return a * b

    if operation == "divide":
        if b == 0:
            raise ValueError("Cannot divide by zero.")

        return a / b

    raise ValueError("Unsupported operation.")


def convert_units(value: float, from_unit: str, to_unit: str) -> float:
    from_unit = from_unit.lower()
    to_unit = to_unit.lower()

    if from_unit == "km" and to_unit == "miles":
        return value * 0.621371

    if from_unit == "miles" and to_unit == "km":
        return value / 0.621371

    if from_unit == "celsius" and to_unit == "fahrenheit":
        return value * 9 / 5 + 32

    if from_unit == "fahrenheit" and to_unit == "celsius":
        return (value - 32) * 5 / 9

    raise ValueError("Unsupported unit conversion.")


def get_weather_mock(city: str) -> dict:
    weather_data = {
        "bucharest": {
            "temperature_celsius": 23,
            "condition": "sunny",
            "wind_speed_kmh": 10,
        },
        "london": {
            "temperature_celsius": 16,
            "condition": "rain",
            "wind_speed_kmh": 18,
        },
    }

    key = city.lower()

    if key not in weather_data:
        return {
            "city": city,
            "error": "Weather data not available."
        }

    return {
        "city": city,
        **weather_data[key],
    }


root_agent = Agent(
    name="multi_tool_agent",
    model="gemini-2.5-flash",
    instruction=(
        "You are a practical assistant. "
        "Use the available tools when the user asks for calculations, "
        "unit conversions, or weather information."
    ),
    tools=[
        calculator,
        convert_units,
        get_weather_mock,
    ],
)

Der Agent fungiert nun als Orchesterer. Er wählt je nach Anfrage in Echtzeit die passenden Tools aus, und der Benutzer muss nie angeben, welches Tool verwendet werden soll.

Agenten als Tools anderer Agenten

ADK ermöglicht es einem Agenten, als Tool für einen anderen zu dienen, was die Spezialisierung fördert. Anstelle eines riesigen Prompts, der versucht, alles abzudecken, werden kleinere Agenten mit spezifischen Aufgaben erstellt. Ein Reiseplaner, der aus mehreren Agenten zusammengesetzt ist, veranschaulicht dies:

from google.adk.agents import LlmAgent
from google.adk.tools import google_search
from google.adk.tools import google_maps_grounding
from google.adk.tools.agent_tool import AgentTool


routing_agent = LlmAgent(
    name="routing_agent",
    model="gemini-2.5-pro",
    instruction="""
    You are a routing agent.
    Use google_maps_grounding to estimate routes and travel times.
    """,
    tools=[google_maps_grounding],
)


discovery_agent = LlmAgent(
    name="discovery_agent",
    model="gemini-2.5-pro",
    instruction="""
    You are a travel discovery agent.
    Use Google Search to find interesting places.
    """,
    tools=[google_search]
)


composer_agent = LlmAgent(
    name="composer_agent",
    model="gemini-2.5-pro",
    instruction="""
    Write a friendly travel itinerary based on the collected information.
    """,
    tools=[]
)


root_agent = LlmAgent(
    name="travel_agent",
    model="gemini-2.5-pro",
    instruction="""
    You are a travel assistant.
    Coordinate discovery, routing, and itinerary composition.
    """,
    tools=[
        AgentTool(discovery_agent),
        AgentTool(routing_agent),
        AgentTool(composer_agent)
    ]
)

Der Root-Agent fungiert als Orchesterer ohne feste Arbeitsabläufe, und jeder Sub-Agent ist ein Spezialist, der in beliebiger Reihenfolge gerufen werden kann. Ein solches System ist einfacher zu warten, zu skalieren und zu verstehen, was der Entwicklungslinie vieler Unternehmens-KI-Designs entspricht.

Gestrukturierte Abläufe

Nicht jeder Prozess sollte vollständig autonom sein, da Geschäftsprozesse oft Struktur benötigen. Eine gängige Struktur besteht aus Planung, anschließender Ausführung und Berichterstattung. ADK umsetzt dies mit sequenziellen Agenten, wie in dieser Kette aus Planer, Ausführender und Berichterstatter:

from google.adk.agents import Agent, SequentialAgent
from google.adk.tools import AgentTool


planner_agent = Agent(
    name="planner_agent",
    model="gemini-2.5-flash",
    instruction="""
    Read the user request and create a short execution plan.
    """
)


executor_agent = Agent(
    name="executor_agent",
    model="gemini-2.5-flash",
    instruction="""
    Execute the plan and delegate specialist work.
    """,
    tools=[]
)


report_agent = Agent(
    name="report_agent",
    model="gemini-2.5-flash",
    instruction="""
    Produce the final report based on execution results.
    """
)


root_agent = SequentialAgent(
    name="planner_executor_report_workflow",
    sub_agents=[
        planner_agent,
        executor_agent,
        report_agent,
    ],
)

Lokalentwicklung

ADKs lokaler Loop ist schnell. Zunächst legt eine .env-Datei das Google Cloud-Projekt, den Standort sowie die Verwendung von Vertex AI fest:

GOOGLE_CLOUD_PROJECT=PROJECT_ID
GOOGLE_CLOUD_LOCATION=us-central1
GOOGLE_GENAI_USE_VERTEXAI=True

Dann startet ein Befehl eine lokale Web-Oberfläche, um die Agenten interaktiv auszuprobieren:

adk web

Der schnelle Zyklus eignet sich gut für Experimente.

Einbetten in Cloud Run

Lokaler Test reicht nur bis zu einem gewissen Punkt, und Cloud Run ist einer der einfachsten Wege in die Produktion. Für den ersten Agenten oben reicht ein kurzer Dockerfile aus:

FROM python:3.11-slim

WORKDIR /app

COPY . .

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

CMD ["adk", "web", "--host", "0.0.0.0", "--port", "8080"]

Deployen aus der Quelle mit gcloud:

gcloud run deploy simple-agent \
  --source . \
  --region us-central1 \
  --allow-unauthenticated \
  --set-env-vars GOOGLE_GENAI_USE_VERTEXAI=TRUE \
  --set-env-vars GOOGLE_CLOUD_PROJECT=PROJECT_ID \
  --set-env-vars GOOGLE_CLOUD_LOCATION=us-central1

Suchen Sie anschließend die Service-URL heraus:

gcloud run services describe simple-agent \
  --region us-central1 \
  --format='value(status.url)'

Durch das Öffnen dieser URL wird die ADK-Schnittstelle direkt aus Cloud Run bereitgestellt. Das Ergebnis ist ein einsetzbarer KI-Dienst, kein nur zum Ausprobieren geeignetes Notebook-Tool.

Ein API mit FastAPI bereitstellen

Manchmal eignet sich eine HTTP-API besser als eine Browser-Oberfläche, und ADK funktioniert hervorragend mit FastAPI. Ein minimales main.py, das den Wetter-Tool-Agent umschließt, sieht wie folgt aus:

import uuid

from fastapi import FastAPI
from pydantic import BaseModel

from google.adk.runners import Runner
from google.adk.sessions import InMemorySessionService
from google.genai import types

from agent import root_agent


app = FastAPI()

session_service = InMemorySessionService()

runner = Runner(
    agent=root_agent,
    app_name="weather_agent_service",
    session_service=session_service,
)


class QueryRequest(BaseModel):
    message: str


@app.post("/weather")
async def weather(request: QueryRequest):

    user_id = "api_user"
    session_id = str(uuid.uuid4())

    await session_service.create_session(
        app_name="weather_agent_service",
        user_id=user_id,
        session_id=session_id,
    )

    content = types.Content(
        role="user",
        parts=[
            types.Part(text=request.message)
        ],
    )

    final_answer = ""

    async for event in runner.run_async(
        user_id=user_id,
        session_id=session_id,
        new_message=content,
    ):
        if event.is_final_response():
            final_answer = event.content.parts[0].text

    return {
        "response": final_answer
    }

Um es zu deployen, ist eine leicht abgewandelte Dockerfile erforderlich:

FROM python:3.11-slim

WORKDIR /app

COPY . .

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

CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8080"]

Agent Engine

ADK kann auch auf Googles Agent Engine bereitgestellt werden, einer verwalteten Laufzeitumgebung, die für die Ausführung von Enterprise-Agenten entwickelt wurde. Beginnen Sie damit, die erforderlichen APIs zu aktivieren:

gcloud services enable \
  aiplatform.googleapis.com \
  storage.googleapis.com

Nächste Schritt: Erstellen Sie einen Staging-Container:

export STAGING_BUCKET="gs://${PROJECT_ID}-agent-staging"

gsutil mb -l us-central1 $STAGING_BUCKET

Dann deployen Sie den Agenten:

adk deploy agent_engine \
--project=$PROJECT_ID \
--region=us-central1 \
--staging_bucket=$STAGING_BUCKET \
basic_agent

Dies erzeugt eine verwaltete Reasoning-Engine-Ressource in Google Cloud, und der Prozess ist unkompliziert, wenn man bedenkt, was im Hintergrund abläuft.

Warum das wichtig ist

Agentic AI ist eine andere Art, Software um Sprachmodelle herum zu entwickeln – es geht dabei nicht nur um bessere Anfragen. Agenten denken nach, nutzen Werkzeuge, koordinieren Arbeitsabläufe und arbeiten mit externen Systemen zusammen, anstatt isolierte Antworten zu liefern.

ADK ist ein gutes Lerninstrument, da es diese Konzepte schrittweise näherbringt. Man beginnt mit einem Gemini-Agenten, fügt Werkzeuge hinzu, verbindet mehrere Agenten miteinander und gelangt schließlich zu unternehmensweiten Arbeitsabläufen mit RAG, MCP-Integrationen, Bewertungspipelines und Bereitstellung auf GCP. Die gleichen Prinzipien gelten vom Rechnerbeispiel bis hin zu einer mehragentigen Unternehmensumgebung: Denken, Delegation, Orchestrierung und Ausführung. Software entwickelt sich von der Beantwortung von Fragen hin zur Nutzung innerhalb echter Anwendungen.