Die Nutzung von KI-Agenten in Python-Anwendungen erfordert keine umfassende Neugestaltung bestehender Skripte. Wenn Ihr Skript bereits nützliche Funktionen enthält, können Sie diese als Tools bereitstellen und einem großen Sprachmodell (LLM) die Entscheidung überlassen, wann und wie diese Funktionen aufgerufen werden.
In diesem Tutorial wird ein einfaches Skript zur Überwachung von Websites in einen KI-Agenten umgewandelt, wobei das OpenAI Agents SDK zum Einsatz kommt.
Ausgangspunkt: Ein normales Python-Skript
Bevor wir mit dem Aufbau eines KI-Agenten beginnen, betrachten wir zunächst ein einfaches Python-Programm. Angenommen, wir möchten überprüfen, ob eine Website reagiert und wie lange die Anfrage dauert:
```
from time import perf_counter
import requests
def check_website(url: str) -> str:
start = perf_counter()
try:
response = requests.get(url, timeout=10)
latency = perf_counter() - start
return (
f"{url}\n"
f"Status: {response.status_code}\n"
f"Response time: {latency:.2f}s"
)
except requests.RequestException as error:
return f"{url}\nError: {error}"
print(check_website("https://www.python.org"))
```
Die Ausgabe lautet:
``` https://www.python.org Status: 200 Response time: 0.99s ```
Das Skript erfüllt genau die programmierte Aufgabe: Es sendet eine HTTP-Anfrage, sammelt den Statuscode, misst die Antwortzeit und gibt das Ergebnis zurück. Dies ist nützlich, jedoch ist der Workflow vollständig festgelegt:
Wenn wir fünf Websites überprüfen, ihre Antwortzeiten vergleichen oder feststellen möchten, welche davon möglicherweise nicht gesund ist, müssen wir diese Logik selbst implementieren. Hier kommt der KI-Agent ins Spiel.
Anstatt jede Entscheidung in Python zu kodieren, können wir die Funktion check_website() als Tool bereitstellen und dem KI-Modell ein Ziel vorgeben. Das Modell kann dann entscheiden, wann das Tool aufgerufen wird, welche URL überprüft wird, wie oft es verwendet wird und was mit den Ergebnissen geschehen soll.
Schritt 1: Installation des Agents SDK
Zunächst richten Sie ein Python-Projekt ein und installieren die benötigten Pakete, um den Agenten zu erstellen und auszuführen.
Erstellen Sie ein neues Projekt:
``` mkdir website-agent cd website-agent uv init uv add openai-agents requests ```
Oder verwenden Sie pip:
``` pip install openai-agents requests ```
Setzen Sie Ihren OpenAI API-Schlüssel:
``` export OPENAI_API_KEY="your-api-key" ```
Das Agents SDK bietet eine leichtgewichtige Laufzeitumgebung für Agenten, Tools, Übergaben, Sitzungen und Nachverfolgung.
Schritt 2: Umwandlung der Python-Funktion in ein Tool
Im nächsten Schritt machen wir unsere bestehende Python-Funktion zu einem Tool, das das Modell auswählen kann. Wir können fast die gesamte bestehende Funktion beibehalten. Die Hauptänderung besteht darin, @function_tool hinzuzufügen:
```
from time import perf_counter
import requests
from agents import function_tool
@function_tool
def check_website(url: str) -> str:
"""Check a website's HTTP status and response time."""
start = perf_counter()
try:
response = requests.get(url, timeout=10)
latency = perf_counter() - start
return (
f"URL: {url}\n"
f"Status: {response.status_code}\n"
f"Response time: {latency:.2f}s"
)
except requests.RequestException as error:
return f"URL: {url}\nError: {error}"
```
Das OpenAI Agents SDK konvertiert automatisch die Funktionssignatur in das JSON-Schema, das vom Modell benötigt wird. Es verwendet auch den Funktionsnamen und die Dokumentation, um das Tool zu beschreiben. Wir müssen kein Tool-Schema manuell erstellen.
Schritt 3: Erstellung des Agenten
Nun erstellen wir einen Agenten, definieren, was er tun soll, und geben ihm Zugriff auf unser check_website() Tool.
``` from agents import Agent, Runner agent = Agent( name="Website Monitor", model="gpt-5.6-luna", instructions=""" Monitor websites using the available tool. Compare results and explain problems clearly. """, tools=[check_website], ) ```
Führen Sie den Agenten aus:
``` result = Runner.run_sync( agent, "Check python.org, github.com, and openai.com. " "Which one has the slowest response?" ) print(result.final_output) ```
Die Ausgabe lautet:
``` python.org is the slowest, responding in **1.59 seconds**. - github.com: 0.83s - openai.com: 0.49s All returned HTTP 200. ```
Früher hätten wir die Schleife und die Vergleichslogik selbst schreiben müssen:
```
for url in urls:
check_website(url)
```
Jetzt interpretiert das Modell die Anfrage, ruft check_website() für die drei Websites auf, erhält die Ergebnisse, vergleicht sie und liefert die Antwort.
Funktionsweise der Agentenschleife
Im Hintergrund verwaltet der Runner die Interaktion zwischen dem Modell und den Tools. Konzeptuell sieht die Schleife folgendermaßen aus:
Wenn das Modell mehr Informationen benötigt, kann es das Tool erneut aufrufen. Die Schleife setzt sich fort, bis genügend Informationen vorliegen, um eine endgültige Antwort zu liefern. Dies macht den Workflow agentisch. Anstatt einer festen Abfolge, die vollständig in Python geschrieben ist, entscheidet das Modell, welche Aktionen basierend auf der Anfrage und den erhaltenen Ergebnissen zu ergreifen sind.
Weitere Python-Skripte, die Sie in Agenten umwandeln können
Das gleiche Muster funktioniert mit fast jeder bestehenden Python-Automatisierung. Sie behalten die Python-Funktionen, die die eigentliche Arbeit verrichten, und lassen den Agenten entscheiden, welche Funktionen aufgerufen werden und wie die Ergebnisse kombiniert werden.
- CSV-Analyzer: Funktionen filtern Zeilen, berechnen Kennzahlen und finden Trends. Der Agent beantwortet Fragen in natürlicher Sprache zu den Daten.
- Servermonitor: Funktionen überprüfen CPU, Speicher, Festplatte und Prozesse. Der Agent untersucht, warum ein Server möglicherweise nicht gesund aussieht.
- Log-Analyzer: Funktionen durchsuchen Protokolle, zählen Fehler und extrahieren Ereignisse. Der Agent untersucht Vorfälle und fasst zusammen, was passiert ist.
- API-Automatisierung: Funktionen holen Daten ab, aktualisieren Datensätze oder erstellen Berichte. Der Agent entscheidet, welche Operationen erforderlich sind und in welcher Reihenfolge.
Mit dem OpenAI Agents SDK können Sie bestehende Python-Funktionen mit @function_tool bereitstellen und sie zur tools-Liste des Agenten hinzufügen. Der Python-Code führt weiterhin die Arbeit aus; der Agent fügt natürliche Sprachverständnis, Toolauswahl und Orchestrierung hinzu.
Fazit
Agentische KI wird zunehmend zu einer praktischen Methode zur Automatisierung von Workflows, wobei immer mehr Unternehmen Agenten einsetzen, um mehrstufige Aufgaben zu bewältigen, anstatt sich auf feste Skripte zu verlassen. Gleichzeitig machen günstigere Modelle wie GPT-5.6 Luna es viel erschwinglicher, Tool-nutzende und sogar Multi-Agenten-Systeme in großem Maßstab zu betreiben.
In diesem Leitfaden haben wir mit einer normalen Python-Funktion begonnen, sie in ein Tool umgewandelt, sie mit einem Agenten verbunden und den Runner die Entscheidungsfindungsschleife verwalten lassen. Das ist die Kernidee hinter agentischen Anwendungen: geben Sie dem Modell ein Ziel und die richtigen Werkzeuge, und lassen Sie es entscheiden, wie die Aufgabe zu erledigen ist.
Quellen: kdnuggets
Bildquelle: KI generiert
Dieser Text wurde mit Hilfe von künstlicher Intelligenz in Zusammenarbeit mit unserer Redaktion erstellt.
🚀