Plugins für Agents erstellen: Ein praktischer Schnellstartleitfaden

Einführung : Die Macht der Agenten-Plugins

Im sich schnell entwickelnden Bereich der künstlichen Intelligenz werden große Sprachmodelle (LLMs) zunehmend sophistiziert. Allerdings haben selbst die fortschrittlichsten LLMs inhärente Einschränkungen: Sie funktionieren auf Basis ihrer Trainingsdaten, haben keinen Zugang zu Echtzeitinformationen und können nicht direkt mit externen Systemen interagieren oder spezifische Aktionen ausführen. Hier kommen die Agenten-Plugins ins Spiel. Die Agenten-Plugins ermöglichen es den LLMs, ihre Fähigkeiten zu erweitern und fungieren als Brücken zur Außenwelt. Sie erlauben einem KI-Agenten, Aufgaben auszuführen, für die er nicht explizit trainiert wurde, auf proprietäre Daten zuzugreifen, mit APIs zu interagieren und Aktionen in der realen Welt auszuführen.

Denken Sie an ein LLM wie an einen brillanten Geist mit umfangreichem Wissen, aber ohne Hände oder Augen über seine internen Daten hinaus. Ein Plugin gibt ihm diese Hände und Augen. Es verwandelt eine konversationelle KI in eine handlungsfähige KI, die nicht nur verstehen, sondern auch handeln kann. In diesem Artikel werden wir die praktischen Aspekte der Erstellung von Agenten-Plugins erkunden, wobei wir uns auf einen schnellen Einstieg mit konkreten Beispielen konzentrieren, um Ihnen den Beginn zu erleichtern.

Das Grundkonzept verstehen : LLM, Agent und Plugin

Bevor wir mit dem Programmieren beginnen, festigen wir unser Verständnis der Schlüsselaspekte:

• Großes Sprachmodell (LLM) : Die grundlegende KI, die die menschliche Sprache versteht und generiert. Es ist das Gehirn unseres Agenten. Beispiele: GPT-4, Claude, Llama 2.
• Agent : Eine intelligente Entität, die ein LLM nutzt, um zu schlussfolgern, zu planen und Aufgaben auszuführen. Die Aufgabe des Agenten besteht darin zu entscheiden, wann und wie die verfügbaren Werkzeuge (Plugins) eingesetzt werden, um das Ziel eines Benutzers zu erreichen. Dies beinhaltet oft eine Reflexions- und Schlussfolgerungsschleife.
• Plugin (oder Tool/Funktion) : Ein Stück Code, das der Agent aufrufen kann, um eine spezifische Aktion durchzuführen oder eine bestimmte Information abzurufen. Jedes Plugin hat ein klar definiertes Ziel, Eingabeparameter und eine erwartete Ausgabe.

Der Interaktionsfluss verläuft normalerweise wie folgt: Der Benutzer stellt eine Frage → Der Agent interpretiert die Anfrage → Der Agent entscheidet, ob ein Plugin erforderlich ist → Der Agent ruft das Plugin mit den entsprechenden Parametern auf → Das Plugin führt aus und gibt die Ergebnisse zurück → Der Agent verarbeitet die Ergebnisse und antwortet dem Benutzer.

Die Anatomie eines Agenten-Plugins

Obwohl spezifische Frameworks und Plattformen ihre eigenen Konventionen haben können, sind die grundlegenden Komponenten eines Agenten-Plugins bemerkenswert ähnlich:

1. Name : Eine eindeutige und beschreibende Kennung für das Plugin (z.B. getCurrentWeather, searchWikipedia, sendEmail).
2. Beschreibung : Eine klare und prägnante Erklärung, was das Plugin tut und wann es verwendet werden sollte. Dies ist entscheidend, damit das LLM seinen Zweck versteht und entscheidet, ob es aufgerufen werden soll.
3. Parameter (Schema) : Eine Definition der Eingaben, die das Plugin erwartet. Dies wird oft mit einem JSON-Schema beschrieben, das die Namen der Parameter, deren Typen, Beschreibungen und ob sie erforderlich sind, spezifiziert.
4. Implementierung (Code) : Der tatsächliche Code, der die gewünschte Aktion ausführt, wenn das Plugin aufgerufen wird. Dies könnte der Aufruf einer externen API, das Abfragen einer Datenbank, die Ausführung einer lokalen Berechnung oder die Interaktion mit einer Benutzeroberfläche sein.
5. Ausgabe : Die Daten, die vom Plugin nach der Ausführung zurückgegeben werden.

Schnellstart : Erstellung eines einfachen Wetter-Plugins

Lassen Sie uns ein praktisches Beispiel erkunden. Wir werden ein Plugin erstellen, das das aktuelle Wetter einer bestimmten Stadt abruft. Um es zu vereinfachen, verwenden wir eine fiktive API, aber die Prinzipien gelten direkt für reale APIs.

Schritt 1 : Zweck und Schnittstelle des Plugins definieren

Name : get_current_weather
Beschreibung : „Ruft die aktuellen Wetterbedingungen für eine angegebene Stadt ab. Nützlich, um Fragen zur Temperatur, Luftfeuchtigkeit und allgemeinen Wetterlage an einem bestimmten Ort zu beantworten.“
Parameter : Wir benötigen die city. Nehmen wir an, es handelt sich um eine Zeichenfolge und sie ist erforderlich.

Schritt 2 : Die Plugin-Funktion implementieren

Wir verwenden Python für unsere Beispiele, da es in der KI-Community weit verbreitet ist. Sie können jede beliebige Sprache verwenden, aber die Konzepte bleiben dieselben.

import json

def get_current_weather(city: str) -> dict:
 """
 Ruft die aktuellen Wetterbedingungen für eine angegebene Stadt ab.
 
 Args:
 city (str): Der Name der Stadt, um das Wetter abzurufen.
 
 Returns:
 dict: Ein Wörterbuch, das Wetterinformationen enthält (z. B. Temperatur, Bedingungen, Luftfeuchtigkeit).
 """
 # In einem realen Szenario würden Sie hier einen API-Aufruf machen,
 # zum Beispiel unter Verwendung von requests.get('https://api.weatherapi.com/v1/current.json?key=YOUR_KEY&q={city}')
 
 # Für dieses Beispiel geben wir fiktive Daten zurück
 mock_weather_data = {
 "London": {"temperature": 15, "conditions": "Bewölkt", "humidity": 80},
 "New York": {"temperature": 22, "conditions": "Sonnenklar", "humidity": 60},
 "Tokyo": {"temperature": 28, "conditions": "Regnerisch", "humidity": 90},
 "Paris": {"temperature": 18, "conditions": "Teilweise bewölkt", "humidity": 70},
 }
 
 weather = mock_weather_data.get(city, {"temperature": "N/A", "conditions": "Unbekannt", "humidity": "N/A"})
 
 return {"city": city, **weather}

Schritt 3 : Das Plugin für das LLM beschreiben (Funktionsaufruf-Schema)

Dies ist zweifellos der kritischste Schritt. Das LLM führt den Python-Code nicht direkt aus; es benötigt eine strukturierte Beschreibung des Plugins, um den richtigen Funktionsaufruf zu generieren. Die meisten LLM-Anbieter (OpenAI, Google, Anthropic usw.) bieten eine Funktion zur „Funktionsaufruf“ oder „Werkzeugnutzung“ an, bei der Sie ein JSON-Schema bereitstellen, das Ihre Funktionen beschreibt. So würde unser Wetter-Plugin beschrieben werden:

{
 "type": "function",
 "function": {
 "name": "get_current_weather",
 "description": "Ruft die aktuellen Wetterbedingungen für eine angegebene Stadt ab. Nützlich, um Fragen zur Temperatur, Luftfeuchtigkeit und allgemeinen Wetterlage an einem bestimmten Ort zu beantworten.",
 "parameters": {
 "type": "object",
 "properties": {
 "city": {
 "type": "string",
 "description": "Der Name der Stadt (z. B. London, New York, Tokyo)"
 }
 },
 "required": ["city"]
 }
 }
}

Schlüsselpunkte im Schema :

• type: "function" : Gibt an, dass es sich um eine Funktionsdefinition handelt.
• function.name : Entspricht genau unserem Namen der Python-Funktion.
• function.description : Das ist es, was das LLM liest! Seien Sie klar und detailliert. Fügen Sie Anwendungsfälle und Beispiele hinzu, falls dies hilfreich ist.
• function.parameters : Ein Standard-JSON-Schema-Objekt, das die Eingaben definiert.
• properties : Definiert jeden Parameter (city in unserem Fall).
• required : Liste der Parameter, die bereitgestellt werden müssen.

Integration mit einem LLM (Beispiel OpenAI)

Jetzt schauen wir uns an, wie ein LLM-Agent dieses Plugin verwenden würde. Wir werden die Funktionsaufruf-API von OpenAI als Beispiel verwenden, aber die Konzepte sind auf andere Anbieter übertragbar.

import openai
import os

# Angenommen, OPENAI_API_KEY ist in Ihren Umgebungsvariablen definiert
# openai.api_key = os.getenv("OPENAI_API_KEY") 

# Unser Werkzeug-Schema
tools = [
 {
 "type": "function",
 "function": {
 "name": "get_current_weather",
 "description": "Erhält die aktuellen Wetterbedingungen für eine angegebene Stadt. Nützlich zur Beantwortung von Fragen zu Temperatur, Luftfeuchtigkeit und allgemeinen Wettervorhersagen an einem bestimmten Ort.",
 "parameters": {
 "type": "object",
 "properties": {
 "city": {
 "type": "string",
 "description": "Der Name der Stadt (zum Beispiel, London, New York, Tokio)"
 }
 },
 "required": ["city"]
 }
 }
 }
]

# Die tatsächliche Python-Funktion, die wir zuvor definiert haben
def get_current_weather(city: str) -> dict:
 # ... (gleiche Implementierung wie oben) ...
 mock_weather_data = {
 "London": {"temperature": 15, "conditions": "Bewölkt", "humidity": 80},
 "New York": {"temperature": 22, "conditions": "Sonnig", "humidity": 60},
 "Tokyo": {"temperature": 28, "conditions": "Regnerisch", "humidity": 90},
 "Paris": {"temperature": 18, "conditions": "Teilweise bewölkt", "humidity": 70},
 }
 weather = mock_weather_data.get(city, {"temperature": "N/V", "conditions": "Unbekannt", "humidity": "N/V"})
 return {"city": city, **weather}

# Eine einfache Agentenschleife
def run_agent_with_tools(user_query: str):
 messages = [{
 "role": "user", 
 "content": user_query
 }]

 # Erster Aufruf an das LLM mit der Benutzeranfrage und den verfügbaren Werkzeugen
 response = openai.chat.completions.create(
 model="gpt-4o", # Oder gpt-3.5-turbo, usw.
 messages=messages,
 tools=tools,
 tool_choice="auto" # Ermöglicht dem LLM zu entscheiden, ob es ein Werkzeug aufrufen möchte
 )

 response_message = response.choices[0].message
 messages.append(response_message)

 # Prüfen, ob das LLM entschieden hat, ein Werkzeug aufzurufen
 if response_message.tool_calls:
 for tool_call in response_message.tool_calls:
 function_name = tool_call.function.name
 function_args = json.loads(tool_call.function.arguments)
 
 if function_name == "get_current_weather":
 # Führen Sie das Werkzeug aus und erhalten Sie das Ergebnis
 tool_output = get_current_weather(city=function_args.get("city"))
 
 # Fügen Sie die Ausgabe des Werkzeugs zur Konversationshistorie hinzu
 messages.append({
 "tool_call_id": tool_call.id,
 "role": "tool",
 "name": function_name,
 "content": json.dumps(tool_output)
 })
 
 # Zweiter Aufruf an das LLM mit der Ausgabe des Werkzeugs
 final_response = openai.chat.completions.create(
 model="gpt-4o",
 messages=messages
 )
 print(final_response.choices[0].message.content)
 else:
 print(f"Fehler: Unbekanntes Werkzeug aufgerufen: {function_name}")
 else:
 # Kein Werkzeugaufruf, nur eine direkte Antwort vom LLM
 print(response_message.content)

# Testfälle
print("--- Anfrage 1: Wetter in London ---")
run_agent_with_tools("Wie ist das Wetter in London?")

print("\n--- Anfrage 2: Wetter in New York ---")
run_agent_with_tools("Sagen Sie mir die aktuelle Temperatur in New York.")

print("\n--- Anfrage 3: Allgemeine Frage ---")
run_agent_with_tools("Was ist die Hauptstadt von Frankreich?")

print("\n--- Anfrage 4: Wetter in einer unbekannten Stadt ---")
run_agent_with_tools("Wie ist das Wetter in Atlantis?")

Erklärung der Agentenschleife:

1. Benutzeranfrage: Der Benutzer stellt eine Frage (zum Beispiel: „Wie ist das Wetter in London?“).
2. Erster LLM-Aufruf: Die Benutzeranfrage und die Liste der verfügbaren Werkzeuge (unseres get_current_weather Schemas) werden an das LLM gesendet. Das LLM analysiert die Anfrage und die Beschreibungen der Werkzeuge.
3. Entscheidung des LLM: Das LLM entscheidet basierend auf seinem Verständnis, ob es ein Werkzeug aufrufen soll.
• Wenn es entscheidet, ein Werkzeug aufzurufen, generiert es ein tool_calls Objekt, das den Namen des Werkzeugs und die Parameter angibt, die es übergeben möchte (zum Beispiel: {"name": "get_current_weather", "arguments": {"city": "London"}}).
• Wenn kein relevantes Werkzeug vorhanden ist, generiert es eine direkte textliche Antwort.
4. Ausführung des Werkzeugs: Wenn das LLM einen Werkzeugaufruf generiert, fängt unser Agentencode dies ab, extrahiert den Funktionsnamen und die Argumente und führt dann die tatsächliche Python-Funktion aus (get_current_weather("London")).
5. Zweiter LLM-Aufruf (mit Ausgabe des Werkzeugs): Das Ergebnis der Ausführung des Werkzeugs wird dann zurück an das LLM gesendet, zusammen mit der gesamten Konversationshistorie. Das LLM hat jetzt die ursprüngliche Anfrage des Benutzers, seine eigene Entscheidung, ein Werkzeug aufzurufen, und das konkrete Ergebnis dieses Werkzeugs.
6. Endgültige Antwort: Das LLM verwendet diese Informationen, um eine Antwort in natürlicher Sprache an den Benutzer zu formulieren und die Ausgabe des Werkzeugs zu integrieren.

Fortgeschrittene Konzepte von Plugins und Best Practices

Fehlerbehandlung und Zuverlässigkeit

Die APIs der realen Welt können fehlschlagen. Ihre Plugins sollten Fehler mit Leichtigkeit handhaben (Netzwerkprobleme, ungültige Eingaben, API-Rate-Limits usw.). Geben Sie informative Fehlermeldungen von Ihrem Plugin zurück, und das LLM kann diese oft nutzen, um den Benutzer zu informieren oder sogar einen neuen Versuch mit korrigierten Parametern zu unternehmen.

def get_current_weather_solid(city: str) -> dict:
 try:
 # Simulieren Sie einen API-Aufruf mit potenziellen Fehlern
 if city == "Error City":
 raise ValueError("Der API-Aufruf ist für Error City fehlgeschlagen: Dienst nicht verfügbar.")
 # ... Rest der erfolgreichen Mock-Datenlogik ...
 return {"city": city, **weather}
 except Exception as e:
 return {"error": str(e), "city": city}

Mehrere Plugins und Werkzeug-Orchestrierung

Die wahre Kraft eines Agenten liegt in der Nutzung mehrerer Plugins. Stellen Sie sich einen „Reiseplaner“-Agenten mit Plugins für Folgendes vor:

• search_flights(origin, destination, date)
• book_hotel(city, check_in, check_out)
• get_attractions(city)

Das LLM kann durch seinen Denkprozess diese Werkzeuge verknüpfen. Wenn ein Benutzer beispielsweise fragt: „Planen Sie eine Reise nach Paris nächsten Monat und finden Sie Dinge zu tun“, könnte das LLM zuerst search_flights aufrufen, dann book_hotel (wenn vom Benutzer bestätigt) und schließlich get_attractions.

Wenn Sie mehrere Werkzeuge bereitstellen, fügen Sie einfach weitere JSON-Schemas zur tools Liste in Ihrem LLM-Aufruf hinzu.

Schlussfolgerung und Reflexion der Agenten

Anspruchsvolle Agenten führen nicht einfach Werkzeuge aus; sie denken über ihre Aktionen nach. Frameworks wie LangChain und LlamaIndex bieten Abstraktionen dafür, wobei häufig Folgendes involviert ist:

• Planung: Zerlegen komplexer Ziele in Unteraufgaben.
• Werkzeugauswahl: Auswahl des am besten geeigneten Werkzeugs für jede Unteraufgabe.
• Parametergenerierung: Extrahieren der notwendigen Argumente aus dem Konversationskontext.
• Ausführung: Ausführen des Werkzeugs.
• Beobachtung: Interpretieren der Ausgabe des Werkzeugs.
• Reflexion: Bewerten, ob das Ziel erreicht wurde oder ob weitere Aktionen/Korrekturen erforderlich sind.

Die Beschreibung Ihres Plugins durch das LLM ist zentral für dieses Denken. Eine vage Beschreibung führt zu einer schlechten Werkzeugauswahl.

Sicherheitsüberlegungen

• Validierung von Eingaben: Validieren Sie immer die vom Plugin erhaltenen Eingaben, auch wenn das LLM sie generiert hat. Schadhafte oder unerwartete Eingaben können zu Sicherheitsanfälligkeiten führen.
• Prinzip der geringsten Privilegien: Stellen Sie sicher, dass Ihr Plugin nur Zugriff auf die Ressourcen hat, die es unbedingt benötigt.
• Sensible Daten: Seien Sie äußerst vorsichtig beim Umgang mit sensiblen Informationen. Vermeiden Sie es, Geheimnisse direkt in Pluginbeschreibungen oder -protokollen offenzulegen.
• Zugriffskontrolle/Ratenbegrenzung: Schützen Sie Ihre Backend-Systeme vor Missbrauch, indem Sie geeignete Ratenlimits und Authentifizierung für die zugrunde liegenden APIs Ihres Plugins implementieren.

Asynchrone Operationen

Viele reale Plugin-Aktionen (zum Beispiel E-Mail senden, lange Datenbankabfragen) sind asynchron. Ihr Agent muss dies möglicherweise verwalten, indem er eine Arbeits-ID zurückgibt und ein anderes Plugin verwendet, um den Arbeitsstatus zu überprüfen, oder indem er Webhooks einsetzt.

Fazit

Das Erstellen von Agenten-Plugins ist eine transformative Fähigkeit für jeden, der mit LLM arbeitet. Es geht über die einfache Konversation hinaus und ermöglicht es KI-Systemen, wirklich interaktiv und handlungsfähig zu werden. Indem Sie dem Schnellstartleitfaden folgen, haben Sie die grundlegenden Komponenten erlernt: die Zielsetzung des Plugins zu definieren, dessen Logik zu implementieren und, ganz entscheidend, es effektiv mit einem JSON-Schema für das LLM zu beschreiben. Die Kraft dieser Beschreibungen kann nicht übertrieben werden: Sie sind die Brücke zwischen dem sprachlichen Verständnis eines LLM und seiner Fähigkeit, mit der realen Welt zu interagieren.

Wenn Sie voranschreiten, vergessen Sie nicht, sich auf klare Beschreibungen, eine solide Fehlerverwaltung und eine durchdachte Orchestrierung mehrerer Tools zu konzentrieren. Die Zukunft der KI-Agenten liegt in ihrer Fähigkeit, harmonisch mit dem umfangreichen Ökosystem von Software und Daten zu integrieren, und die Plugins sind der Schlüssel, um dieses Potenzial freizusetzen. Beginnen Sie mit dem Experimentieren, erstellen Sie Ihre eigenen maßgeschneiderten Tools und sehen Sie zu, wie Ihre KI-Agenten zum Leben erwachen!

🕒 Published: March 29, 2026