Meine Reise: Von der Verwirrung mit KI-Agenten zur Klarheit

1. Ein Ziel: Über spezifische Themen informiert bleiben.
2. Werkzeuge: Zugriff auf das Internet (Web-Scraping, API-Aufrufe), eine Möglichkeit, Texte zu verarbeiten (zum Filtern und Zusammenfassen), und eine Möglichkeit, Informationen zu speichern/präsentieren.
3. Eine Schleife: Periodisch die Aufgabe “finden und filtern” ausführen.
4. Ein Ergebnis: Eine strukturierte Liste von Erkenntnissen.

Keine Sorge, wir sprechen nicht darüber, ein komplexes System von Grund auf neu zu bauen. Wir werden bestehende Bibliotheken und Dienste nutzen, um das überraschend unkompliziert zu machen.

Praktisches Beispiel 1: Ein Python-Skript mit einfachen Keywords

Fangen wir super einfach an. Stell dir vor, du möchtest Erwähnungen von “LangGraph Tutorials” und “CrewAI Alternativen” in ein paar wichtigen Tech-Blogs verfolgen. Wir können Python verwenden, ein bisschen Web-Scraping (vorsichtig!) und einen einfachen Keyword-Matching-Ansatz.

Für dieses Beispiel halten wir es sehr einfach: Wir überprüfen ein paar fest codierte RSS-Feeds. RSS ist immer noch lebendig und aktiv, Leute, und es ist eine fantastische, höfliche Möglichkeit, Updates von Websites zu erhalten, ohne deren Server zu überlasten.

import requests
import xml.etree.ElementTree as ET
import datetime

# --- Konfiguration ---
TOPICS_OF_INTEREST = ["LangGraph Tutorials", "CrewAI Alternativen", "LiteLLM Preisgestaltung"]
RSS_FEEDS = [
 "https://www.exampletechblog.com/feed/",
 "https://anotherdevsite.org/rss.xml",
 # Füge hier weitere relevante RSS-Feeds hinzu
]
OUTPUT_FILE = "agent_findings.md"

def fetch_rss_feed(url):
 """Lädt einen RSS-Feed und analysiert ihn."""
 try:
 response = requests.get(url, timeout=10)
 response.raise_for_status() # Raise an exception for HTTP errors
 return ET.fromstring(response.content)
 except requests.exceptions.RequestException as e:
 print(f"Fehler beim Abrufen von {url}: {e}")
 return None

def main():
 print(f"Starte den Themenverfolgungsagenten um {datetime.datetime.now()}")
 found_articles = []

 for feed_url in RSS_FEEDS:
 print(f"Überprüfe Feed: {feed_url}")
 root = fetch_rss_feed(feed_url)
 if root is None:
 continue

 for item in root.findall(".//item"): # Anpassen basierend auf der RSS-Struktur
 title = item.find("title").text if item.find("title") is not None else "Kein Titel"
 link = item.find("link").text if item.find("link") is not None else "#"
 description = item.find("description").text if item.find("description") is not None else ""

 content_to_check = f"{title} {description}".lower()

 for topic in TOPICS_OF_INTEREST:
 if topic.lower() in content_to_check:
 found_articles.append({
 "topic": topic,
 "title": title,
 "link": link,
 "source": feed_url
 })
 print(f" -> Gefunden '{topic}' in: {title}")
 break # Ein Thema gefunden, gehe zum nächsten Artikel

 # --- Ergebnisse ausgeben ---
 with open(OUTPUT_FILE, "a", encoding="utf-8") as f:
 f.write(f"\n## Agent Erkenntnisse - {datetime.date.today()}\n")
 if not found_articles:
 f.write("Keine neuen Artikel zu den interessierenden Themen gefunden.\n")
 else:
 for article in found_articles:
 f.write(f"- **Thema:** {article['topic']}\n")
 f.write(f" - **Titel:** [{article['title']}]({article['link']})\n")
 f.write(f" - **Quelle:** {article['source']}\n\n")
 
 print(f"Agent fertig. Ergebnisse in {OUTPUT_FILE} gespeichert.")

if __name__ == "__main__":
 main()

Dies ist ein einfaches Beispiel, aber es illustriert die Kernidee. Du führst dieses Skript regelmäßig aus (z. B. einmal pro Tag mit einem Cron-Job oder einem einfachen Scheduler) und es fügt relevante Erkenntnisse zu einer Markdown-Datei hinzu. Du musst dann nur diese Datei öffnen, um deine kuratierte Liste zu sehen!

• Warum das ein Agent ist: Er hat ein Ziel (Themen verfolgen), verwendet Werkzeuge (Anfragen, XML-Parsing) und führt autonom nach einem Zeitplan aus.
• Anfängerfreundlich: Es ist Python, verwendet Standardbibliotheken, und die Logik ist unkompliziert.

Praktisches Beispiel 2: Einen Hauch von LLM für intelligenteres Filtern hinzufügen

Der Keyword-Ansatz ist gut, kann aber etwas starr sein. Was ist, wenn ein Artikel *über* “LangGraph Tutorials” spricht, aber diesen genauen Begriff nicht explizit verwendet? Oder wenn der Begriff in einem negativen Kontext verwendet wird und du nur positive/neutrale Erwähnungen wünschst?

Hier macht die Integration eines kleinen Sprachmodells (LLM) einen großen Unterschied. Wir können ein LLM verwenden, um den Inhalt besser zu “verstehen” und ihn basierend auf semantischer Relevanz zu filtern, nicht nur anhand von Schlüsselwörtern. Für einen Anfänger ist die Nutzung einer API wie der von OpenAI (oder Anthropic, oder sogar ein lokales LLM, wenn du dich abenteuerlustig fühlst) der einfachste Weg, um zu beginnen.

Lass uns unser vorheriges Beispiel ändern, um ein LLM für das Filtern zu verwenden. Wir werden eine neue Funktion einführen, die den Titel und die Beschreibung des Artikels an ein LLM sendet und es bittet, die Relevanz zu bestimmen.

# ... (vorherige Importe und Konfigurationen) ...
import openai # pip install openai

# --- LLM-Konfiguration (ersetze durch deinen tatsächlichen API-Schlüssel und Modell) ---
OPENAI_API_KEY = "DEIN_OPENAI_API_KEY" 
OPENAI_MODEL = "gpt-3.5-turbo" # Oder "gpt-4-turbo" für bessere Ergebnisse, aber höhere Kosten

def check_relevance_with_llm(title, description, topics_of_interest):
 """Verwendet ein LLM, um zu bestimmen, ob ein Artikel für die Themen relevant ist."""
 client = openai.OpenAI(api_key=OPENAI_API_KEY)
 
 # Formuliere einen Prompt, der die Aufgabe klar definiert
 prompt = f"""
 Du bist ein KI-Assistent, der Artikel für spezifische Forschungsthemen filtert.
 Bestimme anhand des folgenden Artikeltitels und der Beschreibung, ob er hochgradig relevant
 für EINES dieser Forschungsthemen ist: {', '.join(topics_of_interest)}.

 Artikel Titel: "{title}"
 Artikel Beschreibung: "{description}"

 Antworte mit "JA", wenn er hochgradig relevant für mindestens ein Thema ist, und "NEIN", sonst.
 Wenn JA, gib auch an, auf welches(n) Thema(e) er relevant ist, zum Beispiel:
 JA: LangGraph Tutorials, CrewAI Alternativen
 NEIN
 """
 
 try:
 response = client.chat.completions.create(
 model=OPENAI_MODEL,
 messages=[
 {"role": "system", "content": "Du bist ein hilfreicher Assistent."},
 {"role": "user", "content": prompt}
 ],
 temperature=0.0 # Halte es deterministisch für die Filterung
 )
 llm_response_content = response.choices[0].message.content.strip()
 
 if llm_response_content.startswith("JA"):
 # Extrahiere die vom LLM identifizierten Themen
 relevant_topics_str = llm_response_content.split(":", 1)[1].strip()
 return True, [t.strip() for t in relevant_topics_str.split(',')]
 else:
 return False, []
 except Exception as e:
 print(f"Fehler beim Aufruf des LLM: {e}")
 return False, []

def main_with_llm():
 print(f"Starte LLM-unterstützten Themenverfolgungsagenten um {datetime.datetime.now()}")
 found_articles = []

 for feed_url in RSS_FEEDS:
 print(f"Überprüfe Feed: {feed_url}")
 root = fetch_rss_feed(feed_url)
 if root is None:
 continue

 for item in root.findall(".//item"):
 title = item.find("title").text if item.find("title") is not None else "Kein Titel"
 link = item.find("link").text if item.find("link") is not None else "#"
 description = item.find("description").text if item.find("description") is not None else ""

 is_relevant, identified_topics = check_relevance_with_llm(title, description, TOPICS_OF_INTEREST)

 if is_relevant:
 # Speichere jedes identifizierte Thema zur Klarheit
 for topic in identified_topics:
 found_articles.append({
 "topic": topic,
 "title": title,
 "link": link,
 "source": feed_url
 })
 print(f" -> LLM identifizierte Relevanz für: {title} (Themen: {', '.join(identified_topics)})")
 else:
 print(f" -> LLM hielt nicht für relevant: {title}")

 # --- Ergebnisse ausgeben (wie zuvor) ---
 with open(OUTPUT_FILE, "a", encoding="utf-8") as f:
 f.write(f"\n## Agent Ergebnisse (LLM gefiltert) - {datetime.date.today()}\n")
 if not found_articles:
 f.write("Keine neuen Artikel für interessante Themen gefunden.\n")
 else:
 for article in found_articles:
 f.write(f"- **Thema:** {article['topic']}\n")
 f.write(f" - **Titel:** [{article['title']}]({article['link']})\n")
 f.write(f" - **Quelle:** {article['source']}\n\n")
 
 print(f"Agent beendet. Ergebnisse gespeichert in {OUTPUT_FILE}")

if __name__ == "__main__":
 # Du kannst wählen, welche Hauptfunktion du ausführen möchtest
 # main() # Für keywordbasierte Filterung
 main_with_llm() # Für LLM-unterstützte Filterung

Denke daran, "DEIN_OPENAI_API_KEY" durch deinen tatsächlichen Schlüssel zu ersetzen und die openai Bibliothek zu installieren (`pip install openai`).

Dieser LLM-gestützte Ansatz macht den Agenten wesentlich intelligenter. Er kann Kontext, Synonyme und sogar implizite Relevanz verstehen, was Fehlalarme reduziert und dir einen genaueren Feed bietet. Die Kosten für GPT-3.5-turbo sind für diese Art von Aufgabe ziemlich niedrig und machen es zugänglich für den persönlichen Gebrauch.

Über die Grundlagen hinaus: Was kommt als Nächstes für deinen Themenverfolger?

Du hast einen grundlegenden, funktionalen KI-Agenten erstellt. Ziemlich cool, oder? Aber das ist erst der Anfang. Hier sind einige Ideen, um die Fähigkeiten deines Agenten zu erweitern:

• Weitere Quellen: Anstatt nur RSS-Feeds zu nutzen, füge Web-Scraping für Seiten ohne Feeds hinzu (sei höflich und prüfe robots.txt!), oder verwende APIs für Plattformen wie Twitter, Reddit oder spezifische Forschungsdatenbanken.
• Zusammenfassung: Bitte das LLM, eine knappe Zusammenfassung des Artikels bereitzustellen, nachdem er als relevant erachtet wurde. Das spart noch mehr Zeit!
• Sentiment-Analyse: Frage das LLM, die Stimmung des Artikels zu deinem Thema zu bewerten. Sind die Leute begeistert von LangGraph oder haben sie Probleme gefunden?
• Personalisierte Benachrichtigungen: Integriere mit E-Mail, Slack oder Discord, um dir tägliche oder wöchentliche Zusammenfassungen direkt zu senden.
• Persistenz: Speichere die Artikel, die bereits verarbeitet wurden, in einer einfachen Datenbank (wie SQLite), um eine erneute Verarbeitung zu vermeiden und sicherzustellen, dass du nur wirklich *neue* Erkenntnisse erhältst.
• Benutzeroberfläche: Eine einfache Weboberfläche (mit Flask oder Streamlit) könnte es dir ermöglichen, Themen und Feeds leicht hinzuzufügen oder zu entfernen, ohne den Code zu bearbeiten.

Meine Erkenntnisse für angehende Agentenentwickler

Wenn du gerade erst mit KI-Agenten anfängst, denke an diese Dinge:

1. Einfach anfangen: Versuche nicht, eine universelle KI zu entwickeln. Wähle ein spezifisches, lästiges Problem aus, das du hast, wie das Verfolgen von Informationen, und baue einen Agenten dafür.
2. Verfügbare Werkzeuge nutzen: Du musst das Rad nicht neu erfinden. Python-Bibliotheken, bestehende APIs (für LLMs, Webdienste) und sogar einfaches Scripting können dich sehr weit bringen.
3. Das Ziel klar definieren: Was genau soll dein Agent erreichen? Je klarer das Ziel ist, desto einfacher ist es zu entwerfen und zu debuggen.
4. Iterieren: Deine erste Version wird nicht perfekt sein. Führe sie aus, sieh, was sie macht, und verbessere sie dann Schritt für Schritt. So habe ich herausgefunden, dass die LLM-Filterung ein Wendepunkt für mein eigenes Informationsmanagement war.
5. Keine Angst vor “Einfach”: Ein “einfacher” Agent, der ein echtes Problem löst, ist unendlich nützlicher als ein komplexer, theoretischer, der niemals das Licht der Welt erblickt.

Den Themenverfolger-Agenten zu erstellen, ging nicht nur darum, meine Informationsflüsse besser zu managen; es war auch eine fantastische Lernerfahrung. Es hat mein Verständnis der agentischen Prinzipien auf sehr praktische Weise gefestigt. Ich hoffe, das gibt dir das Vertrauen, einzutauchen und deinen eigenen digitalen Assistenten zu bauen!

Welche Themen sind schwierig für dich, auf dem Laufenden zu bleiben? Lass es mich in den Kommentaren wissen, vielleicht können wir einige Agentenideen brainstormen!

🕒 Published: March 29, 2026