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 unglaublich leistungsstark, 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 bloße Textgenerierung hinaus erweitern. Hier kommen die Agenten-Plugins ins Spiel. Agenten-Plugins sind im Wesentlichen Werkzeuge oder Funktionen, die ein KI-Agent auswählen kann, um spezifische Aufgaben auszuführen, auf externe Informationen zuzugreifen oder mit anderen Systemen zu interagieren. Sie überbrücken die Kluft zwischen den Denkfähigkeiten des LLM und der Außenwelt, indem sie ein Sprachmodell in einen anspruchsvollen, zielorientierten Agenten verwandeln.
Stellen Sie sich einen KI-Assistenten vor, der nicht nur Ihre Anfrage versteht, „das nächste italienische Restaurant zu finden“, sondern tatsächlich im Internet surfen, Ergebnisse filtern und Wegbeschreibungen bereitstellen kann. Diese Funktionalität wird durch Plugins erreicht. Diese Plugins ermöglichen es dem Agenten:
- Auf Echtzeitdaten zuzugreifen: Aktuelle Wetterdaten, Aktienkurse, Nachrichten oder Datenbankinformationen abzurufen.
- Aktionen durchzuführen: E-Mails zu senden, Termine zu planen, Smart-Home-Geräte zu steuern oder mit APIs zu interagieren.
- LLM-Einschränkungen zu überwinden: Komplexe Berechnungen durchzuführen, Code auszuführen oder präzise faktische Informationen abzurufen, die möglicherweise außerhalb des Umfangs seiner Trainingsdaten liegen.
Dieser Leitfaden führt Sie durch die praktischen Schritte zum Erstellen von Agenten-Plugins und konzentriert sich auf einen schnellen Einstieg mit klaren Beispielen, um Ihnen den Start zu erleichtern.
Verstehen der Grundkonzepte
Wie Agenten Plugins verwenden
Im Kern arbeitet ein KI-Agent in einer „denken-planen-handeln“-Schleife. Wenn ihm eine Eingabe präsentiert wird, denkt der Agent zunächst darüber nach, welche Vorgehensweise am besten ist. Wenn er feststellt, dass ein externes Werkzeug (Plugin) notwendig ist, um die Anfrage zu erfüllen, wird er planen, welches Plugin er verwenden möchte, welche Argumente weitergegeben werden sollen, und dann handeln, indem er dieses Plugin aufruft. Die Ausgabe des Plugins wird dann an den Agenten zurückgegeben, der diese neuen Informationen nutzt, um seinen Denkprozess fortzusetzen und eine abschließende Antwort zu formulieren.
Wichtige 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 kurze Erklärung, was das Plugin macht. Dies ist entscheidend, da das LLM diese Beschreibung verwendet, um zu entscheiden, wann und wie es das Plugin verwenden kann.
- Parameter/Schema: Eine Definition der Eingaben, die das Plugin erwartet, oft beschrieben mithilfe eines Schemas (wie JSON Schema). Dies teilt dem LLM mit, welche Argumente bereitgestellt werden sollen.
- 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 gängiges Python-basiertes Framework, das die Entwicklung von Agenten erleichtert. Viele Frameworks wie LangChain, LlamaIndex oder sogar die Rohfunktionalität von OpenAI bieten ähnliche Mechanismen. Wir konzentrieren uns auf die übertragbaren Prinzipien.
Voraussetzungen
- Python installiert (3.8+)
- Eine virtuelle Umgebung (empfohlen)
- Grundlegendes Verständnis von Python-Funktionen
Beispiel 1: Ein einfaches Taschenrechner-Plugin
Lassen Sie uns mit einem sehr einfachen Plugin beginnen, das Addition durchführt. Während ein LLM einfache Mathematik machen kann, veranschaulicht dies den Prozess klar.
Schritt 1: Definieren Sie die Plugin-Funktion
Zuerst erstellen wir eine standardmäßige Python-Funktion, die die gewünschte Operation ausfü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 kommen die Frameworks ins Spiel. Sie stellen Dekoratoren oder spezifische Klassen bereit, um eine reguläre Python-Funktion in ein agentenaufrufbares Werkzeug zu verwandeln. Wir müssen eine Beschreibung bereitstellen, und implizit wird das LLM die Parameter aus der Funktionssignatur und den Docstrings ableiten.
Lassen Sie uns eine konzeptionelle Rahmenrepräsentation verwenden (ähnlich, wie LangChain oder LlamaIndex es abstrahieren würde):
# Verwendung einer konzeptionellen 'Tool'-Klasse (ähnlich wie LangChains Tool oder LlamaIndexs FunctionTool)
class CalculatorTool:
def __init__(self):
self.name = "add_numbers"
self.description = (
"Ein Werkzeug 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, die addiert werden soll"},
"num2": {"type": "number", "description": "Die zweite Zahl, die addiert werden soll"}
},
"required": ["num1", "num2"]
}
# Oder, praktischer, indem man die integrierte Werkzeugerstellung eines Frameworks verwendet:
# Beispiel mit LangChains create_function_tool
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 Werkzeug 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 von der Funktionssignatur ab
Die beschreibung ist entscheidend. Das LLM verlässt sich stark darauf, um den Zweck des Plugins und wann es aufgerufen werden soll, zu verstehen. Machen Sie es klar, prägnant und heben Sie seinen Nutzen hervor.
Schritt 3: Integrieren Sie es mit einem Agenten
Jetzt müssen wir dieses Werkzeug einem KI-Agenten bereitstellen. Dies umfasst typischerweise die Instanziierung eines LLM und einer Agentenklasse und das Übergeben unserer Liste von Werkzeugen an es.
Als Beispiel mit LangChain:
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 Werkzeuge, die wir erstellt haben
tools = [add_tool]
# Holt die Eingabe vom LangChain-Hub
prompt = hub.pull("hwchase17/openai-tools-agent")
# Erstellen Sie den Agenten
agent = create_openai_tools_agent(llm, tools, prompt)
# Erstellen Sie einen Agenten-Executor, um den Agenten auszuführen
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
# Jetzt lassen Sie uns das ausführen!
response = agent_executor.invoke({"input": "Was ist 123 + 456?"})
print(response["output"])
Wenn Sie dies ausführen, sehen Sie den Denkprozess des Agenten (wenn verbose=True):
> Betritt neue AgentExecutor-Kette...
Gedanke:
Der Benutzer bittet darum, zwei Zahlen zu addieren. Das `add_numbers`-Werkzeug eignet sich für diese Aufgabe.
Ich muss das `add_numbers`-Werkzeug mit `num1=123` und `num2=456` aufrufen.
Aktion:
```json
{
"tool_name": "add_numbers",
"args": {
"num1": 123,
"num2": 456
}
}
```
Beobachtung: 579.0
Gedanke:
Das `add_numbers`-Werkzeug gab 579.0 zurück. Dies 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
Lassen Sie uns ein praktisches Plugin erstellen, das aktuelle Wetterinformationen mithilfe einer öffentlichen API abruft. Wir werden die OpenWeatherMap-API für dieses Beispiel verwenden (Sie benötigen einen kostenlosen API-Schlüssel).
Schritt 1: API-Schlüssel erhalten
Gehen Sie zu OpenWeatherMap API und melden Sie sich für ein kostenloses Konto an, um einen API-Schlüssel zu erhalten.
Schritt 2: Definieren Sie die Plugin-Funktion
Diese Funktion wird eine HTTP-Anfrage an die OpenWeatherMap-API stellen.
import requests
import os
from typing import Dict, Any
# Stelle sicher, dass du deinen API-Schlüssel als Umgebungsvariable setzt
# Zum Beispiel: export OPENWEATHER_API_KEY="DEIN_API_SCHLÜSSEL"
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 (z.B. "London", "New York").
unit (str): Die Temperatureinheit. Kann "metric" (Celsius) oder "imperial" (Fahrenheit) sein. Standardwert ist "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öse 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 Parsen der Wetterdaten: fehlender Schlüssel {e}. Antwort: {data}"}
Schritt 3: Erstelle das Werkzeug 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 Werkzeug, um die aktuellen Wetterbedingungen für eine angegebene Stadt abzurufen. "
"Nützlich, wenn nach dem aktuellen Wetter, der Temperatur oder den Bedingungen an einem Ort gefragt wird. "
"Gib den Städtenamen und optional die Einheit an (metric für Celsius, imperial für Fahrenheit)."
)
)
print(weather_tool.name)
print(weather_tool.description)
Beachte die detaillierte Beschreibung, die dem LLM hilft zu verstehen, wann dieses Werkzeug verwendet werden sollte und welche Parameter benötigt werden.
Schritt 4: Integrieren und Testen
Füge das neue Werkzeug zur Werkzeugliste deines Agenten hinzu und teste es.
# ... (frühere Imports und LLM-Setup)
# Kombiniere unsere Werkzeuge
tools = [add_tool, weather_tool]
# Erstelle den Agenten und den Executor wie zuvor
agent = create_openai_tools_agent(llm, tools, prompt)
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)
# Teste 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": "Erzähle mir das Wetter in Nocityhere."})
print(response_invalid_city["output"])
Erwartete Ausgabe (variierend basierend auf tatsächlichem Wetter und API-Schlüssel-Setup):
> Eingabe der neuen AgentExecutor-Kette...
Gedanke:
Der Benutzer fragt nach dem Wetter in Tokio. Das Werkzeug `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'}
Gedanke:
Das Wetter in Tokio ist leichter Regen mit einer Temperatur von 15.2 Celsius, fühlt sich an wie 14.8 Celsius. Die Luftfeuchtigkeit beträgt 90% und die Windgeschwindigkeit liegt bei 3.09 m/s.
Endgültige Antwort: In Tokio beträgt das aktuelle Wetter leichter Regen, mit einer Temperatur von 15.2°C (fühlt sich an wie 14.8°C). Die Luftfeuchtigkeit beträgt 90% und die Windgeschwindigkeit liegt bei 3.09 m/s.
> Kette beendet.
In Tokio beträgt das aktuelle Wetter leichter Regen, mit einer Temperatur von 15.2°C (fühlt sich an wie 14.8°C). Die Luftfeuchtigkeit beträgt 90% und die Windgeschwindigkeit liegt bei 3.09 m/s.
Erweiterte Überlegungen und Best Practices
solide Fehlerbehandlung
Wie im Wetterbeispiel zu sehen ist, interagieren reale Plugins mit externen Systemen, die fehlerhaft sein können. Implementiere immer eine solide Fehlerbehandlung (try-except-Blöcke), um Netzwerkprobleme, API-Fehler oder unerwartete Datenformate abzufangen. Gib informative Fehlermeldungen zurück, damit der Agent versteht, was schiefgelaufen ist, und dies möglicherweise an den Benutzer kommunizieren oder einen alternativen Ansatz versuchen kann.
Klare und spezifische Beschreibungen
Das lässt sich nicht genug betonen. Die Fähigkeit des LLM, das richtige Werkzeug auszuwählen, hängt nahezu vollständig von der Qualität der Beschreibung deines Plugins ab. Schließe ein:
- Was das Werkzeug tut.
- Wann es verwendet werden sollte.
- Welche Argumente es erwartet und deren Typ/Purpose.
- Eventuelle Einschränkungen oder Nebenwirkungen.
Parametervalidierung
Obwohl das LLM versucht, Parameter abzuleiten, ist es eine gute Praxis, innerhalb deiner Plugin-Funktionen eine Eingangsvalidierung hinzuzufügen. Dies verhindert, dass unerwartete Daten Probleme verursachen, falls das LLM einen Fehler macht oder der Benutzer fehlerhafte Eingaben liefert.
Asynchrone Operationen
Für Plugins, die langwierige Operationen beinhalten (z.B. komplexe Datenbankabfragen, große Datei-Uploads), ziehe in Betracht, sie asynchron zu implementieren, um das Blockieren des Ausführungs-Threads des Agenten zu vermeiden. Viele Frameworks unterstützen asynchrone Werkzeuge.
Zustandsmanagement (fortgeschritten)
Die meisten einfachen Plugins sind zustandslos. Für komplexere Interaktionen könnte es jedoch erforderlich sein, dass ein Agent den Zustand über mehrere Runden oder Plugin-Aufrufe hinweg beibehält. Dies ist ein fortgeschrittenes Thema und erfordert oft, dass das Agent-Framework den Gesprächsverlauf oder einen speziellen Zustandsspeicher verwaltet.
Sicherheit
Achte auf Sicherheit, wenn du Funktionalitäten über Plugins zur Verfügung stellst. Ein Agent könnte potenziell zu einem Missbrauch eines Plugins provoziert werden, wenn es nicht ordnungsgemäß gesichert ist. Berücksichtige:
- Zugriffskontrolle: Stelle sicher, dass Plugins nur auf Ressourcen zugreifen, für die sie autorisiert sind.
- Eingabesäuberung: Verhindere Injektionsangriffe, wenn Plugin-Eingaben an Datenbanken oder Shell-Befehle übergeben werden.
- Minimalprivilegien: Gib Plugins nur die minimalen Berechtigungen, die erforderlich sind, um ihre Aufgabe auszuführen.
Werkzeugverkettung und -schlussfolgerungen
Die wahre Stärke von Agenten tritt zutage, wenn sie mehrere Werkzeuge zusammenketten können. Zum Beispiel könnte ein Agent zuerst ein ‘Suche’-Werkzeug verwenden, um relevante Informationen zu finden, dann ein ‘Zusammenfassen’-Werkzeug, um diese zu destillieren, und schließlich ein ‘E-Mail’-Werkzeug, um die Zusammenfassung zu versenden. Gestalte deine Plugins so, dass sie atomar und zusammensetzbar sind, damit der Agent sie flexibel kombinieren kann.
Schlussfolgerung
Das Erstellen von Agenten-Plugins ist eine kraftvolle Möglichkeit, die Fähigkeiten von großen Sprachmodellen zu erweitern und sie von komplexen Textgeneratoren in intelligente, handlungsorientierte Agenten zu verwandeln. Indem du dieser Schnellstartanleitung folgst und die grundlegenden Prinzipien verstehst, kannst du beginnen, externe Daten, Dienstleistungen und komplexe Logik in deine KI-Anwendungen zu integrieren.
Denk daran, dich auf klare Beschreibungen, solide Fehlerbehandlung und die Gestaltung atomarer, zusammensetzbarer Funktionen zu konzentrieren. Wenn du dich sicherer fühlst, kannst du fortgeschrittenere Themen wie asynchrone Operationen, Zustandsmanagement und Sicherheit erkunden, um zunehmend ausgeklügelte und zuverlässige KI-Agenten zu entwickeln. Die Zukunft der KI-Interaktion liegt in diesen erweiterten Fähigkeiten, und durch das Meistern der Plugin-Entwicklung befindest du dich an der Spitze dieses aufregenden Bereichs.
🕒 Published: