Einführung in Agenten-Plugins
Der Bereich der künstlichen Intelligenz entwickelt sich schnell weiter, wobei große Sprachmodelle (LLMs) an der Spitze dieser Revolution stehen. Diese Modelle sind zwar mächtig, arbeiten jedoch oft innerhalb der Grenzen ihrer Trainingsdaten. Um ihr Potenzial wirklich freizusetzen und sie in Anwendungen der realen Welt zu integrieren, müssen wir ihre Fähigkeiten über die einfache Textgenerierung hinaus erweitern. Hier kommen die Agenten-Plugins ins Spiel. Agenten-Plugins sind im Grunde Werkzeuge oder Funktionen, die ein KI-Agent wählen kann, um spezifische Aufgaben auszuführen, auf externe Informationen zuzugreifen oder mit anderen Systemen zu interagieren. Sie überbrücken die Lücke zwischen den Denkfähigkeiten des LLM und der Außenwelt und verwandeln ein Sprachmodell in einen anspruchsvollen und zielorientierten Agenten.
Stellen Sie sich einen KI-Assistenten vor, der nicht nur Ihre Anfrage „den nächsten Italiener finden“ versteht, sondern tatsächlich im Internet navigieren, die Ergebnisse filtern und Wegbeschreibungen liefern kann. Dieses Funktionsniveau wird durch Plugins ermöglicht. Diese Plugins erlauben es dem Agenten:
- Auf Echtzeitdaten zuzugreifen: Aktuelle Wetterdaten, Aktienkurse, Nachrichten oder Informationen aus einer Datenbank abzufragen.
- Aktionen auszuführen: E-Mails zu senden, Termine zu planen, smarte Haushaltsgeräte zu steuern oder mit APIs zu interagieren.
- Die Einschränkungen der LLM zu überwinden: Komplexe Berechnungen durchzuführen, Code auszuführen oder präzise faktische Informationen abzurufen, die über das hinausgehen könnten, was in seinen Trainingsdaten enthalten ist.
Dieser Leitfaden wird Sie durch die praktischen Schritte zur Erstellung von Agenten-Plugins führen und sich auf einen schnellen Einstieg mit klaren Beispielen konzentrieren, um Sie auf den richtigen Weg zu bringen.
Die Schlüsselkoncepte verstehen
Wie Agenten Plugins nutzen
Im Kern funktioniert ein KI-Agent in einem Zyklus von „denken-planen-handeln“. Wenn ihm ein Prompt präsentiert wird, „denkt“ der Agent zuerst darüber nach, welcher Kurs der beste ist. Wenn er feststellt, dass ein externes Werkzeug (Plugin) notwendig ist, um die Anfrage zu erfüllen, „plant“ er, welches Plugin verwendet werden soll, welche Argumente übergeben werden sollen, und „handelt“ dann, indem er dieses Plugin aufruft. Die Ausgabe des Plugins wird dann an den Agenten zurückgegeben, der diese neue Information nutzt, um seinen Denkprozess fortzusetzen und eine endgültige Antwort zu formulieren.
Wesentliche Komponenten eines Plugins
Obwohl die Implementierungen variieren können, teilen die meisten Agenten-Plugins diese grundlegenden Komponenten:
- Name: Eine eindeutige Kennung für das Plugin (z.B.
get_weather,send_email). - Beschreibung: Eine prägnante Erklärung, was das Plugin tut. Dies ist entscheidend, da das LLM diese Beschreibung verwendet, um zu entscheiden, wann und wie das Plugin eingesetzt werden soll.
- Parameter/Schemata: Eine Definition der Eingaben, die das Plugin erwartet, oft in einem Schema (wie JSON Schema) beschrieben. Dies weist das LLM an, welche Argumente bereitzustellen sind.
- Funktion/Implementierung: Der tatsächliche Code, der die Logik des Plugins ausführt (z.B. einen API-Aufruf tätigen, eine Berechnung durchführen).
Schnellstart: Erstellen Sie Ihr erstes Plugin
Für diesen Schnellstart verwenden wir ein auf Python basierendes Framework, das die Entwicklung von Agenten vereinfacht. Viele Frameworks wie LangChain, LlamaIndex oder sogar die Funktionsaufruffähigkeiten von OpenAI bieten ähnliche Mechanismen. Wir konzentrieren uns auf die Prinzipien, die übertragbar sind.
Voraussetzungen
- Installiertes Python (3.8+)
- Eine virtuelle Umgebung (empfohlen)
- Ein grundlegendes Verständnis von Python-Funktionen
Beispiel 1: Ein einfaches Rechner-Plugin
Lassen Sie uns mit einem sehr einfachen Plugin beginnen, das die Addition ausführt. Obwohl ein LLM einfache Mathematik durchführen kann, veranschaulicht dies den Prozess deutlich.
Schritt 1: Definieren Sie die Funktion des Plugins
Zuerst erstellen wir eine Standard-Python-Funktion, die die gewünschte Operation durchführt.
# calculator_plugin.py
def add_numbers(num1: float, num2: float) -> float:
"""
Addiert zwei Zahlen.
Args:
num1 (float): Die erste Zahl.
num2 (float): Die zweite Zahl.
Returns:
float: Die Summe der beiden Zahlen.
"""
return num1 + num2
Schritt 2: Beschreiben Sie das Plugin für den Agenten
Hier sind die Frameworks nützlich. Sie bieten Dekoratoren oder spezielle Klassen, um eine gewöhnliche Python-Funktion in ein Tool zu transformieren, das von einem Agenten genutzt werden kann. Wir müssen eine Beschreibung bereitstellen und das LLM sucht sich implizit die Parameter aus der Funktionssignatur und den Docstrings.
Lassen Sie uns ein konzeptionelles Framework verwenden (ähnlich der Art und Weise, wie LangChain oder LlamaIndex abstrahieren würde):
# Verwendung einer konzeptionellen 'Tool'-Klasse (ähnlich dem Tool von LangChain oder der FunctionTool von LlamaIndex)
class CalculatorTool:
def __init__(self):
self.name = "add_numbers"
self.description = (
"Ein Tool zum Addieren von zwei Zahlen. "
"Nützlich, wenn Sie zwei numerische Werte addieren müssen."
)
self.function = add_numbers
self.parameters = {
"type": "object",
"properties": {
"num1": {"type": "number", "description": "Die erste Zahl zum Addieren"},
"num2": {"type": "number", "description": "Die zweite Zahl zum Addieren"}
},
"required": ["num1", "num2"]
}
# Oder, praktischer, unter Verwendung der integrierten Tool-Erstellung eines Frameworks:
# Beispiel mit der Funktions-Tool-Erstellung von LangChain
from langchain.tools import create_function_tool
def add_numbers(num1: float, num2: float) -> float:
"""
Addiert zwei Zahlen.
Args:
num1 (float): Die erste Zahl.
num2 (float): Die zweite Zahl.
Returns:
float: Die Summe der beiden Zahlen.
"""
return num1 + num2
add_tool = create_function_tool(
func=add_numbers,
name="add_numbers",
description="Ein Tool zum Addieren von zwei Zahlen. Nützlich, wenn Sie zwei numerische Werte addieren müssen."
)
print(add_tool.name)
print(add_tool.description)
# print(add_tool.args) # LangChain leitet dies aus der Funktionssignatur ab
Die description ist von zentraler Bedeutung. Das LLM verlässt sich stark darauf, um den Zweck des Plugins zu verstehen und wann es aufgerufen werden soll. Halten Sie dies klar, präzise und betonen Sie den Nutzen.
Schritt 3: Integrieren mit einem Agenten
Jetzt müssen wir dieses Tool einem KI-Agenten zur Verfügung stellen. Dies beinhaltet in der Regel das Instanziieren eines LLM und einer Agentenklasse und das Übergeben unserer Liste von Tools an ihn.
Verwenden wir LangChain als Beispiel:
from langchain_openai import ChatOpenAI
from langchain.agents import AgentExecutor, create_openai_tools_agent
from langchain import hub
# Vorausgesetzt, Sie haben einen OpenAI API-Schlüssel als Umgebungsvariable (OPENAI_API_KEY) gesetzt
llm = ChatOpenAI(model="gpt-4o", temperature=0)
# Die Tools, die wir erstellt haben
tools = [add_tool]
# Den Prompt aus dem LangChain-Hub abrufen
prompt = hub.pull("hwchase17/openai-tools-agent")
# Den Agenten erstellen
agent = create_openai_tools_agent(llm, tools, prompt)
# Einen Agenten-Ausführer erstellen, um den Agenten zum Laufen zu bringen
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
# Jetzt lassen Sie es uns zum Laufen bringen!
response = agent_executor.invoke({"input": "Was ist die Summe von 123 und 456?"})
print(response["output"])
Wenn Sie dies ausführen, sehen Sie den Denkprozess des Agenten (wenn verbose=True):
> Betritt eine neue Ausführungsreihe von AgentExecutor...
Denken:
Der Benutzer fragt, die Summe zweier Zahlen zu bilden. Das Tool `add_numbers` ist dafür geeignet.
Ich muss das Tool `add_numbers` mit `num1=123` und `num2=456` aufrufen.
Aktion:
```json
{
"tool_name": "add_numbers",
"args": {
"num1": 123,
"num2": 456
}
}
```
Beobachtung: 579.0
Denken:
Das Tool `add_numbers` hat 579.0 zurückgegeben. Es ist die Summe von 123 und 456.
Ich sollte jetzt dem Benutzer mit dem Ergebnis antworten.
Endgültige Antwort: Die Summe von 123 und 456 ist 579.0.
> Kette beendet.
Die Summe von 123 und 456 ist 579.0.
Praktisches Beispiel 2: Ein Wetter-Plugin
Lasst uns ein praktisches Plugin erstellen, das die aktuellen Wetterinformationen über eine öffentliche API abruft. Wir verwenden die OpenWeatherMap-API für dieses Beispiel (Sie benötigen einen kostenlosen API-Schlüssel).
Schritt 1: Holen Sie sich einen API-Schlüssel
Besuchen Sie die OpenWeatherMap-API und melden Sie sich an, um einen kostenlosen API-Schlüssel zu erhalten.
Schritt 2: Definieren Sie die Funktion des Plugins
Diese Funktion wird eine HTTP-Anfrage an die OpenWeatherMap-API durchführen.
import requests
import os
from typing import Dict, Any
# Stellen Sie sicher, dass Sie Ihren API-Schlüssel als Umgebungsvariable festgelegt haben
# Zum Beispiel, export OPENWEATHER_API_KEY="YOUR_API_KEY"
OPENWEATHER_API_KEY = os.getenv("OPENWEATHER_API_KEY")
def get_current_weather(city: str, unit: str = "metric") -> Dict[str, Any]:
"""
Ruft die aktuellen Wetterbedingungen für eine angegebene Stadt ab.
Args:
city (str): Der Name der Stadt (zum Beispiel "London", "New York").
unit (str): Die Temperatureinheit. Kann "metric" (Celsius) oder "imperial" (Fahrenheit) sein. Standardmäßig "metric".
Returns:
dict: Ein Wörterbuch mit Wetterinformationen oder einer Fehlermeldung.
"""
if not OPENWEATHER_API_KEY:
return {"error": "OpenWeatherMap API-Schlüssel nicht gesetzt."}
base_url = "http://api.openweathermap.org/data/2.5/weather"
params = {
"q": city,
"appid": OPENWEATHER_API_KEY,
"units": unit
}
try:
response = requests.get(base_url, params=params)
response.raise_for_status() # Löst einen HTTPError für schlechte Antworten (4xx oder 5xx)
data = response.json()
if data.get("cod") == "404":
return {"error": f"Stadt '{city}' nicht gefunden."}
weather_description = data["weather"][0]["description"]
temperature = data["main"]["temp"]
feels_like = data["main"]["feels_like"]
humidity = data["main"]["humidity"]
wind_speed = data["wind"]["speed"]
return {
"city": city,
"description": weather_description,
"temperature": temperature,
"feels_like": feels_like,
"humidity": humidity,
"wind_speed": wind_speed,
"unit": "Celsius" if unit == "metric" else "Fahrenheit"
}
except requests.exceptions.RequestException as e:
return {"error": f"Netzwerk- oder API-Fehler: {e}"}
except KeyError as e:
return {"error": f"Fehler beim Analysieren der Wetterdaten: fehlender Schlüssel {e}. Antwort: {data}"}
Schritt 3: Erstellen Sie das Tool für den Agenten
from langchain.tools import create_function_tool
weather_tool = create_function_tool(
func=get_current_weather,
name="get_current_weather",
description=(
"Ein Tool zum Abrufen der aktuellen Wetterbedingungen für eine angegebene Stadt. "
"Nützlich, wenn nach dem aktuellen Wetter, der Temperatur oder den Bedingungen an einem Standort gefragt wird. "
"Geben Sie den Namen der Stadt und optional die Einheit an (metrisch für Celsius, imperial für Fahrenheit)."
)
)
print(weather_tool.name)
print(weather_tool.description)
Beachten Sie die detaillierte Beschreibung, die dem LLM hilft zu verstehen, wann dieses Tool verwendet werden soll und welche Parameter es benötigt.
Schritt 4: Integrieren und Testen
Fügen Sie das neue Tool zur Liste der Tools Ihres Agenten hinzu und testen Sie es.
# ... (frühere Importe und LLM-Konfiguration)
# Kombinieren Sie unsere Tools
tools = [add_tool, weather_tool]
# Erstellen Sie den Agenten und den Executor wie zuvor
agent = create_openai_tools_agent(llm, tools, prompt)
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
# Testen Sie das Wetter-Plugin
response_weather = agent_executor.invoke({"input": "Wie ist das Wetter in Tokio?"})
print(response_weather["output"])
response_weather_imperial = agent_executor.invoke({"input": "Wie hoch ist die Temperatur in New York in Fahrenheit?"})
print(response_weather_imperial["output"])
response_invalid_city = agent_executor.invoke({"input": "Sag mir, wie das Wetter in Nocityhere ist."})
print(response_invalid_city["output"])
Erwartetes Ergebnis (wird je nach aktuellem Wetter und API-Schlüssel-Konfiguration variieren):
> Eingabe in eine neue AgentExecutor-Kette...
Nachdenken:
Der Benutzer fragt nach dem Wetter in Tokio. Das Tool `get_current_weather` ist für diese Aufgabe geeignet.
Ich sollte `get_current_weather` mit `city='Tokyo'` aufrufen.
Aktion:
```json
{
"tool_name": "get_current_weather",
"args": {
"city": "Tokyo"
}
}
```
Beobachtung: {'city': 'Tokyo', 'description': 'leichter Regen', 'temperature': 15.2, 'feels_like': 14.8, 'humidity': 90, 'wind_speed': 3.09, 'unit': 'Celsius'}
Nachdenken:
Das Wetter in Tokio ist leichter Regen mit einer Temperatur von 15.2 Celsius, gefühlt wie 14.8 Celsius. Die Luftfeuchtigkeit beträgt 90 % und die Windgeschwindigkeit liegt bei 3.09 m/s.
Endgültige Antwort: In Tokio ist das aktuelle Wetter leichter Regen, mit einer Temperatur von 15.2°C (gefühlt wie 14.8°C). Die Luftfeuchtigkeit beträgt 90 % und die Windgeschwindigkeit liegt bei 3.09 m/s.
> Kette beendet.
In Tokio ist das aktuelle Wetter leichter Regen, mit einer Temperatur von 15.2°C (gefühlt wie 14.8°C). Die Luftfeuchtigkeit beträgt 90 % und die Windgeschwindigkeit liegt bei 3.09 m/s.
Erweiterte Überlegungen und Best Practices
Fehlerbehandlung
Wie im Wetterbeispiel gesehen, interagieren reale Plugins mit externen Systemen, die ausfallen können. Implementieren Sie immer eine solide Fehlerbehandlung (try-except-Blöcke), um Netzwerkprobleme, API-Fehler oder unerwartete Datenformate abzufangen. Geben Sie informative Fehlermeldungen zurück, damit der Agent versteht, was schief gelaufen ist und dies möglicherweise dem Benutzer mitteilen oder einen alternativen Ansatz ausprobieren kann.
Klare und spezifische Beschreibungen
Das kann nicht genug betont werden. Die Fähigkeit des LLM, das richtige Tool auszuwählen, hängt fast vollständig von der Qualität der Beschreibung Ihres Plugins ab. Fügen Sie ein:
- Was das Tool tut.
- Wann es verwendet werden sollte.
- Welche Argumente es erwartet und deren Typen/Zwecke.
- Alle Einschränkungen oder Nebeneffekte.
Parametervalidierung
Obwohl das LLM versucht, die Parameter zu inferieren, ist es ratsam, Eingabevalidierungen innerhalb Ihrer Plugin-Funktionen durchzuführen. Dies verhindert, dass unerwartete Daten Probleme verursachen, falls das LLM einen Fehler macht oder der Benutzer eine falsch formatierte Eingabe angibt.
Asynchrone Operationen
Für Plugins, die langwierige Operationen umfassen (zum Beispiel komplexe Abfragen in einer Datenbank, das Herunterladen großer Dateien), sollten Sie in Betracht ziehen, diese asynchron zu implementieren, um zu verhindern, dass der Ausführungsthread des Agenten blockiert wird. Viele Frameworks unterstützen asynchrone Tools.
Zustandsverwaltung (Fortgeschritten)
Die meisten einfachen Plugins sind zustandslos. Für komplexere Interaktionen könnte ein Agent jedoch notwendig sein, einen Zustand über mehrere Runden oder Plugin-Aufrufe hinweg zu halten. Dies ist ein fortgeschrittenes Thema und umfasst oft, dass das Agenten-Framework die Konversationshistorie oder einen speziellen Zustands-Speicher verwaltet.
Sicherheit
Achten Sie auf die Sicherheit, wenn Sie Funktionen über Plugins expose. Ein Agent könnte möglicherweise dazu verleitet werden, ein Plugin zu missbrauchen, wenn es nicht ordnungsgemäß gesichert ist. Erwägen Sie:
- Zugriffskontrolle: Stellen Sie sicher, dass Plugins nur auf die Ressourcen zugreifen, für die sie autorisiert sind.
- Eingabesäuberung: Verhindern Sie Injection-Angriffe, wenn die Plugin-Eingaben an Datenbanken oder Shell-Befehle übergeben werden.
- Minimalprivileg: Geben Sie den Plugins nur die minimal erforderlichen Berechtigungen, um ihre Aufgabe zu erfüllen.
Tool-Kette und Schlussfolgerung
Die wahre Stärke von Agenten zeigt sich, wenn sie mehrere Tools miteinander verknüpfen können. Beispielsweise könnte ein Agent zuerst ein ‘Such’-Tool verwenden, um relevante Informationen zu finden, dann ein ‘Synthese’-Tool, um sie zu destillieren, und schließlich ein ‘E-Mail’-Tool, um die Zusammenfassung zu senden. Gestalten Sie Ihre Plugins so, dass sie atomar und kombinierbar sind, um dem Agenten zu ermöglichen, sie flexibel zu kombinieren.
Fazit
Das Erstellen von Plugins für Agenten ist eine leistungsstarke Methode, um die Fähigkeiten großer Sprachmodelle zu erweitern und sie von ausgeklügelten Textgeneratoren in intelligente, handlungsorientierte Agenten zu verwandeln. Indem Sie diesen schnellen Startleitfaden befolgen und die grundlegenden Prinzipien verstehen, können Sie beginnen, externe Daten, Dienste und komplexe Logik in Ihre KI-Anwendungen zu integrieren.
Vergessen Sie nicht, sich auf klare Beschreibungen, eine solide Fehlerbehandlung zu konzentrieren und Funktionen zu entwerfen, die atomar und kombinierbar sind. Wenn Sie sich sicherer fühlen, können Sie fortgeschrittene Themen wie asynchrone Operationen, Zustandsverwaltung und Sicherheit erkunden, um immer ausgeklügeltere und zuverlässigere KI-Agenten zu erstellen. Die Zukunft der Interaktion mit KI liegt in diesen erweiterten Fähigkeiten, und indem Sie die Entwicklung von Plugins beherrschen, stehen Sie an der Spitze dieser spannenden Grenze.
🕒 Published: