Diese Seite wurde von der Cloud Translation API übersetzt.

AG2-Agent entwickeln

AG2, ein von der Community entwickelter Fork des ursprünglichen AutoGen, ist ein Open-Source-Framework zum Erstellen von KI-basierten Agenten. Auf dieser Seite erfahren Sie, wie Sie einen Agent mit der frameworkspezifischen AG2-Vorlage (der Klasse AG2Agent im Vertex AI SDK for Python) entwickeln. Der Agent gibt den Wechselkurs zwischen zwei Währungen an einem bestimmten Datum zurück. Gehen Sie wie folgt vor:

Ausführbares Programm definieren und konfigurieren
Tool definieren und verwenden
Optional: Orchestration anpassen

Hinweise

Richten Sie Ihre Umgebung ein, indem Sie die Schritte unter Umgebung einrichten ausführen.

Schritt 1: Ausführbares Programm definieren und konfigurieren

Geben Sie die zu verwendende Modellversion an.

model = "gemini-2.0-flash"

Geben Sie den Namen des ausführbaren Programms an, das verwendet werden soll.

runnable_name = "Get Exchange Rate Agent"

Optional: Konfigurieren Sie das Modell.

from google.cloud.aiplatform.aiplatform import initializer

llm_config = {
    "config_list": [{
        "project_id":       initializer.global_config.project,
        "location":         initializer.global_config.location,
        "model":            "gemini-2.0-flash",
        "api_type":         "google",
    }]
}

Weitere Informationen zum Konfigurieren des Modells in AG2 finden Sie unter Model Configuration Deep-dive.

Optional: Konfigurieren Sie die Sicherheitseinstellungen des Modells. Das folgende Beispiel zeigt, wie Sie die Sicherheitseinstellungen konfigurieren können:

from vertexai.generative_models import HarmBlockThreshold, HarmCategory

safety_settings = {
    HarmCategory.HARM_CATEGORY_HARASSMENT: HarmBlockThreshold.BLOCK_ONLY_HIGH,
    HarmCategory.HARM_CATEGORY_HATE_SPEECH: HarmBlockThreshold.BLOCK_ONLY_HIGH,
    HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT: HarmBlockThreshold.BLOCK_ONLY_HIGH,
    HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT: HarmBlockThreshold.BLOCK_ONLY_HIGH,
}

for config_item in llm_config["config_list"]:
    config_item["safety_settings"] = safety_settings

Weitere Informationen zu den verfügbaren Optionen für Sicherheitseinstellungen in Gemini finden Sie unter Sicherheitsattribute konfigurieren.

Erstellen Sie mit den Modellkonfigurationen einen AG2Agent:

from vertexai import agent_engines

agent = agent_engines.AG2Agent(
    model=model,                  # Required.
    runnable_name=runnable_name,  # Required.
    llm_config=llm_config,        # Optional.
)

Wenn Sie in einer interaktiven Umgebung (z.B. einem Terminal oder einem Colab-Notebook) arbeiten, können Sie eine Abfrage als Zwischenschritt zum Testen ausführen:

response = agent.query(input="What is the exchange rate from US dollars to SEK today?", max_turns=1)

print(response)

Die Antwort ist ein Python-Dictionary, das dem folgenden Beispiel ähnelt:

{'chat_id': None,
 'chat_history': [{'content': 'What is the exchange rate from US dollars to Swedish currency?',
   'role': 'assistant',
   'name': 'user'},
  {'content': 'I do not have access to real-time information, including currency exchange rates. To get the most up-to-date exchange rate from US dollars to Swedish Krona (SEK), I recommend using a reliable online currency converter or checking with your bank. \n',
   'role': 'user',
   'name': 'Exchange Rate Agent'}],
 'summary': 'I do not have access to real-time information, including currency exchange rates. To get the most up-to-date exchange rate from US dollars to Swedish Krona (SEK), I recommend using a reliable online currency converter or checking with your bank. \n',
 'cost': {'usage_including_cached_inference': {'total_cost': 5.2875e-06,
   'gemini-2.0-flash': {'cost': 5.2875e-06,
    'prompt_tokens': 34,
    'completion_tokens': 62,
    'total_tokens': 96}},
  'usage_excluding_cached_inference': {'total_cost': 5.2875e-06,
   'gemini-2.0-flash': {'cost': 5.2875e-06,
    'prompt_tokens': 34,
    'completion_tokens': 62,
    'total_tokens': 96}}},
 'human_input': []}

Erweiterte Anpassung (optional)

Für die Vorlage AG2Agent wird standardmäßig api_type=="google" verwendet, da sie Zugriff auf alle in Google Cloudverfügbaren Fundierungsmodelle bietet. Wenn Sie ein Modell verwenden möchten, das nicht über api_type=="google" verfügbar ist, können Sie den Parameter llm_config anpassen.

Eine Liste der in AG2 unterstützten Modelle und ihrer Funktionen finden Sie unter Modellanbieter. Die unterstützten Werte für llm_config= sind für jedes Chatmodell spezifisch. Weitere Informationen finden Sie in der entsprechenden Dokumentation.

Gemini

Standardmäßig installiert.

Wird in AG2Agent verwendet, wenn Sie das llm_config-Argument weglassen, z. B.

from vertexai import agent_engines

agent = agent_engines.AG2Agent(
    model=model,                # Required.
    runnable_name=runnable_name # Required.
)

Anthropic

Folgen Sie zuerst der Dokumentation, um ein Konto einzurichten und das Paket zu installieren.

Als Nächstes definieren Sie einen llm_config:

llm_config = {
    "config_list": [{
        "model": "claude-3-5-sonnet-20240620",            # Required.
        "api_key": "ANTHROPIC_API_KEY",  # Required.
        "api_type": "anthropic",                          # Required.
     }]
}

Verwenden Sie ihn schließlich in AG2Agent mit dem folgenden Code:

from vertexai import agent_engines

agent = agent_engines.AG2Agent(
    model="claude-3-5-sonnet-20240620",             # Required.
    runnable_name=runnable_name,                    # Required.
    llm_config=llm_config,                          # Optional.
)

OpenAI

Sie können OpenAI in Verbindung mit der ChatCompletions API von Gemini verwenden.

Definieren Sie zuerst eine llm_config:

import google.auth
from google.cloud.aiplatform.aiplatform import initializer

project = initializer.global_config.project
location = initializer.global_config.location
base_url = f"https://{location}-aiplatform.googleapis.com/v1beta1/projects/{project}/locations/{location}/endpoints/openapi"

# Note: the credential lives for 1 hour by default.
# After expiration, it must be refreshed.
creds, _ = google.auth.default(scopes=["https://www.googleapis.com/auth/cloud-platform"])
auth_req = google.auth.transport.requests.Request()
creds.refresh(auth_req)

llm_config = {
    "config_list": [{
        "model": "google/gemini-2.0-flash",  # Required.
        "api_type": "openai",                    # Required.
        "base_url": base_url,                    # Required.
        "api_key": creds.token,                  # Required.
    }]
}

Verwenden Sie ihn schließlich in AG2Agent mit dem folgenden Code:

from vertexai import agent_engines

agent = agent_engines.AG2Agent(
    model="google/gemini-2.0-flash",  # Or "meta/llama3-405b-instruct-maas".
    runnable_name=runnable_name,          # Required.
    llm_config=llm_config,                # Optional.
)

Schritt 2: Tool definieren und verwenden

Nachdem Sie Ihr Modell definiert haben, definieren Sie im nächsten Schritt die Tools, die Ihr Modell für Logik verwendet. Ein Tool kann ein AG2-Tool oder eine Python-Funktion sein.

Wenn Sie Ihre Funktion definieren, ist es wichtig, Kommentare einzufügen, die die Parameter der Funktion, die Funktion selbst und die Rückgabe der Funktion vollständig und klar beschreiben. Anhand dieser Informationen bestimmt das Modell, welche Funktion verwendet werden soll. Sie müssen Ihre Funktion auch lokal testen, um zu bestätigen, dass sie funktioniert.

Verwenden Sie den folgenden Code, um eine Funktion zu definieren, die einen Wechselkurs zurückgibt:

def get_exchange_rate(
    currency_from: str = "USD",
    currency_to: str = "EUR",
    currency_date: str = "latest",
):
    """Retrieves the exchange rate between two currencies on a specified date.

    Uses the Frankfurter API (https://api.frankfurter.app/) to obtain
    exchange rate data.

    Args:
        currency_from: The base currency (3-letter currency code).
            Defaults to "USD" (US Dollar).
        currency_to: The target currency (3-letter currency code).
            Defaults to "EUR" (Euro).
        currency_date: The date for which to retrieve the exchange rate.
            Defaults to "latest" for the most recent exchange rate data.
            Can be specified in YYYY-MM-DD format for historical rates.

    Returns:
        dict: A dictionary containing the exchange rate information.
            Example: {"amount": 1.0, "base": "USD", "date": "2023-11-24",
                "rates": {"EUR": 0.95534}}
    """
    import requests
    response = requests.get(
        f"https://api.frankfurter.app/{currency_date}",
        params={"from": currency_from, "to": currency_to},
    )
    return response.json()

So testen Sie die Funktion, bevor Sie sie in Ihrem Agent verwenden:

get_exchange_rate(currency_from="USD", currency_to="SEK")

Die Antwort sollte in etwa so aussehen:

{'amount': 1.0, 'base': 'USD', 'date': '2024-02-22', 'rates': {'SEK': 10.3043}}

Wenn Sie das Tool in AG2Agent verwenden möchten, fügen Sie es der Liste der Tools unter dem Argument tools= hinzu:

from vertexai import agent_engines

agent = agent_engines.AG2Agent(
    model=model,                 # Required.
    runnable_name=runnable_name, # Required.
    tools=[get_exchange_rate],   # Optional.
)

Sie können den Agent lokal testen, indem Sie Testabfragen an ihn durchführen. Führen Sie den folgenden Befehl aus, um den Agenten lokal mit US-Dollar und schwedischen Kronen zu testen:

response = agent.query(input="What is the exchange rate from US dollars to Swedish currency?", max_turns=2)

Die Antwort ist ein Wörterbuch, das in etwa so aussieht:

{'chat_id': None,
 'chat_history': [{'content': 'What is the exchange rate from US dollars to Swedish currency?',
   'role': 'assistant',
   'name': 'user'},
  {'content': '',
   'tool_calls': [{'id': '2285',
     'function': {'arguments': '{"currency_from": "USD", "currency_to": "SEK"}',
      'name': 'get_exchange_rate'},
     'type': 'function'}],
   'role': 'assistant'},
  {'content': "{'amount': 1.0, 'base': 'USD', 'date': '2025-02-27', 'rates': {'SEK': 10.6509}}",
   'tool_responses': [{'tool_call_id': '2285',
     'role': 'tool',
     'content': "{'amount': 1.0, 'base': 'USD', 'date': '2025-02-27', 'rates': {'SEK': 10.6509}}"}],
   'role': 'tool',
   'name': 'user'},
  {'content': 'The current exchange rate is 1 USD to 10.6509 SEK. \n',
   'role': 'user',
   'name': 'Get Exchange Rate Agent'},
  {'content': 'What is the exchange rate from US dollars to Swedish currency?',
   'role': 'assistant',
   'name': 'user'},
  {'content': '',
   'tool_calls': [{'id': '4270',
     'function': {'arguments': '{"currency_from": "USD", "currency_to": "SEK"}',
      'name': 'get_exchange_rate'},
     'type': 'function'}],
   'role': 'assistant'},
  {'content': "{'amount': 1.0, 'base': 'USD', 'date': '2025-02-27', 'rates': {'SEK': 10.6509}}",
   'tool_responses': [{'tool_call_id': '4270',
     'role': 'tool',
     'content': "{'amount': 1.0, 'base': 'USD', 'date': '2025-02-27', 'rates': {'SEK': 10.6509}}"}],
   'role': 'tool',
   'name': 'user'},
  {'content': 'The current exchange rate is 1 USD to 10.6509 SEK. \n',
   'role': 'user',
   'name': 'Get Exchange Rate Agent'}],
 'summary': 'The current exchange rate is 1 USD to 10.6509 SEK. \n',
 'cost': {'usage_including_cached_inference': {'total_cost': 0.0002790625,
   'gemini-2.0-flash': {'cost': 0.0002790625,
    'prompt_tokens': 757,
    'completion_tokens': 34,
    'total_tokens': 791}},
  'usage_excluding_cached_inference': {'total_cost': 0.0002790625,
   'gemini-2.0-flash': {'cost': 0.0002790625,
    'prompt_tokens': 757,
    'completion_tokens': 34,
    'total_tokens': 791}}},
 'human_input': []}

Schritt 3: Orchestrierung anpassen

Alle AG2-Agents implementieren die ConversableAgent-Schnittstelle, die Eingabe- und Ausgabeschemas für die Orchestrierung bereitstellt. Für die Vorlage AG2Agent muss ein ausführbares Programm erstellt werden, damit sie auf Anfragen reagieren kann. Standardmäßig erstellt AG2Agent ein ausführbares Programm, indem das Modell mit Tools verknüpft wird.

Sie sollten die Orchestrierung anpassen, wenn Sie (i) einen Assistant-Agent implementieren möchten, der eine Aufgabe mit einem Modell löst, (ii) einen User Proxy-Agent implementieren möchten, der Code ausführen und Feedback an die anderen Agents geben kann, oder (iii) einen Reasoning-Agent implementieren möchten, der eine Aufgabe mit einem Modell und der Tree-of-Thought-Methode löst. Dazu müssen Sie beim Erstellen von AG2Agent das ausführbare Standardprogramm überschreiben, indem Sie das runnable_builder=-Argument mit einer Python-Funktion der folgenden Signatur angeben:


def runnable_builder(
    **runnable_kwargs,
):

So haben Sie verschiedene Möglichkeiten, die Orchestrierungslogik anzupassen.

Assistant-Agent

Im einfachsten Fall können Sie zum Erstellen eines Assistant-Agents ohne Orchestrierung die runnable_builder für AG2Agent überschreiben.

from vertexai import agent_engines

def runnable_builder(**kwargs):
    from autogen import agentchat

    return agentchat.AssistantAgent(**kwargs)

agent = agent_engines.AG2Agent(
    model=model,
    runnable_name=runnable_name,
    runnable_builder=runnable_builder,
)

User Proxy Agent

Im einfachsten Fall können Sie zum Erstellen eines Nutzer-Proxy-Agents ohne Orchestrierung die runnable_builder für AG2Agent überschreiben.

from vertexai import agent_engines

def runnable_builder(**kwargs):
    from autogen import agentchat

    return agentchat.UserProxyAgent(**kwargs)

agent = agent_engines.AG2Agent(
    model=model,
    runnable_name=runnable_name,
    runnable_builder=runnable_builder,
)

Reasoning Agent

Im einfachsten Fall können Sie zum Erstellen eines Reasoning-Agents ohne Orchestrierung die runnable_builder für AG2Agent überschreiben.

from vertexai import agent_engines

def runnable_builder(**kwargs):
    from autogen import agentchat

    return agentchat.ReasoningAgent(**kwargs)

agent = agent_engines.AG2Agent(
    model=model,
    runnable_name=runnable_name,
    runnable_builder=runnable_builder,
)