Wie benutze ich Google ADK für Bauagenten?

Möchten Sie intelligente Agenten mit realen Fähigkeiten aufbauen? Verwenden Sie Google ADK, um Agenten zu erstellen, die dynamisch argumentieren, delegieren und reagieren können. Dieses Google ADK -Tutorial führt Sie durch die Schritte, um Konversationsmittel mit Google ADK über verschiedene Sprachmodelle hinweg zu erstellen Zwillinge Und Gpt. Unabhängig davon KI -Agenten Mit Google ADK hilft Ihnen dieser praktische Leitfaden mit Leichtigkeit und Klarheit in die agierende Entwicklung.

Was ist das Agent Improvement Package?

Das Agent Improvement Package (ADK) ist ein flexibler und modularer Rahmen für die Entwicklung und Bereitstellung von KI -Agenten. Es kann mit populären LLMs und Open-Supply-Generativen-KI-Instruments verwendet werden und dient dazu, eng in das Google-Ökosystem und die Gemini-Modelle integriert zu werden. ADK macht es einfach, mit einfachen Agenten zu beginnen, die von Gemini -Modellen und Google AI -Instruments betrieben werden und gleichzeitig die Steuerung und Struktur für komplexere Agentenarchitekturen und Orchestrierung bereitstellen.

Funktionen des Agent Improvement Package von Google

1. Multi-Agent-Architektur: Verfassen Sie die Agenten parallel, sequentielle oder hierarchische Workflows.
2. Versatile Orchestrierung: Routen Sie dynamisch mit LLM-gestützten Workflows.
3. Reiches Werkzeug -Ökosystem: Verwenden Sie nahtlos integrierte Instruments für integrierte, benutzerdefinierte und Drittanbieter.
4. Modell-Agnostic: Unterstützt Gemini, GPT-4O, Claude, Mistral und Extra.
5. Streaming -Funktionen: Echtzeit-Streaming für Textual content, Audio und Video.
6. Dev-freundliches Werkzeug: CLI-, Internet -UI-, visuelle Debugging- und Evaluierungstools.
7. Speicher- und Staatsverwaltung: Eingebaute Handhabung für Sitzung und Langzeitgedächtnis.
8. Artefakthandhabung: Verwalten Sie mühelos Dateien, Ausgänge und binäre Daten.
9. Sensible Execution: Agenten können Code ausführen und mehrstufige Planung verarbeiten.
10. Vielseitige Bereitstellung: Laufen Sie lokal, in Google Cloud (Vertex AI, Cloud -Lauf) oder über Docker.

Problemanweisung

Wenn sich KI-Systeme von Einzweck-Instruments bis hin zu kollaborativen, multi-Agenten-Ökosystemen entwickeln, benötigen Entwickler praktische Anleitung zum Aufbau und zur Orchestrierung intelligenter Agenten, die kommunizieren, delegieren und anpassen können. Um diese Lücke zu überbrücken, werden wir eine bauen Wetterteamein Mehr-Agent-System, das wetterbezogene Abfragen beantworten kann und gleichzeitig Benutzerinteraktionen wie Grüße, Abschied und sichere Antworten bearbeitet.

Dieses praktische Projekt soll demonstrieren, wie man:

• Entwerfen Sie ein modulares Multi-Agent-System mit Googles Agent Improvement Package (ADK).
• Integrieren Sie mehrere Sprachmodelle (z. B. Gemini, GPT, Claude) für die Aufgabenspezialisierung.
• Implementieren Sie intelligente Job -Delegation zwischen Agenten.
• Verwalten Sie den Sitzungsspeicher für kontextbezogene Kontinuität.
• Wenden Sie Sicherheitsmechanismen über strukturierte Rückrufe an.

Durch die Lösung dieses Issues sammeln Sie praktische Erfahrungen mit der Finest Practices der ADK-Architektur, Orchestrierung, Gedächtnismanagement und Sicherheitssicherheit und legen die Grundlage für komplexere, reale Agentenanwendungen.

Sie können sich auf die zur Verfügung gestellten beziehen Colab Pocket book Um Sie durch die praktische Implementierung zu führen.

Vorgeschlagenen Workflow

Voraussetzungen

Stellen Sie vor dem Eintauchen in den Code sicher, dass Sie die folgenden Setup -Schritte ausgeführt haben:

1. Richten Sie Ihre Umgebung ein und installieren Sie ADK

Beginnen Sie mit der Erstellung und Aktivierung einer virtuellen Umgebung, um Ihre Projektabhängigkeiten zu isolieren:

# Create a digital setting

python -m venv .venv

Nachdem die Umgebung erstellt wurde, können wir sie mit den folgenden Befehlen aktivieren:

# Activate the setting

# macOS/Linux:

supply .venv/bin/activate

# Home windows CMD:

.venvScriptsactivate.bat

# Home windows PowerShell:

.venvScriptsActivate.ps1

Sobald Ihre Umgebung aktiviert ist, installieren Sie die Google AI Improvement Package (ADK):

pip set up google-adk

2. Erhalten Sie Ihre API -Schlüssel

Sie benötigen API -Schlüssel, um mit verschiedenen KI -Modellen zu interagieren. Nehmen Sie sie aus den folgenden Quellen:

Schritte zum Erstellen Ihrer Wetter -App

Schritt 1: Einrichtung und Set up

Installieren Sie die erforderlichen Bibliotheken für das Projekt:

# Set up Google ADK and LiteLLM
!pip set up google-adk -q
!pip set up litellm -q

Bibliotheken importieren:

import os

import asyncio

from google.adk.brokers import Agent

from google.adk.fashions.lite_llm import LiteLlm # For multi-model assist

from google.adk.classes import InMemorySessionService

from google.adk.runners import Runner

from google.genai import varieties # For creating message Content material/Components

import warnings

# Ignore all warnings

warnings.filterwarnings("ignore")

import logging

logging.basicConfig(degree=logging.ERROR)

API -Schlüssel einrichten:

# Gemini API Key

os.environ("GOOGLE_API_KEY") = "YOUR_GOOGLE_API_KEY"

# OpenAI API Key

os.environ('OPENAI_API_KEY') = “YOUR_OPENAI_API_KEY”

# Anthropic API Key

os.environ('ANTHROPIC_API_KEY') = “YOUR_ANTHROPIC_API_KEY”

print("API Keys Set:")

print(f"Google API Key set: {'Sure' if os.environ.get('GOOGLE_API_KEY') and os.environ('GOOGLE_API_KEY') != 'YOUR_GOOGLE_API_KEY' else 'No (REPLACE PLACEHOLDER!)'}")

print(f"OpenAI API Key set: {'Sure' if os.environ.get('OPENAI_API_KEY') and os.environ('OPENAI_API_KEY') != 'YOUR_OPENAI_API_KEY' else 'No (REPLACE PLACEHOLDER!)'}")

print(f"Anthropic API Key set: {'Sure' if os.environ.get('ANTHROPIC_API_KEY') and os.environ('ANTHROPIC_API_KEY') != 'YOUR_ANTHROPIC_API_KEY' else 'No (REPLACE PLACEHOLDER!)'}")

# Configure ADK to make use of API keys straight (not Vertex AI for this multi-model setup)

os.environ("GOOGLE_GENAI_USE_VERTEXAI") = "False"

Definieren Sie Modellkonstanten für die leichtere Verwendung:

MODEL_GEMINI_2_0_FLASH = "gemini-2.0-flash".

MODEL_GPT_4O = "openai/gpt-4o"

MODEL_CLAUDE_SONNET = "anthropic/claude-3-sonnet-20240229"

print("nEnvironment configured.")

Schritt 2: Definieren Sie die Werkzeuge

In ADK sind Instruments die funktionalen Bausteine, mit denen Agenten über die nur generierenden Textual content hinausgehen können. Sie sind in der Regel einfache Python -Funktionen, die echte Aktionen ausführen können, z. B. das Abrufen von Wetterdaten, das Abfragen einer Datenbank oder das Ausführen von Berechnungen.

Zu Beginn erstellen wir ein Scheinwetter -Instrument, um Wetter -Lookups zu simulieren. Dies hilft uns, sich auf die Struktur des Agenten zu konzentrieren, ohne externe APIs zu benötigen. Später können wir es problemlos gegen einen echten Wetterdienst tauschen.

Code:

def get_weather(metropolis: str) -> dict:
   """Retrieves the present climate report for a specified metropolis.


   Args:
       metropolis (str): The identify of the town (e.g., "Mumbai","Chennai","Delhi").


   Returns:
       dict: A dictionary containing the climate info.
             Features a 'standing' key ('success' or 'error').
             If 'success', features a 'report' key with climate particulars.
             If 'error', consists of an 'error_message' key.
   """
   # Finest Follow: Log instrument execution for simpler debugging
   print(f"--- Instrument: get_weather known as for metropolis: {metropolis} ---")


   city_normalized = metropolis.decrease().change(" ", "")  # Primary enter normalization


   mock_weather_db = {
       "delhi": {"standing": "success", "report": "The climate in Delhi is sunny with a temperature of 35°C."},
       "mumbai": {"standing": "success", "report": "It is humid in Mumbai with a temperature of 30°C."},
       "bangalore": {"standing": "success", "report": "Bangalore is experiencing mild showers and a temperature of twenty-two°C."},
       "kolkata": {"standing": "success", "report": "Kolkata is partly cloudy with a temperature of 29°C."},
       "chennai": {"standing": "success", "report": "It is sizzling and humid in Chennai with a temperature of 33°C."},
   }


   if city_normalized in mock_weather_db:
       return mock_weather_db(city_normalized)
   else:
       return {"standing": "error", "error_message": f"Sorry, I haven't got climate info for '{metropolis}'."}


# Instance utilization
print(get_weather("Mumbai"))

Schritt 3: Definieren des Agenten

In ADK ist ein Agent die Kernkomponente, die den Konversationsfluss verwaltet und den Benutzer, den LLM und die Instruments verbindet, die er verwenden kann.

Um einen Agenten zu definieren, konfigurieren Sie einige wesentliche Parameter:

• Title: Eine eindeutige Kennung für den Agenten (z. B. „Weather_agent_v1“).
• Modell: Der LLM, den der Agent verwendet (z. B. model_gemini_2_5_pro).
• Beschreibung: Eine kurze Zusammenfassung dessen, was der Agent tut-entscheidend für die Zusammenarbeit und Delegation in Multi-Agent-Systemen.
• Anweisung: Detaillierte Verhaltensrichtlinien für die LLM, Definieren ihrer Persona, Ziele, die Verwendung von Instruments und der Umgang mit Randfällen.
• Werkzeuge: Eine Liste von Werkzeugfunktionen (wie (get_weather)) Der Agent kann aufrufen.

Code:

AGENT_MODEL=mannequin
weather_agent=Agent(
   identify="weather_agent_v1",
   mannequin=AGENT_MODEL,
   description="Gives climate info for particular cities.",
   instruction="You're a useful climate assistant. Your major aim is to offer present climate stories. "
               "When the consumer asks for the climate in a selected metropolis, "
               "you MUST use the 'get_weather' instrument to seek out the knowledge. "
               "Analyze the instrument's response: if the standing is 'error', inform the consumer politely concerning the error message. "
               "If the standing is 'success', current the climate 'report' clearly and concisely to the consumer. "
               "Solely use the instrument when a metropolis is talked about for a climate request.",
   instruments=(get_weather),


)

print(f"Agent '{weather_agent.identify}' created utilizing mannequin '{AGENT_MODEL}'.")

Schritt 4: Richten Sie den Zweitplatzierungs- und Sitzungsdienst ein

Um Gespräche zu verarbeiten und den Agenten effektiv auszuführen, benötigen wir zwei Schlüsselkomponenten:

SESSIsionService: Diese Komponente verfolgt den Gesprächsverlauf und den Sitzungsstatus jedes Benutzers. Eine grundlegende Model genannt InmemorysesionService Speichert alle Daten im Speicher, wodurch es preferrred für Assessments oder leichte Apps ist. Es protokolliert jede in einer Sitzung ausgetauschte Nachricht. Wir werden dauerhaft in die Speicherdaten eingehen.

Läufer: Dies wirkt als Gehirn des Methods. Es verwaltet den gesamten Interaktionsfluss, wird Benutzereingaben aufgenommen, an den richtigen Agenten weitergegeben, das LLM und alle erforderlichen Instruments aufgerufen, Sitzungsdaten über die aktualisiert SESSIsionServiceund produzieren eine Reihe von Ereignissen, die zeigen, was während der Interaktion passiert.

Code:

# @title Setup Session Service and Runner
# ---Session Administration ---
# Key Idea: SessionService shops dialog historical past & state.
# InMemorySessionService is a straightforward, non-persistent storage for this tutorial.


session_service=InMemorySessionService()


# Outline constants for figuring out the interplay context
APP_NAME="weathertutorial_app"
USER_ID="user_1"
SESSION_ID="session_001"


# Create the particular session the place the dialog will occur
session=session_service.create_session(
   app_name=APP_NAME,
   user_id=USER_ID,
   session_id=SESSION_ID,
)


print(f"Session created: App='{APP_NAME}', Consumer="{USER_ID}", Session='{SESSION_ID}'")


# ---Runner ---
# Key Idea: Runner orchestrates the agent execution loop.


runner=Runner(
   agent=weather_agent,
   app_name=APP_NAME,
   session_service=session_service
)


print(f"Runner created for agent '{runner.agent.identify}'.")

Schritt 5: Interagieren Sie mit dem Agenten

Wir werden den asynchronen Läufer von ADK verwenden, um mit unserem Agenten zu sprechen und seine Antwort zu erhalten. Seit Llm und Werkzeugaufrufe können Zeit in Anspruch nehmen und sie asynchron umgehen, sorgt für ein reibungsloses, nicht blockierendes Erlebnis.

Wir erstellen eine Helferfunktion mit dem Namen call_agent_async das macht Folgendes:

• Akzeptiert eine Benutzerabfrage als Eingabe
• Verpackt es in das erforderliche Inhaltsformat von ADK
• Anrufe Runner.run_async () mit der Sitzung und Nachricht
• Iteriert durch die Occasion Stream ADK gibt diese Ereignisse zurück und verfolgt jeden Schritt (Werkzeugaufruf, Antwort usw.).
• Erkennt und druckt die endgültige Antwort mithilfe Ereignis.is_Final_Response ())

Code:

# @title Outline Agent Interplay Operate
import asyncio
from google.genai import varieties # For creating message Content material/Components


async def call_agent_async(question: str):
 """Sends a question to the agent and prints the ultimate response."""
 print(f"n>>> Consumer Question: {question}")


 # Put together the consumer's message in ADK format
 content material = varieties.Content material(position="consumer", components=(varieties.Half(textual content=question)))


 final_response_text = "Agent didn't produce a ultimate response." # Default


 # Key Idea: run_async executes the agent logic and yields Occasions.
 # We iterate by occasions to seek out the ultimate reply.
 async for occasion in runner.run_async(user_id=USER_ID, session_id=SESSION_ID, new_message=content material):
     # You may uncomment the road beneath to see *all* occasions throughout execution
     # print(f"  (Occasion) Writer: {occasion.creator}, Kind: {kind(occasion).__name__}, Last: {occasion.is_final_response()}, Content material: {occasion.content material}")


     # Key Idea: is_final_response() marks the concluding message for the flip.
     if occasion.is_final_response():
         if occasion.content material and occasion.content material.components:
            # Assuming textual content response within the first half
            final_response_text = occasion.content material.components(0).textual content
         elif occasion.actions and occasion.actions.escalate: # Deal with potential errors/escalations
            final_response_text = f"Agent escalated: {occasion.error_message or 'No particular message.'}"
         # Add extra checks right here if wanted (e.g., particular error codes)
         break # Cease processing occasions as soon as the ultimate response is discovered


 print(f"<<< Agent Response: {final_response_text}")

Schritt 6: Führen Sie das Gespräch aus

Nachdem alles eingerichtet ist, ist es an der Zeit, unseren Agenten auf den Take a look at zu setzen, indem Sie einige Beispielanfragen senden.

Additionally:

• Wickeln Sie die asynchron Anrufe in a hauptsächlich() Coroutine
• Verwenden erwarten die Funktion ausführen.

Was zu erwarten:

• Die Benutzeranfragen werden gedruckt
• Wenn der Agent ein Instrument verwendet (wie get_weather), sehen Sie Protokolle wie:
  – Instrument: get_weather angerufen… –
• Der Agent gibt eine endgültige Antwort zurück, die auch anmutig Fälle behandelt, in denen Daten nicht verfügbar sind (z. B. für „Paris“).

Code:

# @title Run the Preliminary Dialog


# # We'd like an async perform to await our interplay helper
# async def run_conversation():
#     await call_agent_async("What's the climate like in Mumbai")
#     await call_agent_async("How about Delhi?") # Anticipating the instrument's error message
#     await call_agent_async("Inform me the climate in CHennai")


# Execute the dialog utilizing await in an async context (like Colab/Jupyter)
await run_conversation()

Ausgabe:

Lesen Sie auch: Wie benutze ich OpenAIs Antworten API & Agent SDK?

Abschluss

Mit Googles Agent Improvement Package (ADK) können Entwickler intelligente, Multi-Agent-Systeme erstellen, die über die einfache Textgenerierung hinausgehen. Durch den Aufbau eines Wetterbots lernten wir wichtige ADK -Konzepte wie Instrument -Integration, Agent Orchestration und Sitzungsmanagement und nutzten gleichzeitig die Leistung von Googles Gemini. Von der Definition klarer, deskriptiver Dokastosen für Instruments bis hin zur Orchestrierung von Interaktionen durch den Läufer und Sessionservice bietet ADK die Flexibilität, produktionsbereite Wirkstoffe aufzubauen, die interagieren, lernen und anpassen können. Egal, ob Sie Chatbots, virtuelle Assistenten oder Multi-Agent-Ökosysteme erstellen, ADK bietet die Werkzeuge, um Ihre Imaginative and prescient zum Leben zu erwecken.

Häufig gestellte Fragen

Datenwissenschaftler | AWS Licensed Options Architect | KI & ML Innovator

Als Datenwissenschaftler bei Analytics Vidhya spezialisiere ich mich auf maschinelles Lernen, Deep Studying und KI-gesteuerte Lösungen, die NLP-, Laptop-Imaginative and prescient- und Cloud-Technologien nutzen, um skalierbare Anwendungen zu erstellen.

Mit einem B.Tech in Informatik (Knowledge Science) aus VIT- und Zertifizierungen wie AWS Licensed Options Architect und TensorFlow umfasst meine Arbeit generative KI, Anomalie -Erkennung, falsche Nachrichtenerkennung und Emotionserkennung. Ich bemühe mich, intelligente Systeme zu entwickeln, die die Zukunft der KI prägen.