Hallo, angehender Agent! Emma hier, zurück von einem weiteren nächtlichen Tauchgang in die faszinierende, manchmal frustrierende Welt der KI-Agenten. Wenn du wie ich bist, hast du wahrscheinlich die letzten Monate damit verbracht, flüsternde (oder schreiende) Gerüchte über KI-Agenten zu hören, und dir gedacht: „Okay, das klingt cool, aber auch… was ist das wirklich, und wie bekomme ich einen, der etwas für mich macht?“
Nun, du bist am richtigen Ort. Heute werden wir nicht einfach darüber sprechen, was KI-Agenten *theoretisch* sind. Wir werden uns die Ärmel hochkrempeln und eine Frage angehen, die viele von euch (und mich bis vor kurzem) beschäftigt: Wie konstruiert man einen einfachen KI-Agenten, der tatsächlich im Internet surfen und spezifische Fragen beantworten kann?
Lass uns den ganzen Hype für einen Moment vergessen. Wir werden uns auf das Praktische konzentrieren. Unser Ziel ist: „Ich kann das wirklich auf meinem Laptop zum Laufen bringen.“ Denn ehrlich gesagt, sehen ist glauben, oder?
Meine eigenen Fehler (und Erfolge) mit dem Browser
Als ich anfing, mit der Idee eines Agenten zu experimentieren, der das Internet nutzen kann, hatte ich große Visionen. Ich wollte, dass er komplexe Themen recherchiert, Preise auf einem Dutzend Websites vergleicht und im Grunde mein persönlicher digitaler Assistent ist. Was ich anfangs bekam, waren viele Fehler, ein paar kaputte Web-Scraper und ein tiefes Gefühl der Unzulänglichkeit. Meine ersten Versuche waren wie der Versuch, einem Kleinkind beizubringen, eine komplexe Maschine zu bedienen – viel Enthusiasmus, kein Verständnis für die zugrunde liegenden Mechanismen.
Das größte Hindernis? Einen KI-Modell dazu zu bringen, sinnvoll und kontrolliert mit dem Internet zu interagieren. Es ist eine Sache, ChatGPT eine Frage zu stellen, auf die es bereits die Antwort kennt. Es ist etwas anderes, ihm zu sagen, dass es neue Informationen suchen, diese interpretieren und dann entsprechend handeln soll. Genau hier kommt der Teil „Agent“ wirklich ins Spiel.
Nach vielen Versuchen und Fehlern habe ich festgestellt, dass der Schlüssel nicht darin besteht, sofort eine super komplexe und omnipotente Entität zu bauen. Man muss klein anfangen, mit einer sehr spezifischen Aufgabe, und sich von dort aus entwickeln. Und genau das werden wir heute tun. Wir werden einen einfachen Browser-Agenten erstellen, der eine bestimmte Website besucht, Informationen extrahiert und einen Bericht erstellt.
Was ist ein KI-Browser-Agent?
Bevor wir in den Code eintauchen, lass uns schnell klären. Ein KI-Agent ist im Grunde ein KI-Programm, das entwickelt wurde, um eine spezifische Aufgabe autonom zu erfüllen. Es beobachtet seine Umgebung (in unserem Fall das Internet), trifft Entscheidungen basierend auf seinen Zielen und handelt dann. Ein *Browser*-KI-Agent verwendet speziell die Fähigkeit zum Web-Browsing als Werkzeug.
Denk daran so: Du sagst deinem Agenten: „Finde mir das aktuelle Wetter in London.“ Statt einfach auf sein internes Wissen zurückzugreifen, würde ein Browser-Agent idealerweise einen Webbrowser öffnen, zu einer Wetter-Website navigieren, die Information finden und sie dir dann mitteilen. Das ist der Unterschied, ob man einen Bibliothekar fragt, der bereits die Antwort kennt, oder ihn bittet, ein Buch zu suchen, ein bestimmtes Kapitel zu lesen und es für dich zusammenzufassen.
Für unseren einfachen Agenten werden wir ein paar gebräuchliche Python-Bibliotheken verwenden, die den gesamten Prozess viel weniger einschüchternd machen.
Die Werkzeuge, die wir benötigen
Du brauchst keinen Supercomputer dafür. Nur deine gewohnte Entwicklungsumgebung. Hier ist, was wir verwenden werden:
- Python: Unsere bevorzugte Programmiersprache. (Ich benutze Version 3.9, aber 3.8+ sollte auch ausreichen.)
requests: Eine großartige Bibliothek, um HTTP-Anfragen zu stellen (d. h. Web-Seiten abzurufen).BeautifulSoup(bs4): Unser Zauberer für das Web-Parsen. Er hilft uns, Daten aus HTML zu navigieren und zu extrahieren.- Eine API für großes Sprachmodell (LLM): Wir benötigen Zugang zu einem LLM wie den GPT-Modellen von OpenAI oder Claude von Anthropic. Für dieses Tutorial setze ich voraus, dass du einen OpenAI-API-Schlüssel hast.
Zuerst richten wir unsere Umgebung ein. Wenn du diese Bibliotheken nicht installiert hast, öffne dein Terminal oder Eingabeaufforderung und führe aus:
pip install requests beautifulsoup4 openai
Und stelle sicher, dass du deinen OpenAI-API-Schlüssel griffbereit hast. Du musst ihn als Umgebungsvariable festlegen oder direkt in dein Skript eingeben. Zur Vereinfachung werde ich ihn direkt angeben, aber in der Produktion sind Umgebungsvariablen immer die bessere Wahl.
Unsere Mission: Einen spezifischen Artikel auf einem Blog finden
Lass uns ein konkretes und erreichbares Ziel setzen. Die Mission unseres Agenten wird es sein:
- Eine bestimmte Blog-Website zu besuchen (lasst uns vorerst eine fiktive Blog-URL verwenden oder sogar agent101.net, falls du mutig bist!).
- Ein Blogbeitrag mit einem spezifischen Schlüsselwort (zum Beispiel „Anfänger“) zu finden.
- Die URL dieses Blogbeitrags zu extrahieren.
- Den Inhalt dieses Blogbeitrags mit einem LLM zusammenzufassen.
Das ist ein fantastischer Ausgangspunkt, da es die Web-Interaktion mit dem Verständnis des LLM kombiniert. Es ist, als würdest du deinen digitalen Assistenten bitten: „Finde mir den neuesten Artikel über KI-Agenten für Anfänger auf agent101.net und sage mir, worum es darin geht.“
Schritt 1: Die Webseite abrufen
Der erste Schritt für jeden Browser-Agenten ist es, die Webseite zu „sehen“. Wir werden dafür die Bibliothek requests verwenden. Lass uns ein einfaches Skript machen:
import requests
def fetch_webpage(url):
try:
response = requests.get(url)
response.raise_for_status() # Löst eine HTTPError für fehlerhafte Antworten (4xx oder 5xx) aus
return response.text
except requests.exceptions.RequestException as e:
print(f"Fehler beim Abrufen der URL {url}: {e}")
return None
# Verwenden wir vorerst eine Platzhalter-URL.
# Ersetze sie durch eine echte Blog-URL, wenn du testen möchtest!
blog_url = "https://www.example-blog.com/articles" # Hier eine echte URL nutzen!
html_content = fetch_webpage(blog_url)
if html_content:
print("Webseiteninhalt erfolgreich abgerufen.")
# Wir werden diesen Inhalt im nächsten Schritt verarbeiten
else:
print("Fehler beim Abrufen der Webseite.")
Eine kurze Anmerkung zu den URLs: Damit das funktioniert, benötigst du eine echte Blog-URL. Wenn du keine zur Hand hast, kannst du eine Website wie `http://quotes.toscrape.com/` verwenden, um einfaches Scraping zu testen, aber für Blogeinträge finde bitte einen echten Blog. Selbst diese Seite, agent101.net, könnte funktionieren, wenn du die CSS-Selektoren später entsprechend anpasst!
Schritt 2: Das HTML analysieren und Artikel-Links finden
Jetzt, wo wir das rohe HTML haben, ist es, als hätten wir ein riesiges Buch ohne Index. BeautifulSoup ist unser Indexierer. Wir müssen ihm sagen, wie er die Titel der Artikel und die entsprechenden Links finden kann.
Dies ist der kniffligste Teil, da die HTML-Struktur jeder Website unterschiedlich ist. Du musst das Element auf der Zielseite „inspektieren“. Mache einen Rechtsklick auf einen Titel eines Artikels deines gewählten Blogs und wähle „Untersuchen“ (oder „Element untersuchen“). Suche nach gemeinsamen Mustern wie den <h2>-Tags für Titel oder den <a>-Tags für Links, die oft in einem <div> mit einem spezifischen Klassennamen verschachtelt sind.
Für die Demonstration nehmen wir eine gängige Blogstruktur an, in der die Titel der Artikel in <h2>-Tags und die Links in einem <a>-Tag direkt darin oder davor zu finden sind.
from bs4 import BeautifulSoup
def find_article_links(html_content, keyword):
soup = BeautifulSoup(html_content, 'html.parser')
article_data = []
# Dies ist ein generisches Beispiel. Sie müssen die Selektoren an die Zielseite anpassen.
# Häufige Muster: div mit der Klasse 'article-item', h2 mit der Klasse 'article-title', usw.
# Angenommen, die Artikel befinden sich in 'div'-Elementen mit der Klasse 'post'
# und die Titel sind in 'h2'-Tags innerhalb dieser divs, mit einem Link darin.
# Beispiel: Suchen Sie alle -Tags, die Titel von Artikeln enthalten könnten
# Überprüfen Sie dann, ob sie verlinkt sind.
# Ein robusterer Ansatz könnte darin bestehen, zuerst die Container zu finden:
article_containers = soup.find_all('div', class_='article-card') # Passen Sie diese Klasse an!
if not article_containers:
# Wechseln Sie zu einer anderen Auswahl, wenn die erste nicht funktioniert
article_containers = soup.find_all('article') # Ein weiteres häufiges Tag
for container in article_containers:
title_tag = container.find('h2') # Oder 'h3', 'a', usw.
link_tag = container.find('a', href=True) # Finden Sie den ersten Link im Container
if title_tag and link_tag:
title = title_tag.get_text(strip=True)
href = link_tag['href']
# Stellen Sie sicher, dass die URL absolut ist, wenn sie relativ ist
if href.startswith('/'):
full_url = requests.compat.urljoin(blog_url, href)
else:
full_url = href
if keyword.lower() in title.lower():
article_data.append({'title': title, 'url': full_url})
return article_data
# ... (vorheriger Code für fetch_webpage) ...
if html_content:
search_keyword = "beginner" # Welchen Artikel suchen wir?
found_articles = find_article_links(html_content, search_keyword)
if found_articles:
print(f"\nGefundene Artikel mit '{search_keyword}':")
for article in found_articles:
print(f"- Titel : {article['title']}\n URL : {article['url']}")
# Für dieses Beispiel nehmen wir einfach den ersten gefundenen
target_article = found_articles[0]
else:
print(f"\nKein Artikel gefunden, der '{search_keyword}' enthält.")
target_article = None
else:
target_article = None
Wichtige Anpassung : Die Zeilen wie soup.find_all('div', class_='article-card') und container.find('h2') sind Platzhalter. Sie *müssen* sie an die tatsächliche HTML-Struktur des Blogs anpassen, den Sie anvisieren. Hier kommt das Inspizieren der Webseite ins Spiel. Mein bester Rat ist, groß zu beginnen (zum Beispiel `soup.find_all(‘a’)`, um alle Links zu erhalten) und dann mit Klassen oder IDs einzugrenzen.
Schritt 3 : Inhalt des Zielartikels extrahieren
Sobald wir die URL unseres Zielartikels haben, müssen wir seinen Inhalt abrufen und dann den Haupttext extrahieren. Das ist oft einfacher als das Analysieren einer Indexseite, da sich der Großteil des Inhalts der Artikel in einem Hauptinhalts-Tag <div> oder <article> befindet.
# ... (vorheriger Code) ...
import openai
import os
# Legen Sie Ihren OpenAI API-Schlüssel fest
# Beste Praxis: os.environ.get("OPENAI_API_KEY")
# Für dieses Beispiel direkte Zuweisung :
openai.api_key = "YOUR_OPENAI_API_KEY" # ERSETZEN SIE DIESES DURCH IHREN ECHTEN SCHLÜSSEL!
def extract_article_text(article_url):
article_html = fetch_webpage(article_url)
if not article_html:
return None
soup = BeautifulSoup(article_html, 'html.parser')
# Das hängt stark von der Struktur der Webseite ab.
# Häufige Muster: Finden Sie ein div mit der Klasse 'entry-content', 'article-body', 'main-content'
# Oder einfach die -Tags innerhalb des Haupttags des Artikels.
# Lassen Sie uns versuchen, die gemeinsamen Inhaltsbereiche zu finden.
content_div = soup.find('div', class_='entry-content') # Häufig bei WordPress
if not content_div:
content_div = soup.find('article') # Ein weiteres gutes allgemeines Tag
if not content_div:
# Im äußersten Fall, erhalten Sie alle Absatz-Tags
paragraphs = soup.find_all('p')
return "\n".join([p.get_text(strip=True) for p in paragraphs if p.get_text(strip=True)])
# Wenn wir ein spezifisches Inhalts-div/article gefunden haben, extrahieren wir den gesamten Text der Absätze
paragraphs = content_div.find_all('p')
article_text = "\n".join([p.get_text(strip=True) for p in paragraphs if p.get_text(strip=True)])
return article_text
if target_article:
print(f"\nInhalt wird abgerufen für : {target_article['title']}")
article_text_content = extract_article_text(target_article['url'])
if article_text_content:
# print(article_text_content[:500]) # Zeigt die ersten 500 Zeichen zur Überprüfung an
print("\nArtikeltext erfolgreich extrahiert. Lassen Sie uns mit der Zusammenfassung fortfahren.")
else:
print("Fehler beim Extrahieren des Artikeltextes.")
article_text_content = "" # Stellen Sie sicher, dass es nicht None für den nächsten Schritt ist
else:
article_text_content = ""
Nochmals, die Zeile soup.find('div', class_='entry-content') ist Ihr Hauptziel für die Anpassung. Verwenden Sie den Inspektor Ihres Browsers!
Schritt 4 : Mit einem LLM zusammenfassen
Schließlich ist es an der Zeit, die künstliche Intelligenz einzubeziehen! Wir werden den extrahierten Text an ein LLM füttern und ihn um eine Zusammenfassung bitten. Hier zeigt sich wirklich die “Intelligenz” unseres Agents.
# ... (vorheriger Code) ...
def summarize_text_with_llm(text):
if not text:
return "Kein Text zur Zusammenfassung bereitgestellt."
# Kürzen Sie den Text, wenn er zu lang für das Kontextfenster des Modells ist
# GPT-3.5-turbo hat ein Kontextfenster von 16k, aber es ist gut, vernünftig zu bleiben.
# Für einen Anfänger sollte man 4000-8000 Tokens anstreben.
# Etwa 1 Token = 4 Zeichen für englischen Text.
max_tokens_for_input = 12000 # Passen Sie das je nach Kapazität Ihres Modells und Kostenüberlegungen an
if len(text) > max_tokens_for_input * 4: # Grobe Schätzung der Zeichen
text = text[:max_tokens_for_input * 4]
print(f"Warnung: Text auf ~{max_tokens_for_input} Tokens zum LLM-Verarbeiten gekürzt.")
try:
response = openai.chat.completions.create(
model="gpt-3.5-turbo", # Oder "gpt-4", "claude-3-opus-20240229", usw.
messages=[
{"role": "system", "content": "Sie sind ein hilfreicher Assistent, der Blogartikel prägnant zusammenfasst."},
{"role": "user", "content": f"Bitte fassen Sie den folgenden Blogbeitrag für mich zusammen:\n\n{text}"}
],
temperature=0.7, # Steuerung des Zufalls. Niedriger für gezieltere Zusammenfassungen.
max_tokens=500 # Maximal-Tokens für die Zusammenfassung selbst
)
return response.choices[0].message.content.strip()
except openai.APIError as e:
print(f"OpenAI API-Fehler: {e}")
return "Fehler aufgrund eines API-Fehlers."
except Exception as e:
print(f"Ein unvorhergesehenes Problem ist bei der Zusammenfassung aufgetreten: {e}")
return "Fehler aufgrund eines unvorhergesehenen Fehlers."
if article_text_content:
print("\nBitte um LLM-Zusammenfassung...")
summary = summarize_text_with_llm(article_text_content)
print("\n--- Artikelzusammenfassung ---")
print(summary)
else:
print("\nZusammenfassung nicht möglich: Kein Artikelinhalt verfügbar.")
Und das ist es! Ein einfaches, aber funktionelles KI-Agent, das navigieren, extrahieren und zusammenfassen kann. Es ist nicht nur eine Theorie; es ist ein greifbares Stück Code, das Sie ausführen können.
Alles in einem (Vollständiges Skript)
Hier ist das vollständige Skript zum einfachen Kopieren und Testen. Vergessen Sie nicht, die Platz-URLs und Ihren OpenAI API-Schlüssel zu ersetzen!
import requests
from bs4 import BeautifulSoup
import openai
import os
# --- Konfiguration ---
# Ersetzen Sie durch die URL Ihres Blogs. Stellen Sie sicher, dass er Artikel enthält!
TARGET_BLOG_URL = "https://www.example-blog.com/articles"
SEARCH_KEYWORD = "beginner" # Das Schlüsselwort, das in den Artikeltiteln gesucht werden soll
OPENAI_API_KEY = "YOUR_OPENAI_API_KEY" # ERSETZEN SIE DAS! Oder verwenden Sie os.environ.get("OPENAI_API_KEY")
# Definieren Sie den OpenAI API-Schlüssel
openai.api_key = OPENAI_API_KEY
# --- Hilfsfunktionen ---
def fetch_webpage(url):
"""Ruft den HTML-Inhalt einer gegebenen URL ab."""
try:
response = requests.get(url, timeout=10) # Timeout hinzufügen
response.raise_for_status()
return response.text
except requests.exceptions.RequestException as e:
print(f"Fehler beim Abrufen der URL {url} : {e}")
return None
def find_article_links(html_content, base_url, keyword):
"""Analysiert das HTML, um Titel und URLs von Artikeln entsprechend einem Schlüsselwort zu finden."""
soup = BeautifulSoup(html_content, 'html.parser')
article_data = []
# --- ANPASSUNGSPUNKT 1 : Passen Sie diese Selektoren für Ihren Zielblog an ---
# Untersuchen Sie die Blog-Seite, um die richtigen HTML-Tags und Klassen für die Artikelcontainer, Titel und Links zu finden.
article_containers = soup.find_all('div', class_='article-card') # Häufig für Artikelkarten/Vorschauen
if not article_containers:
article_containers = soup.find_all('article') # Ein weiteres häufiges Tag für einzelne Artikel
if not article_containers:
print("Warnung : Keine gemeinsamen Artikelcontainer-Tags gefunden. Versuch einer breiteren Suche.")
# Rückgabe: schauen Sie sich einfach alle Links an, die Artikel-Links sein könnten
all_links = soup.find_all('a', href=True)
for link in all_links:
title_text = link.get_text(strip=True)
if keyword.lower() in title_text.lower():
href = link['href']
full_url = requests.compat.urljoin(base_url, href)
article_data.append({'title': title_text, 'url': full_url})
return article_data # Früh zurückgeben, wenn nur breite Links gefunden wurden
for container in article_containers:
# Suchen Sie den Titel und den Link in jedem Container
title_tag = container.find(['h2', 'h3', 'a']) # Die Titel sind häufig in h2/h3 oder direkt verlinkt
link_tag = container.find('a', href=True)
if title_tag and link_tag:
title = title_tag.get_text(strip=True)
href = link_tag['href']
# Vollständige URL aufbauen, wenn sie relativ ist
full_url = requests.compat.urljoin(base_url, href)
if keyword.lower() in title.lower():
article_data.append({'title': title, 'url': full_url})
return article_data
def extract_article_text(article_url):
"""Ruft eine Artikel-Seite ab und extrahiert deren Hauptinhalt."""
article_html = fetch_webpage(article_url)
if not article_html:
return None
soup = BeautifulSoup(article_html, 'html.parser')
# --- ANPASSUNGSPUNKT 2 : Passen Sie diese Selektoren für den Hauptinhalt des Artikels an ---
# Suchen Sie den Hauptinhalt des Artikels (zum Beispiel div mit der Klasse 'entry-content', 'article-body')
content_area = soup.find('div', class_='entry-content')
if not content_area:
content_area = soup.find('article', class_='main-article-content') # Ein weiteres häufiges Muster
if not content_area:
content_area = soup.find('div', id='content') # Noch eine weitere häufige ID
if content_area:
paragraphs = content_area.find_all('p')
return "\n".join([p.get_text(strip=True) for p in paragraphs if p.get_text(strip=True)])
else:
# Rückgabe: alle Absatz-Tags abrufen, wenn der spezifische Inhaltsbereich nicht gefunden wird
print(f"Warnung : Spezifischer Inhaltsbereich nicht gefunden für {article_url}. Extrahiere alle Absätze.")
paragraphs = soup.find_all('p')
return "\n".join([p.get_text(strip=True) for p in paragraphs if p.get_text(strip=True)])
def summarize_text_with_llm(text):
"""Verwendet ein LLM für den bereitgestellten Text."""
if not text or len(text.strip()) < 50: # Minimale Textlänge, um einen Versuch für eine Zusammenfassung zu unternehmen
return "Nicht genug Inhalt für die Zusammenfassung."
# Einfache Trunkierung, um innerhalb typischer Grenzen des Kontextfensters zu bleiben
# Ziehen Sie in Betracht, einen echten Token-Zähler für mehr Präzision zu verwenden, wenn nötig
max_chars_for_llm = 40000 # Etwa 10k Tokens für GPT-3.5-turbo 16k Kontext
if len(text) > max_chars_for_llm:
print(f"Warnung : Text von {len(text)} auf {max_chars_for_llm} Zeichen für LLM gekürzt.")
text = text[:max_chars_for_llm]
try:
response = openai.chat.completions.create(
model="gpt-3.5-turbo", # Sie können "gpt-4" verwenden, wenn Sie Zugang haben und eine bessere Qualität wünschen
messages=[
{"role": "system", "content": "Sie sind ein hilfreicher Assistent, der Blogartikel prägnant und klar zusammenfasst."},
{"role": "user", "content": f"Bitte geben Sie eine prägnante Zusammenfassung des folgenden Blogartikels mit den wichtigsten Punkten an:\n\n{text}"}
],
temperature=0.6, # Etwas weniger zufällig für Zusammenfassungen
max_tokens=600 # Max Tokens für die generierte Zusammenfassung
)
return response.choices[0].message.content.strip()
except openai.APIError as e:
print(f"Fehler API OpenAI : {e}")
return f"Fehlschlag aufgrund eines API-Fehlers : {e}"
except Exception as e:
print(f"Ein unerwarteter Fehler ist während der Zusammenfassung aufgetreten : {e}")
return f"Fehlschlag aufgrund eines unerwarteten Fehlers : {e}"
# --- Hauptlogik des Agenten ---
def run_browser_agent():
print(f"Starte den Browser-Agenten für {TARGET_BLOG_URL}, um Artikel über '{SEARCH_KEYWORD}' zu finden...")
# Schritt 1 : Abrufen der Hauptseite des Blogs
blog_html = fetch_webpage(TARGET_BLOG_URL)
if not blog_html:
print("Der Agent konnte die Hauptseite des Blogs nicht abrufen. Beende.")
return
# Schritt 2 : Finden von Artikeln, die dem Schlüsselwort entsprechen
found_articles = find_article_links(blog_html, TARGET_BLOG_URL, SEARCH_KEYWORD)
if not found_articles:
print(f"Kein Artikel gefunden, der '{SEARCH_KEYWORD}' auf {TARGET_BLOG_URL} enthält. Der Agent hat die Aufgabe beendet.")
return
print(f"\nGefunden: {len(found_articles)} potenzielle Artikel, die '{SEARCH_KEYWORD}' enthalten:")
for i, article in enumerate(found_articles):
print(f"{i+1}. Titel : {article['title']}\n URL : {article['url']}")
# Für dieses Beispiel, bearbeiten wir den ersten gefundenen Artikel
target_article = found_articles[0]
print(f"\nBearbeitung des ersten gefundenen Artikels: '{target_article['title']}' bei {target_article['url']}")
# Schritt 3 : Extrahieren des Inhalts des Zielartikels
article_content = extract_article_text(target_article['url'])
if not article_content:
print(f"Der Agent konnte den Inhalt von {target_article['url']} nicht extrahieren. Zusammenfassung nicht möglich.")
return
print(f"\nExtrahierter Inhalt des Artikels (erste 200 Zeichen) : {article_content[:200]}...")
# Schritt 4 : Zusammenfassen des Inhalts mit LLM
print("\nBitte LLM um den Artikel...")
summary = summarize_text_with_llm(article_content)
print("\n--- Abschlussbericht des Agenten ---")
print(f"Titel des Artikels : {target_article['title']}")
print(f"URL des Artikels : {target_article['url']}")
print("\nZusammenfassung :")
print(summary)
print("\n--- Aufgabe des Agenten abgeschlossen ---")
if __name__ == "__main__":
run_browser_agent()
Handlungsrelevante Schlüsselpunkte für Ihren eigenen Agenten-Weg
Dieses kleine Projekt ist nur die Spitze des Eisbergs, zeigt Ihnen aber die grundlegenden Mechanismen. Hier ist, was ich gelernt habe und was Sie im Hinterkopf behalten sollten:
- Beginnen Sie klein, denken Sie spezifisch: Versuchen Sie nicht, Skynet am ersten Tag zu bauen. Wählen Sie eine sehr enge und erreichbare Aufgabe für Ihren Agenten. „Finden Sie ein Rezept für vegane Lasagne“ ist besser als „kochen Sie das Abendessen für mich.“
- Web Scraping ist der Wilde Westen: Jede Webseite ist anders. Sie werden Zeit damit verbringen, die Elemente in Ihrem Browser zu inspizieren, um die richtigen CSS- oder XPath-Selectoren zu erhalten. Das ist die Grundlagenarbeit, aber sie ist essenziell. Webseiten ändern sich, daher könnte Ihr Agent gelegentliche Anpassungen benötigen.
- Fehlerbehandlung ist Ihr Freund: Dinge werden schiefgehen. Webseiten werden offline sein, Ihr Internet wird ausfallen, API-Aufrufe werden fehlschlagen. Fügen Sie
try-excepthinzu, um diese Probleme elegant zu handhaben. - LLMs sind intelligent, brauchen aber Anleitung: Die Qualität der Ausgabe Ihres LLM hängt stark von Ihrer Eingabeaufforderung ab. Seien Sie klar, präzise und sagen Sie ihm genau, was Sie erwarten. Seien Sie sich auch der Grenzen des Kontextfensters und der Kosten bewusst.
- Dies ist eine Grundlage: Wir haben einen Agenten in einem Durchlauf gebaut. Echte Agenten beinhalten oft mehrere Schritte, bedingte Logik (z.B. „wenn ich das finde, dann mache das“) und Gedächtnis. Aber Sie haben jetzt die Bausteine.
Ich hoffe, dass Sie mit diesem einfachen Agenten in Aktion sehen, das gesamte Konzept von „KI-Agent“ wird ein wenig weniger mysteriös. Es ist keine Magie; es ist nur intelligente Automatisierung, die auf vorhandenen Tools basiert. Legen Sie los, basteln Sie und bauen Sie Ihre eigenen kleinen digitalen Assistenten!
Viel Spaß beim Coden,
Emma Walsh, agent101.net
Verwandte Artikel
- Wie KI-Agenten mehrere Sprachen nahtlos beherrschen
- Ich habe meinen KI-Agenten nützlich gemacht (hier ist wie)
- Ich habe 2026 einen KI-Agenten gebaut: Meine ehrliche Meinung
🕒 Published: