Der Aufbau produktionsbereiter KI-Systeme erfordert einen Wandel von der einfachen Eingabeaufforderung zur strukturierten Orchestrierung. Mit dem Google Agent Development Kit (ADK) Und PythonSie können robuste Agenten erstellen, die komplexe Überlegungen und Zustandsverwaltung übernehmen.

In diesem Beitrag, Ich werde Sie durch die Kernkonzepte des ADK führen: Von der Definition Ihres ersten Agenten bis zur Bereitstellung als produktionsbereite API mithilfe von FastAPI.

Was ist ein KI-Agent??

Im Gegensatz zu einem Standard-LLM, das einfach Text basierend auf einer Eingabeaufforderung generiert, Ein KI-Agent umfasst Folgendes Argumentation und Entscheidungslogik. Es kann Benutzeranfragen interpretieren, entscheiden, welche Maßnahmen ergriffen werden sollen, und mit Werkzeugen oder anderen Komponenten interagieren, um eine Aufgabe zu erledigen.
In der Praxis, ein Agent kann:

• Grund: Interpretieren Sie die Absicht des Benutzers und verstehen Sie die Einschränkungen in der Anfrage.
• Akt: Rufen Sie externe Tools auf, APIs, oder Funktionen zum Abrufen von Informationen oder zum Ausführen von Vorgängen.
• Zusammenarbeiten: Arbeiten Sie mit anderen spezialisierten Agenten zusammen, um komplexere Aufgaben zu lösen.

Dies macht Agenten besonders nützlich für den Bau strukturiert, mehrstufige KI-Anwendungen.

Unser Anwendungsfall

In diesem Beispiel erstellen wir eines Reiseplanungsagent das auf Benutzeranfragen zu Reisen und Reisezielen antworten kann. Der Agent bearbeitet die Anfrage des Benutzers, generiert relevante Reisevorschläge und strukturiert die Reaktion hilfreich.

Um das System für andere Anwendungen zugänglich zu machen, Wir machen den Agenten über a verfügbar Mit FastAPI erstellte REST-APIDies ermöglicht die Integration mit Webanwendungen, Chat-Schnittstellen und andere Dienste.

Schritt 0: Einrichten Ihrer Umgebung

Zum Mitmachen, Sie benötigen Python 3.10+ und ein Paketmanager wie pipx oder uv (was deutlich schneller ist als Standard-Pip).

Wenn Sie noch kein UV haben, Sie können es mit einem einfachen Curl-Befehl installieren:

# UV installieren
Curl -LsSf [https://astral.sh/uv/install.sh](https://astral.sh/uv/install.sh) | sh

Projektstruktur

Für dieses Projekt erwarten wir die folgende Projektstruktur:

Initialisieren Sie Ihr Projekt

Sobald UV installiert ist, aus dem Stammverzeichnis Ihres Repositorys, Installieren Sie die relevanten Bibliotheken sowohl für die Agent- als auch für die API-Ebene und aktivieren Sie die virtuelle Umgebung:

# Installieren Sie das Google ADK, FastAPI, und Uvicorn (der ASGI-Server)
uv google-adk fastapi uvicorn hinzufügen
# Synchronisieren Sie Abhängigkeiten und aktivieren Sie Ihre Umgebung
UV-Synchronisierung
Quelle .venv/bin/activate

Der nächste Schritt besteht darin, Ihren Agenten über die ADK-CLI zu initialisieren, Dadurch wird die erforderliche Verzeichnisstruktur für die Logik Ihres Agenten erstellt.

# Erstellen Sie ein neues Agentenprojekt
adk create my_travel_planner

Die .env-Konfiguration

Der sichere Umgang mit API-Schlüsseln ist von größter Bedeutung. Sie sollten eine .env-Datei im Verzeichnis my_travel_planner erstellen (oder füllen Sie die vorhandene .env-Vorlagendatei aus, die im obigen Schritt erstellt wurde) Anmeldeinformationen verwalten.

Es ist wichtig, dass Sie diese Datei niemals einer Versionskontrolle unterwerfen. Stellen Sie sicher, dass Sie dies zum hinzufügen .Gitignore-Datei (falls es noch nicht existiert).

• Option 1 (Google AI Studio): Wenn Sie einen Standard-Gemini-API-Schlüssel von verwenden Google AI StudioSetzen Sie GOOGLE_GENAI_USE_VERTEXAI=False und fügen Sie Ihren Schlüssel hinzu.
• Option 2 (Vertex-KI): Wenn Sie Google Cloud nutzen, Setzen Sie GOOGLE_GENAI_USE_VERTEXAI=True und verweisen Sie auf Ihre Anmeldeinformationen für die Anwendung. Sie können dem folgen Link für eine genaue Dokumentation.

# .Env-Vorlage
GOOGLE_API_KEY=your_gemini_api_key_here
GOOGLE_GENAI_USE_VERTEXAI=Falsch
# Optional für Vertex AI:
# GOOGLE_APPLICATION_CREDENTIALS=path/to/your/credentials.json

Schritt 1: Definieren Sie den Agenten

Das „Gehirn“ Ihres Systems ist in my_travel_planner/agent.py definiert. Hier geben wir dem Agenten einen Namen, ein bestimmtes Modell (wie Gemini-2,5-Flash) und klare Anweisungen zu seiner Person.

von google.adk.agents Import Agent
def get_root_agent():
    # Der Root-Agent (The "Brain")
    travel_planner = Agent(
        name="travel_planner",
        model="gemini-2.5-flash",
        description="A comprehensive travel planning assistant.",
        instruction="""You are a world-class travel planner.
        Recommend places to visit based on the user's query.""",
    )
    return travel_planner
root_agent = get_root_agent()

Schritt 2: Verwalten Sie den Speicher mit Sitzungen und Läufern

Zustandslose LLMs vergessen den Kontext, sobald die Anfrage endet. Für Produktionssysteme werden Agenten benötigt Erinnerung. ADK verwaltet dies durch Treffen und die Läufer.

• Sitzungen: Gesprächsverlauf der Filialagenten, Benutzerinformationen, und Zwischenstände.
• Läufer: Orchestriert die gesamte Interaktion – Empfang von Eingaben, es an das Gehirn weiterleiten, und Aufrechterhaltung des Staates.

So können Sie diese Pipeline asynchron ausführen. Im Stammverzeichnis Ihres Repositorys, Erstellen Sie run.py so:

aus google.adk.sessions importieren Sie InMemorySessionService
von google.adk.agents.llm_agent Import-Agent
aus google.adk.runners importiere Runner
aus google.genai-Importtypen  # Zum Erstellen von Nachrichteninhalten/-teilen
Asynchron importieren
aus pathlib import Path
aus dotenv import load_dotenv
load_dotenv(Weg(__Datei__).Elternteil / "my_travel_planner" / ".env")  # Laden Sie Umgebungsvariablen aus der .env-Datei
aus my_travel_planner.agent import_get_root_agent
APP_NAME = "travel-planner_app"
USER_ID = "user_1"
SESSION_ID = "session_001"
async def setup_session_and_runner(root_agent: Agent = Keiner, Sitzungs-ID: str = SESSION_ID):
    # Richten Sie Runner für die Ausführung ein
    session_service = InMemorySessionService()
    session = Warten auf session_service.create_session(app_name=APP_NAME, user_id=USER_ID, session_id=session_id)
    Läufer = Läufer(agent=root_agent, app_name=APP_NAME, session_service=session_service)
    Rücksitzung, Läufer
async def call_agent_async(Abfrage: str, root_agent: Agent = Keiner, Sitzungs-ID: str = SESSION_ID) -> str:
    Inhalt = Typen.Inhalt(role='user', Teile=[Typen.Teil(text=Abfrage)])
    Sitzung, runner = warte auf setup_session_and_runner(root_agent=root_agent, session_id=session_id)
    events = runner.run_async(user_id=USER_ID, session_id=session_id, new_message=content)
    final_response_text = "No response received."
    asynchron für Ereignis in Ereignissen:
        # Schlüsselkonzept: is_final_response() markiert die abschließende Nachricht für die Runde.
        if event.is_final_response():
            wenn event.content und event.content.parts:
                final_response_text = event.content.parts[0].Text
            elif event.actions und event.actions.escalate:
                final_response_text = f"Agent escalated: {event.error_message or 'No specific message.'}"
            brechen
drucken(f"<<< Agentenantwort: {final_response_text}")
    final_response_text zurückgeben
async def run_agent_pipeline(Abfrage: str) -> str:
    root_agent = get_root_agent()
    Rückkehr warte auf call_agent_async(query=Abfrage, root_agent=root_agent, session_id=SESSION_ID)
if __name__ == "__main__":
    user_query = ("I'm planning a trip to Paris in the spring. Was sind einige Sehenswürdigkeiten und lokale Veranstaltungen, die man gesehen haben muss? "
                  "during that time?")
    asyncio.run(run_agent_pipeline(query=user_query))

Schritt 3: Verwandeln Sie Ihren Agenten in eine API

Um Ihren Agenten in der realen Welt nützlich zu machen, Wir müssen es als API verfügbar machen. FastAPI ist der moderne Standard dafür, weil es leistungsstark ist, verwendet Typhinweise zur Validierung, und generiert eine automatische Swagger-Dokumentation.

Indem wir unsere ADK-Pipeline in einen POST-Endpunkt einbinden, Wir können unseren Agenten mit Frontends verbinden, mobile Apps, oder andere Microservices.

Im Repository-Stammverzeichnis, Wir erstellen api.py, wo wir einen einfachen /ask-Endpunkt definieren:

aus Fastapi FastAPI importieren
aus pydantic import BaseModel
aus pathlib import Path
aus dotenv import load_dotenv
load_dotenv(Weg(__Datei__).Elternteil / "my_travel_planner" / ".env")
from run import run_agent_pipeline
app = FastAPI(title="Travel Planner AI", description="Powered by Google ADK + Gemini")
Klasse QueryRequest(Sie sind Modelle):
    Abfrage: str
Klasse QueryResponse(Sie sind Modelle):
    Abfrage: str
    Antwort: str
@app.post("/ask", Response_model=QueryResponse)
async def ask_agent(Anfrage: AbfrageAnfrage):
    Antwort = Warten auf run_agent_pipeline(query=request.query)
    QueryResponse zurückgeben(query=request.query, Antwort=Antwort)

Betreiben Sie Ihren Server mit: UV-Run Uvicorn API:App –neu laden
Der Server startet um http://localhost:8000 und interaktive Dokumente (Swagger-Benutzeroberfläche): http://localhost:8000/Dokumente

Letzte Gedanken: Der Weg zur Produktion

Ein lokales Skript ist ein guter Anfang, Für die Produktionsreife sind jedoch noch einige weitere Schritte erforderlich:

1. Überprüfen: Schreiben Sie Komponententests, um zu überprüfen, ob die Agentenlogik Randfälle verarbeitet.
2. Containerisieren: Verwenden Sie Docker, um sicherzustellen, dass „es funktioniert auf meinem Computer“ in „es funktioniert auf dem Server“ übersetzt wird..
3. Einfügen: Versenden Sie Ihren Container an einen Cloud-Anbieter wie Google Cloud (Cloud Run) oder AWS.

Bereit zum Bau? Holen Sie sich den Code von der GitHub-Repo und beginnen Sie noch heute mit dem Aufbau Ihrer eigenen spezialisierten Agenten-Workflows!

✨ Wir danken dafür Google AI/ML-Entwicklerprogramme Support-Team für Google Cloud Credits.

✨ Der Quellcode kann auf GitHub abgerufen werden Hier.

✨ Wenn Ihnen der Artikel gefällt, Bitte abonnieren zu meinem neuesten.
Um Kontakt aufzunehmen, Kontaktieren Sie mich unter LinkedIn oder ungefähr ashmibanerjee.com.

Offenlegung der GenAI-Nutzung: GenAI-Modelle wurden verwendet, um den Blog auf grammatikalische Inkonsistenzen zu überprüfen und den Text auf Klarheit zu verfeinern. Die Autoren tragen die volle Verantwortung für die in diesem Blog präsentierten Inhalte.

---

[Anleitung] Von Agenten bis zu APIs: Erstellen Sie produktionsbereite KI-Systeme mit Google ADK & FastAPI wurde ursprünglich in Google Developer Experts auf Medium veröffentlicht, wo die Leute die Diskussion fortsetzen, indem sie diese Geschichte hervorheben und darauf reagieren.