Hallo, angehender Agent! Emma hier, zurück von einem weiteren nächtlichen tiefen Eintauchen in die faszinierende, manchmal frustrierende Welt der KI-Agenten. Wenn du so bist wie ich, hast du wahrscheinlich die letzten Monate über KI-Agenten geflüstert (oder laut geschrien) und dachtest: „Okay, das klingt cool, aber auch… was ist das eigentlich und wie bekomme ich einen, der etwas für mich macht?“
Gut, du bist an der richtigen Stelle. Heute werden wir nicht nur darüber reden, was KI-Agenten *theoretisch* sind. Wir werden unsere Ärmel hochkrempeln und eine Frage angehen, die viele von euch (und mich bis vor Kurzem) beschäftigt hat: Wie baue ich einen einfachen KI-Agenten, der tatsächlich für mich im Internet surfen und spezifische Fragen beantworten kann?
Vergiss für einen Moment den Hype. Wir streben nach Praktikabilität. Wir wollen „Ich kann das tatsächlich auf meinem Laptop zum Laufen bringen.“ Denn seien wir ehrlich, dabei zu sehen, ist glauben, oder?
Meine eigenen Erfahrungen mit Browser-Bots (Fehler und Durchbrüche)
Als ich anfing, mit der Idee eines Agenten zu experimentieren, der das Internet nutzen konnte, hatte ich große Visionen. Ich wollte, dass er komplexe Themen recherchiert, Preise über ein Dutzend Seiten vergleicht und im Grunde mein persönlicher digitaler Assistent ist. Was ich zunächst 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, null Verständnis für die zugrunde liegenden Mechanismen.
Das größte Hindernis? Ein KI-Modell dazu zu bringen, in einer sinnvollen, kontrollierten Weise mit dem Internet zu interagieren. Es ist eine Sache, ChatGPT eine Frage zu stellen, die es bereits kennt. Es ist etwas ganz anderes, ihm zu sagen, dass es neue Informationen finden, diese interpretieren und dann darauf basierend handeln soll. Genau da kommt der Teil „Agent“ ins Spiel.
Nach vielen Versuchen und Irrtümern erkannte ich, dass der Schlüssel nicht darin lag, sofort ein super komplexes, allwissendes Wesen zu erschaffen. Es ging darum, klein zu beginnen, mit einer sehr spezifischen Aufgabe, und von dort aus aufzubauen. Und genau das werden wir heute tun. Wir werden einen grundlegenden Browser-Agenten erstellen, der zu einer bestimmten Website gehen, einige Informationen extrahieren und zurückmelden kann.
Was ist überhaupt ein Browser-KI-Agent?
Bevor wir den Code erkunden, lass uns schnell klarstellen. Ein KI-Agent ist im Grunde ein KI-Programm, das entwickelt wurde, um eine spezifische Aufgabe autonom auszuführen. Er beobachtet seine Umgebung (in unserem Fall das Internet), trifft Entscheidungen basierend auf seinen Zielen und ergreift dann Maßnahmen. Ein *Browser*-KI-Agent nutzt speziell seine Web-Browsing-Fähigkeiten als Teil seines Werkzeugsatzes.
Stell es dir so vor: Du sagst deinem Agenten: „Finde mir das aktuelle Wetter in London.“ Anstatt einfach auf sein internes Wissen zurückzugreifen, würde ein Browser-Agent (idealerweise) einen Webbrowser öffnen, zu einer Wetter-Website navigieren, die Informationen finden und sie dann an dich zurückgeben. Es ist der Unterschied zwischen der Frage an einen Bibliothekar, auf die sie bereits die Antwort wissen, und der Bitte, ein Buch zu finden, ein bestimmtes Kapitel zu lesen und es dann für dich zusammenzufassen.
Für unser einfaches Agentenprojekt werden wir einige gängige Python-Bibliotheken verwenden, die diesen gesamten Prozess viel weniger einschüchternd machen.
Die benötigten Werkzeuge
Du brauchst dafür keinen Supercomputer. Nur deine reguläre Entwicklungsumgebung. Das werden wir verwenden:
- Python: Unsere Programmiersprache der Wahl. (Ich benutze 3.9, aber 3.8+ sollte in Ordnung sein.)
requests: Eine großartige Bibliothek für HTTP-Abfragen (d.h. um Webseiten abzurufen).BeautifulSoup(bs4): Dies ist unser Web-Parsing-Zauberer. Er hilft uns, Daten aus HTML zu navigieren und zu extrahieren.- Eine API für ein Large Language Model (LLM): Wir benötigen Zugang zu einem LLM wie den GPT-Modellen von OpenAI oder Claudes von Anthropic. Für dieses Tutorial gehe ich davon aus, dass du einen OpenAI API-Schlüssel hast.
Als erstes bereiten wir unsere Umgebung vor. Wenn du diese nicht installiert hast, öffne dein Terminal oder die 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 setzen oder direkt in dein Skript einfügen. Zur Vereinfachung zeige ich ihn direkt, aber für die Produktion sind Umgebungsvariablen immer besser.
Unsere Mission: Einen bestimmten Artikel auf einem Blog finden
Lass uns ein konkretes, erreichbares Ziel setzen. Die Mission unseres Agenten wird sein:
- Zu einem bestimmten Blog gehen (lass uns vorerst eine Dummy-Blog-URL verwenden oder agent101.net, wenn du dich abenteuerlustig fühlst!).
- Einen Blogbeitragstitel zu finden, der ein bestimmtes Schlüsselwort enthält (z.B. „anfänger“).
- Die URL dieses Blogbeitrags zu extrahieren.
- Den Inhalt dieses Blogbeitrags mit Hilfe eines LLM zusammenzufassen.
Das ist ein fantastischer Ausgangspunkt, weil es Web-Interaktion mit LLM-Verständnis kombiniert. Es ist wie die Bitte an deinen digitalen Assistenten: „Finde mir den neuesten Artikel über KI-Agenten für Anfänger auf agent101.net und sag mir, worum es darin geht.“
Schritt 1: Abrufen der Webseite
Der erste Schritt für jeden Browser-Agenten besteht darin, die Webseite zu „sehen“. Wir verwenden die requests-Bibliothek dafür. Lass uns ein einfaches Skript schreiben:
import requests
def fetch_webpage(url):
try:
response = requests.get(url)
response.raise_for_status() # Löst einen HTTPError für schlechte Antworten aus (4xx oder 5xx)
return response.text
except requests.exceptions.RequestException as e:
print(f"Fehler beim Abrufen der URL {url}: {e}")
return None
# Lass uns vorerst eine Platzhalter-URL verwenden.
# Ersetze sie durch eine echte Blog-URL, die Artikel hat, wenn du testen möchtest!
blog_url = "https://www.example-blog.com/articles" # Hier eine echte URL verwenden!
html_content = fetch_webpage(blog_url)
if html_content:
print("Inhalt der Webseite erfolgreich abgerufen.")
# Wir werden diesen Inhalt im nächsten Schritt verarbeiten
else:
print("Abrufen der Webseite fehlgeschlagen.")
Eine kurze Anmerkung zu URLs: Damit das funktioniert, benötigst du eine echte Blog-URL. Wenn du keine zur Hand hast, kannst du eine Seite wie `http://quotes.toscrape.com/` für das Testen einfacher Scraping verwenden, aber für Blogbeiträge finde einen echten Blog. Sogar diese Seite hier, agent101.net, könnte funktionieren, wenn du später die CSS-Selektoren anpasst!
Schritt 2: Das HTML parsen und Artikel-Links finden
Jetzt, wo wir das rohe HTML haben, ist es wie ein riesiges Buch ohne Index. BeautifulSoup ist unser Indizierer. Wir müssen ihm sagen, wie man die Artikelüberschriften und ihre entsprechenden Links findet.
Das ist der kniffligste Teil, denn die HTML-Struktur jeder Webseite ist unterschiedlich. Du musst das Element auf der Zielseite „untersuchen“. Klicke mit der rechten Maustaste auf einen Artikelüberschrift in deinem gewählten Blog und wähle „Untersuchen“ (oder „Element untersuchen“). Achte auf gängige Muster wie <h2>-Tags für Titel oder <a>-Tags für Links, die oft in einem <div> mit einem bestimmten Klassennamen eingebettet sind.
Zu Demonstrationszwecken nehmen wir an, dass eine übliche Blog-Struktur vorliegt, bei der die Artikelüberschriften in <h2>-Tags stehen und ihre Links direkt in einem <a>-Tag enthalten sind.
from bs4 import BeautifulSoup
def find_article_links(html_content, keyword):
soup = BeautifulSoup(html_content, 'html.parser')
article_data = []
# Dies ist ein allgemeines Beispiel. Sie müssen die Selektoren je nach Ziel-Website anpassen.
# Häufige Muster: div mit der Klasse 'article-item', h2 mit der Klasse 'article-title' usw.
# Nehmen wir an, 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 nach allen -Tags, die Artikelüberschriften enthalten könnten
# Überprüfen Sie dann, ob sie verlinkt sind.
# Ein soliderer Ansatz könnte sein, zuerst Container zu finden:
article_containers = soup.find_all('div', class_='article-card') # Passen Sie diese Klasse an!
if not article_containers:
# Fallback oder versuchen Sie einen anderen Selektor, wenn der 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 fetch_webpage Code) ...
if html_content:
search_keyword = "beginner" # Nach welchem Artikel suchen wir?
found_articles = find_article_links(html_content, search_keyword)
if found_articles:
print(f"\nGefundene Artikel, die '{search_keyword}' enthalten:")
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"\nKeine Artikel gefunden, die '{search_keyword}' enthalten.")
target_article = None
else:
target_article = None
Kritische Anpassung: Die Zeilen wie soup.find_all('div', class_='article-card') und container.find('h2') sind Platzhalter. Diese müssen Sie basierend auf der tatsächlichen HTML-Struktur des Blogs, den Sie anvisieren, anpassen. Hier wird das Inspektieren der Webseite entscheidend. Mein bester Rat ist, breit zu starten (z. B. soup.find_all('a'), um alle Links zu erhalten) und dann mit Klassen oder IDs einzuschränken.
Schritt 3: Inhalte aus dem Zielartikel extrahieren
Sobald wir die URL unseres Zielartikels haben, müssen wir seinen Inhalt abrufen und dann den Haupttext herausziehen. Das ist oft einfacher als das Parsen einer Indexseite, da die meisten Artikelinhalte in einem Hauptinhalt <div> oder <article> Tag leben.
# ... (vorheriger code) ...
import openai
import os
# Setzen Sie Ihren OpenAI API-Schlüssel
# Beste Praxis: os.environ.get("OPENAI_API_KEY")
# Für dieses Beispiel direkte Zuweisung:
openai.api_key = "YOUR_OPENAI_API_KEY" # ERSETZEN SIE DIES MIT IHREM 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')
# Dies hängt stark von der Struktur der Website ab.
# Häufige Muster: Finden Sie ein div mit der Klasse 'entry-content', 'article-body', 'main-content'
# Oder nur die -Tags innerhalb des Hauptartikel-Tags.
# Versuchen wir, gängige Inhaltsbereiche zu finden.
content_div = soup.find('div', class_='entry-content') # Häufig für WordPress
if not content_div:
content_div = soup.find('article') # Ein weiteres gutes allgemeines Tag
if not content_div:
# Als letzte Möglichkeit, holen Sie sich einfach 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 einen spezifischen Inhaltsbereich/einen Artikel gefunden haben, extrahieren Sie den gesamten Absatztext daraus
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 abrufen für: {target_article['title']}")
article_text_content = extract_article_text(target_article['url'])
if article_text_content:
# print(article_text_content[:500]) # Die ersten 500 Zeichen drucken, um zu überprüfen
print("\nArtikeltext erfolgreich extrahiert. Wechseln zur Zusammenfassung.")
else:
print("Failed to extract article text.")
article_text_content = "" # Sicherstellen, 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 primäres Ziel für Anpassungen. Verwenden Sie die Inspektor-Funktion Ihres Browsers!
Schritt 4: Zusammenfassung mit einem LLM
Schließlich ist es an der Zeit, den AI-Verstand einzubringen! Wir füttern den extrahierten Text einem LLM und bitten es darum. Hier zeigt sich die “Intelligenz” unseres Agenten wirklich.
# ... (vorheriger code) ...
def summarize_text_with_llm(text):
if not text:
return "Kein Text zur Zusammenfassung bereitgestellt."
# Texte kürzen, wenn sie zu lang für das Kontextfenster des Modells sind
# GPT-3.5-turbo hat ein Kontextfenster von 16k, aber es ist gut, es vernünftig zu halten.
# Für einen Anfänger sind 4000-8000 Tokens sicher.
# Grob 1 Token = 4 Zeichen für englischen Text.
max_tokens_for_input = 12000 # Passt an die Kapazität Ihres Modells und Kostenerwägungen an
if len(text) > max_tokens_for_input * 4: # Grobe Zeichenschätzung
text = text[:max_tokens_for_input * 4]
print(f"Warnung: Text auf ~{max_tokens_for_input} Tokens für LLM-Verarbeitung 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": "Du bist ein hilfreicher Assistent, der Blogbeiträge prägnant zusammenfasst."},
{"role": "user", "content": f"Bitte fasse den folgenden Blogbeitrag für mich zusammen:\n\n{text}"}
],
temperature=0.7, # Steuert die Zufälligkeit. Niedriger für fokussiertere 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 "Fehlschlag aufgrund eines API-Fehlers."
except Exception as e:
print(f"Ein unerwarteter Fehler ist während der Zusammenfassung aufgetreten: {e}")
return "Fehlschlag aufgrund eines unerwarteten Fehlers."
if article_text_content:
print("\nAnfrage zur Zusammenfassung durch LLM...")
summary = summarize_text_with_llm(article_text_content)
print("\n--- Artikelzusammenfassung ---")
print(summary)
else:
print("\nKann nicht zusammenfassen: Kein Artikelinhalt verfügbar.")
Und da haben Sie es! Ein grundlegender, aber funktionaler AI-Agent, der browsen, extrahieren und zusammenfassen kann. Das ist nicht mehr nur Theorie; es ist ein greifbares Stück Code, das Sie ausführen können.
Alles Zusammenfügen (Vollständiges Skript)
Hier ist das vollständige Skript zum einfachen Kopieren und Testen. Denken Sie daran, Platzhalter-URLs und Ihren OpenAI API-Schlüssel zu ersetzen!
import requests
from bs4 import BeautifulSoup
import openai
import os
# --- Konfiguration ---
# Ersetzen Sie dies durch Ihre tatsächliche Blog-URL. Stellen Sie sicher, dass sie Artikel enthält!
TARGET_BLOG_URL = "https://www.example-blog.com/articles"
SEARCH_KEYWORD = "beginner" # Das Schlüsselwort, das in den Artikeltiteln gefunden werden soll
OPENAI_API_KEY = "YOUR_OPENAI_API_KEY" # ERSETZEN SIE DAS! Oder verwenden Sie os.environ.get("OPENAI_API_KEY")
# Setzen Sie den OpenAI-API-Schlüssel
openai.api_key = OPENAI_API_KEY
# --- Hilfsfunktionen ---
def fetch_webpage(url):
"""Lädt den HTML-Inhalt einer gegebenen URL herunter."""
try:
response = requests.get(url, timeout=10) # Timeout hinzugefügt
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):
"""Parst HTML, um Artikeltitel und URLs zu finden, die einem Schlüsselwort entsprechen."""
soup = BeautifulSoup(html_content, 'html.parser')
article_data = []
# --- ANPASSUNGSPUNKT 1: Passen Sie diese Selektoren für Ihren Zielblog an ---
# Untersuchen Sie die Blogseite, um die richtigen HTML-Tags und Klassen für 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: Gemeinsame Artikelcontainer-Tags konnten nicht gefunden werden. Versuche breitere Suche.")
# Rückfall: Suche einfach nach allen Links, 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ühzeitige Rückgabe, falls nur breite Links gefunden wurden
for container in article_containers:
# Suche nach Titel und Link innerhalb jedes Containers
title_tag = container.find(['h2', 'h3', 'a']) # Titel 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']
# Voll-URL konstruieren, falls 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):
"""Lädt eine Artikel-Seite und extrahiert deren Haupttextinhalt."""
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 Hauptartikelinhalt an ---
# Suchen Sie den Hauptinhalt des Artikels (z. B. 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 gängiges Muster
if not content_area:
content_area = soup.find('div', id='content') # Noch eine gemeinsame 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ückfall: Hole alle Absatz-Tags, wenn der spezifische Inhaltsbereich nicht gefunden wurde
print(f"Warnung: Spezifischer Inhaltsbereich für {article_url} nicht gefunden. 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 für eine Zusammenfassung
return "Nicht genug Inhalt für eine Zusammenfassung."
# Einfache Trunkierung, um innerhalb typischer Kontextfenstergrenzen zu bleiben
# Ziehen Sie in Betracht, einen richtigen Token-Zähler für mehr Genauigkeit zu verwenden, falls nötig
max_chars_for_llm = 40000 # Ungefähr 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 verkü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 Blogbeiträge prägnant und klar zusammenfasst."},
{"role": "user", "content": f"Bitte geben Sie eine prägnante Zusammenfassung des folgenden Blogbeitrags an, in der die wichtigsten Erkenntnisse hervorgehoben werden:\n\n{text}"}
],
temperature=0.6, # Ein wenig weniger zufällig für Zusammenfassungen
max_tokens=600 # Maximale Tokens für die generierte Zusammenfassung
)
return response.choices[0].message.content.strip()
except openai.APIError as e:
print(f"OpenAI API Fehler: {e}")
return f"Fehlgeschlagen aufgrund eines API-Fehlers: {e}"
except Exception as e:
print(f"Ein unerwarteter Fehler ist während der Zusammenfassung aufgetreten: {e}")
return f"Fehlgeschlagen aufgrund eines unerwarteten Fehlers: {e}"
# --- Hauptagent-Logik ---
def run_browser_agent():
print(f"Starte Browser-Agent für {TARGET_BLOG_URL}, um Artikel über '{SEARCH_KEYWORD}' zu finden...")
# Schritt 1: Haupt-Blogseite abrufen
blog_html = fetch_webpage(TARGET_BLOG_URL)
if not blog_html:
print("Agent konnte die Haupt-Blogseite nicht abrufen. Beende.")
return
# Schritt 2: Artikel finden, die dem Schlüsselwort entsprechen
found_articles = find_article_links(blog_html, TARGET_BLOG_URL, SEARCH_KEYWORD)
if not found_articles:
print(f"Keine Artikel gefunden, die '{SEARCH_KEYWORD}' auf {TARGET_BLOG_URL} enthalten. Agent 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, lassen Sie uns den ersten gefundenen Artikel verarbeiten
target_article = found_articles[0]
print(f"\nVerarbeite den ersten gefundenen Artikel: '{target_article['title']}' unter {target_article['url']}")
# Schritt 3: Inhalt aus dem Zielartikel extrahieren
article_content = extract_article_text(target_article['url'])
if not article_content:
print(f"Agent konnte den Inhalt von {target_article['url']} nicht extrahieren. Kann nicht zusammenfassen.")
return
print(f"\nExtrahierter Artikelinhalt (erste 200 Zeichen): {article_content[:200]}...")
# Schritt 4: Zusammenfassung des Inhalts mit LLM anfordern
print("\nFordere LLM zur Artikelzusammenfassung an...")
summary = summarize_text_with_llm(article_content)
print("\n--- Abschließender Bericht des Agenten ---")
print(f"Artikel Titel: {target_article['title']}")
print(f"Artikel URL: {target_article['url']}")
print("\nZusammenfassung:")
print(summary)
print("\n--- Agentenaufgabe abgeschlossen ---")
if __name__ == "__main__":
run_browser_agent()
Handlungsfähige Erkenntnisse für Ihre eigene Agentenreise
Dieses kleine Projekt ist nur die Spitze des Eisbergs, aber es zeigt Ihnen die grundlegenden Mechaniken. Hier’s, was ich gelernt habe und was Sie im Hinterkopf behalten sollten:
- Klein anfangen, spezifisch denken: Versuchen Sie nicht, am ersten Tag Skynet zu bauen. Wählen Sie eine sehr enge, erreichbare Aufgabe für Ihren Agenten. „Finde ein Rezept für vegane Lasagne“ ist besser als „koche das Abendessen für mich.“
- Web Scraping ist der Wilde Westen: Jede Website ist anders. Sie werden Zeit damit verbringen, Elemente in Ihrem Browser zu inspizieren, um die richtigen CSS-Selektoren oder XPath zu erhalten. Das ist die unangenehme Arbeit, aber sie ist wichtig. Websites ändern sich, sodass Ihr Agent gelegentliche Anpassungen benötigen könnte.
- Fehlerbehandlung ist Ihr Freund: Dinge werden schiefgehen. Websites werden ausfallen, Ihr Internet wird unterbrochen, API-Aufrufe werden fehlschlagen. Fügen Sie
try-except-Blöcke hinzu, um diese Probleme elegant zu behandeln. - LLMs sind schlau, brauchen aber Anleitung: Die Qualität der Ausgabe Ihres LLM hängt stark von Ihrem Prompt ab. Seien Sie klar, prägnant und sagen Sie ihm genau, was Sie erwarten. Achten Sie auch auf die Grenzen des Kontextfensters und die Kosten.
- Dies ist eine Grundlage: Wir haben einen Agenten mit einer einzigen Runde erstellt. Echte Agenten umfassen oft mehrere Schritte, bedingte Logik (z. B. „Wenn ich dies finde, dann mache das“) und Gedächtnis. Aber Sie haben jetzt die Bausteine.
Meine Hoffnung ist, dass das Sehen dieses einfachen Agenten, der zum Leben erwacht, das ganze Konzept „AI-Agent“ ein wenig entmystifiziert. Es ist keine Magie; es ist einfach intelligente Automatisierung, die auf vorhandenen Tools basiert. Gehen Sie voran, experimentieren Sie und bauen Sie Ihre eigenen kleinen digitalen Helfer!
Viel Spaß beim Programmieren,
Emma Walsh, agent101.net
Verwandte Artikel
- Wie AI-Agenten mehrere Sprachen reibungslos beherrschen
- Ich habe meinen AI-Agenten nützlich gemacht (Hier ist wie)
- Ich habe einen AI-Agenten im Jahr 2026 gebaut: Meine ehrliche Meinung
🕒 Published: