Hallo Familie Clawgo, hier ist Jake Morrison, der euch eine neue tiefgehende Erkundung der Welt der KI-Agenten bringt. Heute möchte ich über etwas sprechen, das in meinem eigenen Home-Labor seit einigen Wochen für Aufregung sorgt: wie man einen KI-Agenten dazu bringt, etwas Nützliches zu tun, nicht nur theoretisch Interessantes. Genauer gesagt, werden wir untersuchen, wie man einen Agenten dazu bringt, proaktiv Änderungen auf einer Website zu überwachen und darüber zu berichten. Vergesst für eine Minute das anspruchsvolle Gerede über die „Transformation der Branche“; lasst uns an einem praktischen Problem arbeiten.
Das Problem: Erkennung von Änderungen auf Websites (die schwierige Methode)
Hier ist das Szenario: Ich bin immer auf der Suche nach neuen Komponenten für meine verschiedenen Projekte der Hausautomatisierung. Manchmal ist ein bestimmter Sensor oder ein Mikrocontroller ausverkauft, und ich muss wissen, in dem Moment, in dem er wieder verfügbar ist. Eine Seite stündlich zu aktualisieren ist mühsam und, ehrlich gesagt, bin ich zu faul dafür. Ich habe diese allgemeinen Website-Änderungsbenachrichtigungsdienste ausprobiert, aber sie sind oft zu allgemein, zu langsam oder sie werden bei irrelevanten Änderungen wie einem Footer-Update ausgelöst.
Was ich wirklich brauchte, war etwas Intelligenteres. Etwas, das die **Absicht** dessen, was ich suchte, verstand. Hier kommt ein KI-Agent ins Spiel. Anstatt einfach den HTML-Code zu „vergleichen“, wollte ich einen Agenten, der die Seite lesen, den Verfügbarkeitsstatus des Produkts verstehen und mir spezifisch sagen kann, wann sich dieser Status auf „verfügbar“ ändert.
Mein erster Versuch: Einfaches Python-Skript (die brutale Methode)
Mein erster Versuch, wie es oft der Fall ist, bestand aus einem einfachen Python-Skript. Ich habe requests verwendet, um die Seite abzurufen, und BeautifulSoup, um sie zu analysieren. Das sah ungefähr so aus (vereinfachte Version, natürlich):
import requests
from bs4 import BeautifulSoup
import time
URL = "https://example-store.com/product-x-123"
KEYWORD = "Ausverkauft" # Oder "Verfügbar"
def check_stock():
try:
response = requests.get(URL)
response.raise_for_status() # Löst eine Ausnahme für HTTP-Fehler aus
soup = BeautifulSoup(response.text, 'html.parser')
# Das ist der heikle Teil: das spezifische Element finden
# Nehmen wir an, der Verfügbarkeitsstatus befindet sich in einem div mit der Klasse "product-status"
status_div = soup.find('div', class_='product-status')
if status_div and KEYWORD in status_div.text:
print(f"[{time.ctime()}] Produkt ist {KEYWORD}.")
return False # Immer noch ausverkauft
elif status_div:
print(f"[{time.ctime()}] Statusänderung des Produkts! Aktuell: {status_div.text.strip()}")
return True # Der Bestand hat sich geändert!
else:
print(f"[{time.ctime()}] Kann das Status-Div nicht finden.")
return False
except requests.exceptions.RequestException as e:
print(f"[{time.ctime()}] Fehler beim Abrufen der URL: {e}")
return False
# Basis-Schleife (dies würde unendlich laufen oder bis zum Stop)
# while True:
# if check_stock():
# print("ALARM SENDEN: Produkt wieder verfügbar!")
# # Hier die Benachrichtigungslogik hinzufügen (E-Mail, SMS, etc.)
# break # Stoppen, sobald gefunden
# time.sleep(3600) # Alle Stunde überprüfen
Das hat funktioniert, bis zu einem gewissen Punkt. Das Problem? Wenn die Website ihre HTML-Struktur nur geringfügig aktualisierte, würde meine Zeile soup.find('div', class_='product-status') brechen. Oder, wenn die Bezeichnung von „Ausverkauft“ auf „Derzeit Nicht Verfügbar“ wechselte, würde meine KEYWORD-Überprüfung fehlschlagen. Das erforderte ständige Wartung, was dem Ziel der Automatisierung widersprach.
Einsatz des KI-Agenten: Ein intelligenterer Ansatz
Hier begann ich, über einen echten KI-Agenten nachzudenken. Nicht nur ein Skript, das genaue Anweisungen befolgt, sondern etwas, das die Seite **interpretiert**. Mein Ziel war ein Agent, der in der Lage ist:
- Eine URL zu besuchen.
- Zu verstehen, wie ein „Verfügbarkeitsstatus des Produkts“ aussieht.
- Zu erkennen, ob das Produkt verfügbar ist oder nicht, basierend auf der **Bedeutung** des Textes, nicht nur auf genauen Schlüsselwörtern.
- Nur zu berichten, wenn der Status, der mich interessiert (z. B. „verfügbar“), erkannt wird.
Einrichtung des Agenten: Verwendung eines Basis-LLMs für die Interpretation
Für dieses Experiment beschloss ich, es relativ einfach zu halten. Ich verwende ein lokales LLM (speziell, ein verfeinertes Llama 3-Modell, das auf meinem Heimserver läuft, dank Ollama) und ein Python-Skript, um die Aktionen des Agenten zu orchestrieren. Der Agent selbst „lebt“ nicht in einer separaten Umgebung; es ist die Kombination aus Skript, LLM und den Werkzeugen, die er verwenden kann.
Die „Werkzeuge“ des Agenten
- Web Scraper: Eine Funktion, um den HTML-Inhalt einer URL abzurufen (ähnlich wie mein ursprüngliches Python-Skript, aber jetzt gibt es nur noch reines HTML an das LLM weiter).
- LLM-Schnittstelle: Eine Funktion, um Eingabeaufforderungen an meine lokale Llama 3-Instanz zu senden und Antworten zu erhalten.
- Benachrichtigungssystem: Ein einfacher E-Mail-Versender (oder sogar nur eine Druckausgabe vorerst).
Der Workflow des Agenten (vereinfacht)
So habe ich die Hauptschleife des Agenten entworfen:
- Seite abrufen: Verwenden Sie das Web Scraping-Tool, um das rohe HTML der Zielproduktseite zu erhalten.
- Mit dem LLM analysieren: Das HTML mit einer spezifischen Einladung an das LLM senden.
- Interpretieren und Entscheiden: Das LLM analysiert das HTML und entscheidet, ob das Produkt verfügbar ist.
- Änderung berichten: Wenn sich der Status auf „verfügbar“ geändert hat (und zuvor ausverkauft war), eine Benachrichtigung auslösen.
- Wiederholen: Auf einen bestimmten Intervall warten und den Prozess wiederholen.
Prompt-Engineering für die Bestandsüberwachung
Das war der entscheidende Teil. Mein Prompt für das LLM musste klar und prägnant sein. Hier ist ein Beispiel für das, was ich verwendet habe:
"Sie sind ein KI-Assistent, der darauf ausgelegt ist, den Verfügbarkeitsstatus eines Produkts auf einer Webseite zu erkennen.
Ich werde Ihnen den HTML-Inhalt einer Produktseite bereitstellen.
Ihre Aufgabe ist es, das HTML zu analysieren und zu bestimmen, ob das Produkt derzeit 'verfügbar' oder 'ausverkauft' ist.
Suchen Sie nicht nur nach genauen Sätzen; verstehen Sie den Kontext. Suchen Sie nach gängigen Indikatoren wie:
- den Schaltflächen 'In den Warenkorb' (zeigen in der Regel Verfügbarkeit an)
- den Nachrichten 'Ausverkauft'
- den Nachrichten 'Derzeit Nicht Verfügbar'
- 'Vorbestellung' (dies sollte als ausverkauft für einen sofortigen Kauf betrachtet werden)
- Jede Abweichung der Nachrichten über den Verfügbarkeitsstatus.
Geben Sie NUR eines der folgenden Wörter zurück: 'VERFÜGBAR' oder 'AUSVERKAUFT'.
Geben Sie keinen weiteren Text, keine Erklärung oder Formatierung an.
HTML-Inhalt:
" + html_content
Die Anweisung „Geben Sie NUR eines der folgenden Wörter zurück“ ist entscheidend für die programmatische Verarbeitung der LLM-Ausgabe. Dies ermöglicht es meinem Python-Skript, die Entscheidung des LLM leicht zu lesen und entsprechend zu handeln.
Alles Zusammenbringen (Konzeptioneller Code)
Obwohl die vollständige Implementierung mehr Fehlerbehandlung und Zustandsmanagement erfordert, hier ist die Hauptidee in Python:
import requests
import time
# Angenommen, Sie haben eine Funktion, um mit Ihrem LLM zu interagieren
# z.B. von my_llm_interface import query_llm
# Und eine Funktion, um Benachrichtigungen zu senden
# z.B. von my_notifier import send_alert
PRODUCT_URL = "https://example-store.com/product-x-123"
CHECK_INTERVAL_SECONDS = 3600 # Jede Stunde prüfen
last_known_status = "UNKNOWN" # Um Änderungen zu verfolgen
def get_html(url):
try:
response = requests.get(url, timeout=10)
response.raise_for_status()
return response.text
except requests.exceptions.RequestException as e:
print(f"Fehler beim Abrufen der URL: {e}")
return None
def determine_stock_status(html_content):
if not html_content:
return "ERROR"
prompt = f"""
Sie sind ein KI-Assistent, der dafür entwickelt wurde, den Lagerstatus eines Produkts auf einer Webseite zu erkennen.
Ich werde Ihnen den HTML-Inhalt einer Produktseite zur Verfügung stellen.
Ihre Aufgabe ist es, den HTML-Code zu analysieren und zu bestimmen, ob das Produkt derzeit 'auf Lager' oder 'nicht auf Lager' ist.
Suchen Sie nicht nur nach genauen Ausdrücken; verstehen Sie den Kontext. Achten Sie auf gängige Indikatoren wie:
- die Schaltflächen 'In den Warenkorb' (deuten normalerweise auf Lager hin)
- die Nachrichten 'Ausverkauft'
- die Nachrichten 'Derzeit nicht verfügbar'
- 'Vorbestellung' (als nicht auf Lager für einen sofortigen Kauf betrachten)
- Jede Variation von Lagerstatusnachrichten.
Geben Sie AUSSCHLIESSLICH eines der folgenden Wörter zurück: 'AUF_LAGER' oder 'NICHT_AUF_LAGER'.
Geben Sie keinen anderen Text, keine Erklärung oder Formatierung an.
HTML-Inhalt:
{html_content}
"""
# Hier würden Sie Ihr LLM aufrufen
# Zur Demonstration simulieren wir eine Antwort
# real_llm_response = query_llm(prompt)
# LLM-Antwort für den Test simulieren
if "In den Warenkorb" in html_content: # Einfache Heuristik für die Demo
real_llm_response = "AUF_LAGER"
elif "Ausverkauft" in html_content or "Nicht verfügbar" in html_content:
real_llm_response = "NICHT_AUF_LAGER"
else:
real_llm_response = "UNKNOWN"
return real_llm_response.strip().upper()
# Hauptschleife des Agenten
while True:
print(f"[{time.ctime()}] Prüfung des Lagerbestands des Produkts...")
html = get_html(PRODUCT_URL)
current_status = determine_stock_status(html)
if current_status == "ERROR":
print("Kann den Status aufgrund eines Abruffehlers nicht bestimmen. Später erneut versuchen.")
elif current_status == "AUF_LAGER" and last_known_status != "AUF_LAGER":
print("ALARM: Das Produkt ist jetzt AUF LAGER!")
# send_alert(f"Produkt {PRODUCT_URL} ist wieder auf Lager!") # Ihre Logik zur Benachrichtigung
last_known_status = "AUF_LAGER"
elif current_status == "NICHT_AUF_LAGER" and last_known_status != "NICHT_AUF_LAGER":
print("Das Produkt ist NICHT AUF LAGER.")
last_known_status = "NICHT_AUF_LAGER"
else:
print(f"Der Status des Produkts ist {current_status}. Keine Änderung festgestellt.")
time.sleep(CHECK_INTERVAL_SECONDS)
Diese Konfiguration ermöglicht es dem Agenten, viel widerstandsfähiger gegenüber Änderungen im Layout oder in der Formulierung der Website zu sein. Das LLM, mit seinem Verständnis natürlicher Sprache, kann Variationen von “nicht auf Lager” interpretieren, ohne dass ich eine Liste von Schlüsselwörtern jedes Mal aktualisieren muss.
Die Ergebnisse: Ein Zuverlässigerer Monitor
Nachdem ich diesen Agenten einige Wochen lang laufen ließ, kann ich bestätigen, dass er deutlich zuverlässiger ist als mein ursprüngliches BeautifulSoup-Skript. Ich habe gesehen, wie Produktseiten ihre Nachricht “ausverkauft” geändert haben, Elemente verschoben wurden und sogar von Schaltflächen zu Textlinks für den Kauf übergegangen wurde. Mein KI-Agent, der auf der Interpretationskraft des LLM basiert, hat mir ständig präzise Updates zum Lagerstatus gegeben.
Einmal hat ein Geschäft seinen Button “In den Warenkorb” in “Benachrichtigen, wenn verfügbar.” geändert. Mein altes Skript hätte gesehen, wie “In den Warenkorb” verschwand und wäre durcheinandergekommen. Das LLM hingegen hat “Benachrichtigen, wenn verfügbar” korrekt als “NICHT_AUF_LAGER”-Status interpretiert, weil es die *Bedeutung* hinter diesen Ausdrücken versteht.
Es geht nicht darum, eine supersmarte allgemeine KI zu bauen, die Ihr Leben managt. Es geht darum, ein spezifisches und nerviges Problem anzugehen und ein wenig KI-Know-how anzuwenden, um es auf eine solidere Weise zu lösen, als es traditionelle Skripterstellung erlaubt. Es ist praktische KI, und das liebe ich an diesen Dingen.
Praktische Tipps
Wenn Sie experimentieren möchten mit KI-Agenten für praktische Automatisierung, sind hier meine besten Tipps:
- Klein anfangen, ein echtes Problem lösen: Versuchen Sie nicht, Skynet beim ersten Versuch zu bauen. Wählen Sie eine spezifische Aufgabe, die Sie manuell ausführen und die Sie als lästig empfinden. Die Überwachung meiner Website ist ein perfektes Beispiel.
- Verwendung von lokalen LLMs: Tools wie Ollama machen es unglaublich einfach, leistungsstarke LLMs auf Ihrer eigenen Hardware auszuführen. Das senkt die Kosten und schützt die Daten, was für persönliche Projekte großartig ist.
- Fokussieren Sie sich auf klare Anweisungen: Die “Intelligenz” des Agenten hängt oft von der Qualität Ihrer Anweisungen an das LLM ab. Seien Sie klar darüber, was Sie möchten, dass es tut und in welchem Format Sie die Ausgabe erwarten.
- Geben Sie Ihrem Agenten “Werkzeuge”: Ein LLM ist mächtig, muss aber mit der realen Welt interagieren. Stellen Sie ihm Funktionen zur Verfügung, um Daten abzurufen, Nachrichten zu senden oder Dateien zu manipulieren.
- Iterieren und verfeinern: Ihr erster Agent wird nicht perfekt sein. Testen Sie ihn, sehen Sie, wo er versagt, und verfeinern Sie Ihre Anweisungen oder seine Werkzeuge.
Die Welt der KI-Agenten ist noch jung, aber das Potenzial zur praktischen Automatisierung im Alltag ist enorm. Warten Sie nicht auf ein “revolutionäres” Produkt; beginnen Sie jetzt, Ihre eigenen nützlichen kleinen Agenten zu bauen. Sie werden überrascht sein, was Sie von Ihrer Aufgabenliste automatisieren können.
Das ist alles für diesen, Team Clawgo. Lassen Sie mich in den Kommentaren wissen, welche praktischen Agenten Sie bauen!
🕒 Published: