Ich habe einen KI-Agenten entwickelt, um meine Nachrichten zusammenzufassen.

Hallo, Agent in Ausbildung! Emma hier, zurück auf agent101.net. Heute möchte ich über etwas sprechen, das in meinen Slack-Kanälen und persönlichen Projekten in den letzten Monaten ein großes Thema war: einen KI-Agenten dazu zu bringen, tatsächlich etwas Nützliches für dich zu tun, konstant, ohne dass du einen Doktortitel in Prompt Engineering oder eine Serverfarm in deinem Schrank benötigst. Insbesondere werden wir erkunden, wie man einen super einfachen, einstufigen KI-Agenten entwickelt, der spezifische Nachrichten für dich abruft und zusammenfasst – einen kleinen persönlichen Nachrichtenhund, wenn du so willst.

Ich weiß, ich weiß. „KI-Agent“ klingt immer noch nach etwas aus einem Science-Fiction-Film, oder? Oder möglicherweise hast du mit ChatGPT experimentiert und dich gefragt: „Okay, aber wie bringe ich dieses Ding dazu, selbstständig zu laufen, ohne dass ich jeden einzelnen Befehl eintippe?“ Genau diese Lücke werden wir heute schließen. Mein Ziel für diesen Artikel ist es, den Prozess zu entmystifizieren und dir zu zeigen, dass es nicht so beängstigend ist, einen kleinen, fokussierten KI-Agenten zu bauen, wie es klingt. Denk daran, als würdest du deinem digitalen Assistenten einen sehr spezifischen, wiederholbaren Trick beibringen.

Meine eigene Reise in die Welt der Agenten begann, ehrlich gesagt, aus purer Frustration. Ich verbrachte viel zu viel Zeit damit, durch Techniknachrichten zu sichten und nach Erwähnungen von spezifischen Updates für KI-Modelle oder neuen Agenten-Frameworks zu suchen. Ich hatte Google Alerts eingerichtet, aber sie waren oft zu allgemein oder zu langsam. Ich wollte etwas, das den Kontext versteht, den Lärm herausfiltern kann und mir eine prägnante Zusammenfassung gibt. Also dachte ich, wie jeder gute faule Programmierer (dessen ich mich stolz nenne!), „Es muss einen Weg geben, das mit einer KI zu automatisieren.“

Und das gab es! Nach ein paar Fehlstarts, etwas Kopfzerbrechen über API-Schlüssel und ein wenig Versuch und Irrtum mit verschiedenen großen Sprachmodellen (LLMs) fand ich ein Muster, das funktioniert. Es handelt sich nicht um ein Multi-Agenten-System, das komplexe Aufgaben koordiniert, und es wird auch nicht deinen nächsten Roman schreiben. Aber es ist ein perfekter Einstiegspunkt, um zu verstehen, wie diese Teile zusammenpassen, um etwas tatsächlich Hilfreiches zu schaffen.

Warum einen „Nachrichtenhund“ Agenten?

Wenn du gerade erst anfängst, ist es sicher eine Möglichkeit, dich entmutigen zu lassen, ein Projekt auszuwählen, das zu ehrgeizig ist. Deshalb empfehle ich, mit einem einstufigen Agenten zu beginnen. Unser „Nachrichtenhund“-Agent ist aus mehreren Gründen perfekt:

• Klares Ziel: Finde spezifische Nachrichten, fasse sie zusammen. Einfach.
• Greifbares Ergebnis: Du erhältst eine Zusammenfassung, die du tatsächlich lesen kannst.
• Baut auf externen Daten auf: Es zeigt dir, wie Agenten mit der Außenwelt interagieren (Informationen abrufen).
• Verwendet LLMs für die Interpretation: Der Kern der meisten Agenten ist ein LLM, das Text versteht und generiert.
• Wiederholbar: Einmal erstellt, kannst du es täglich, wöchentlich oder wann immer du willst laufen lassen.

Stell dir vor, du wachst auf, und dein Agent hat bereits eine kurze Zusammenfassung aller neuesten Fortschritte in „KI-Ethischen Fragen bei großen Sprachmodellen“ oder „neuen Entwicklungen bei autonomen Fahrzeugsensoren“ erstellt. Kein endloses Scrollen mehr durch generische Technikblogs. Das ist der Traum, und er ist völlig erreichbar.

Die Anatomie unseres einfachen Nachrichtenhund-Agenten

Jeder KI-Agent, egal wie einfach, hat in der Regel ein paar zentrale Komponenten. Für unseren Nachrichtenhund benötigen wir Folgendes:

1. Das „Gehirn“ (LLM): Dies ist unser großes Sprachmodell. Es wird verstehen, wonach wir suchen und die Informationen zusammenfassen. Ich werde die Modelle von OpenAI für dieses Beispiel verwenden, da sie weit verbreitet und gut dokumentiert sind, aber du könntest auch Claude von Anthropic oder sogar ein lokales Open-Source-Modell verwenden, wenn du abenteuerlustig bist.
2. Die „Augen“ (Information Fetcher): Unser Agent benötigt einen Weg, um Informationen aus dem Internet zu beziehen. Für Nachrichten genügt ein RSS-Feed-Reader oder eine einfache Web-Scraping-Bibliothek. Wir halten es einfach mit einer Nachrichten-API für Konsistenz.
3. Die „Anweisungen“ (Prompt): So sagen wir dem LLM, was es tun soll. Es ist entscheidend, um gute Ergebnisse zu erzielen.
4. Der „Orchestrierer“ (Python-Skript): Ein einfaches Skript, um alles zusammenzubinden und dem Agenten zu sagen, wann er abrufen, wann und wo er die Ergebnisse ausgeben soll.

Mach dir keine Sorgen, wenn diese Begriffe jetzt etwas viel erscheinen. Wir werden jedes Teil aufschlüsseln.

Was du benötigst, bevor wir anfangen

• Python: Stelle sicher, dass du Python 3.8+ installiert hast.
• Ein OpenAI API-Schlüssel: Du kannst einen auf der OpenAI Plattform erhalten. Es gibt einen kostenlosen Tarif für erste Tests, aber du musst wahrscheinlich eine Zahlungsmethode für die dauerhafte Nutzung hinzufügen. Bewahre diesen Schlüssel geheim!
• Ein Nachrichten-API-Schlüssel (optional, aber empfohlen): Dienste wie NewsAPI.org oder GNews API bieten kostenlose Tarife an, die dafür perfekt sind. Es macht das Abrufen strukturierter Nachrichtendaten viel einfacher als rohes Web-Scraping. Für dieses Tutorial gehe ich davon aus, dass du einen NewsAPI.org Schlüssel hast.
• Ein einfacher Texteditor: VS Code, Sublime Text oder sogar Notepad sind ausreichend.

Schritt 1: Einrichten deiner Umgebung

Zuerst erstellen wir ein neues Verzeichnis für unser Projekt und installieren die notwendigen Bibliotheken. Öffne dein Terminal oder die Eingabeaufforderung:

mkdir news_hound_agent
cd news_hound_agent
python -m venv venv
source venv/bin/activate # Auf Windows: venv\Scripts\activate
pip install openai requests python-dotenv

Wir installieren:

• openai: Um mit den Modellen von OpenAI zu interagieren.
• requests: Um HTTP-Anfragen an die Nachrichten-API zu stellen.
• python-dotenv: Um unsere API-Keys sicher zu speichern.

Als Nächstes erstelle eine Datei mit dem Namen .env in deinem news_hound_agent Verzeichnis und füge deine API-Keys hinzu:

OPENAI_API_KEY="your_openai_api_key_here"
NEWS_API_KEY="your_newsapi_key_here"

Ersetze die Platzhalter durch deine tatsächlichen Schlüssel. Vergiss nicht, .env zu deiner .gitignore Datei hinzuzufügen, falls du dieses Projekt jemals in ein Git-Repository einfügst!

Schritt 2: Erstellen des Information Fetchers (Die „Augen“)

Lass uns eine Python-Datei namens news_fetcher.py erstellen. Dieses Modul wird dafür verantwortlich sein, die Nachrichtenartikel abzurufen.

# news_fetcher.py
import requests
import os
from dotenv import load_dotenv

load_dotenv() # Lade Umgebungsvariablen aus .env Datei

NEWS_API_KEY = os.getenv("NEWS_API_KEY")
NEWS_API_URL = "https://newsapi.org/v2/everything"

def fetch_news(query, language='en', sort_by='relevancy', page_size=10):
 """
 Ruft Nachrichtenartikel von NewsAPI.org basierend auf einer Anfrage ab.
 """
 if not NEWS_API_KEY:
 print("Fehler: NEWS_API_KEY nicht in .env Datei gefunden.")
 return []

 params = {
 'q': query,
 'language': language,
 'sortBy': sort_by,
 'pageSize': page_size,
 'apiKey': NEWS_API_KEY
 }

 try:
 response = requests.get(NEWS_API_URL, params=params)
 response.raise_for_status() # Wirft eine Ausnahme bei HTTP-Fehlern (4xx oder 5xx)
 data = response.json()
 articles = data.get('articles', [])
 return articles
 except requests.exceptions.RequestException as e:
 print(f"Fehler beim Abrufen der Nachrichten: {e}")
 return []

if __name__ == "__main__":
 # Beispiel für die Verwendung beim direkten Ausführen dieses Skripts
 search_term = "KI-Agenten für persönliche Produktivität"
 articles = fetch_news(search_term, page_size=5)
 if articles:
 print(f"Gefunden: {len(articles)} Artikel für '{search_term}':")
 for i, article in enumerate(articles):
 print(f"{i+1}. {article.get('title', 'Kein Titel')} - {article.get('url', 'Keine URL')}")
 else:
 print(f"Keine Artikel gefunden für '{search_term}'.")

Dieses Skript definiert eine Funktion fetch_news, die eine Anfrage (z. B. „KI-Ethische Fragen“) entgegennimmt und eine Liste von Artikel-Dictionaries zurückgibt. Jedes Dictionary enthält Informationen wie den Titel, die Beschreibung und die URL. Der if __name__ == "__main__": Block ist nur zum Testen dieses Moduls in Isolation.

Schritt 3: Erstellen des Prompts (Die „Anweisungen“)

Hier kommt die Magie des LLM ins Spiel. Je besser dein Prompt, desto besser wird deine Zusammenfassung sein. Lass uns eine Datei mit dem Namen summarizer.py erstellen.

# summarizer.py
from openai import OpenAI
import os
from dotenv import load_dotenv

load_dotenv()

client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))

def summarize_articles(articles, specific_focus="general overview"):
 """
 Fasst eine Liste von Nachrichtenartikeln mithilfe eines OpenAI LLM zusammen.
 Der specific_focus Parameter hilft, die Zusammenfassung zu lenken.
 """
 if not articles:
 return "Keine Artikel bereitgestellt."

 # Bereite die Artikel für das LLM vor
 article_texts = []
 for i, article in enumerate(articles):
 title = article.get('title', 'Kein Titel')
 description = article.get('description', 'Keine Beschreibung')
 url = article.get('url', 'Keine URL')
 article_texts.append(f"Artikel {i+1}:\nTitel: {title}\nBeschreibung: {description}\nURL: {url}\n---")

 combined_text = "\n\n".join(article_texts)

 # Der Prompt für unser LLM
 prompt = f"""
 Du bist ein erfahrener Nachrichtenanalyst. Deine Aufgabe ist es, die folgenden Nachrichtenartikel zu überprüfen und eine prägnante Zusammenfassung bereitzustellen.
 Die Zusammenfassung sollte sich speziell auf "{specific_focus}" konzentrieren.
 Extrahiere die wichtigsten Entwicklungen, Trends und wichtigen Ankündigungen in Bezug auf diesen Fokus.
 Halte die Zusammenfassung unter 300 Wörtern und verwende eine klare und professionelle Sprache.
 Wenn ein Artikel nicht relevant für den spezifischen Fokus ist, kannst du kurz erwähnen, warum, oder ihn weglassen.

 Nachrichtenartikel:
 {combined_text}

 Zusammenfassung mit Fokus auf "{specific_focus}":
 """

 try:
 response = client.chat.completions.create(
 model="gpt-3.5-turbo", # Du kannst "gpt-4" für bessere Qualität verwenden, es ist jedoch teurer
 messages=[
 {"role": "system", "content": "Du bist ein hilfreicher und prägnanter Nachrichtenzusammenfasser."},
 {"role": "user", "content": prompt}
 ],
 max_tokens=500, # Nach Bedarf anpassen
 temperature=0.7 # Ein wenig kreativ, aber trotzdem sachlich
 )
 summary = response.choices[0].message.content.strip()
 return summary
 except Exception as e:
 print(f"Fehler beim Zusammenfassen der Artikel: {e}")
 return "Konnte aufgrund eines Fehlers keine Zusammenfassung erstellen."

if __name__ == "__main__":
 # Beispielhafte Dummy-Artikel für Tests
 dummy_articles = [
 {"title": "KI im Gesundheitswesen sieht neue Finanzierungen", "description": "Investitionen steigen in Startups, die KI für Diagnosen anwenden.", "url": "http://example.com/ai-health"},
 {"title": "Neues Elektrofahrzeug-Modell veröffentlicht", "description": "Luxus-EV-Marke präsentiert ihr neuestes Fahrzeug mit verbesserter Reichweite.", "url": "http://example.com/ev-car"},
 {"title": "Ethische KI-Richtlinien von der EU vorgeschlagen", "description": "Die Europäische Union entwirft strenge Regeln für die verantwortungsvolle Entwicklung von KI.", "url": "http://example.com/eu-ai"},
 ]
 focus = "KI-Ethische und regulatorische Fragen"
 summary_result = summarize_articles(dummy_articles, focus)
 print(f"\n--- Zusammenfassung für '{focus}' ---\n{summary_result}")

In diesem Skript:

• Wir laden den OpenAI API-Schlüssel.
• summarize_articles nimmt eine Liste von Artikeln und einen specific_focus String. Dieser specific_focus ist entscheidend! Er sagt dem LLM, durch welche Linse es zusammenfassen soll, um generische Ausgaben zu verhindern.
• Der Prompt ist sorgfältig konstruiert, um dem LLM eine Rolle („erfahrener Nachrichtenanalyst“), klare Anweisungen (prägnante Zusammenfassung, spezifischer Fokus, Wortgrenze) und den Inhalt zur Verfügung zu stellen.
• Wir verwenden gpt-3.5-turbo, da es ein gutes Gleichgewicht zwischen Kosten und Leistung für diese Aufgabe bietet. Fühle dich frei, mit gpt-4 zu experimentieren, wenn du nuanciertere Zusammenfassungen möchtest.

Schritt 4: Der Orchestrator (Alles Zusammenbringen)

Nun lass uns unser Haupt-agenten-Skript main_agent.py erstellen, das unseren Holter und Zusammenfasser aufruft.

# main_agent.py
from news_fetcher import fetch_news
from summarizer import summarize_articles
import datetime

def run_news_hound_agent(search_query, summary_focus):
 """
 Orchestriert den Nachrichtenabruf- und Zusammenfassungsprozess.
 """
 print(f"[{datetime.datetime.now()}] Starte den Nachrichten-Hund-Agenten...")
 print(f"Suche nach: '{search_query}' mit Fokus auf '{summary_focus}'")

 # Schritt 1: Abrufen der Nachrichtenartikel
 print("Nachrichtenartikel abrufen...")
 articles = fetch_news(search_query, page_size=10) # 10 Artikel abrufen

 if not articles:
 print("Keine Artikel gefunden oder ein Fehler ist beim Abrufen aufgetreten. Beende.")
 return

 print(f"Gefunden {len(articles)} relevante Artikel.")

 # Schritt 2: Die Artikel zusammenfassen
 print("Artikel mit LLM zusammenfassen...")
 summary = summarize_articles(articles, summary_focus)

 # Schritt 3: Die Ergebnisse ausgeben
 print("\n--- Täglicher Nachrichtenüberblick ---")
 print(f"Datum: {datetime.date.today()}")
 print(f"Suchanfrage: {search_query}")
 print(f"Fokus: {summary_focus}")
 print("\nZusammenfassung:")
 print(summary)
 print("\n--- Ende des Überblicks ---")

 # Optional: In eine Datei speichern
 output_filename = f"news_digest_{datetime.date.today().isoformat()}.txt"
 with open(output_filename, "w", encoding="utf-8") as f:
 f.write(f"Täglicher Nachrichtenüberblick für {datetime.date.today()}\n")
 f.write(f"Suchanfrage: {search_query}\n")
 f.write(f"Fokus: {summary_focus}\n\n")
 f.write("Zusammenfassung:\n")
 f.write(summary)
 f.write("\n\nOriginal Artikel Titel (zur Referenz):\n")
 for article in articles:
 f.write(f"- {article.get('title', 'Kein Titel')}\n")
 print(f"\nÜberblick in {output_filename} gespeichert.")


if __name__ == "__main__":
 # Definiere, wonach dein Agent suchen und worauf er sich konzentrieren soll
 my_search_query = "KI-Agenten-Frameworks ODER LLM-Orchestrierung"
 my_summary_focus = "neue Werkzeuge und Methoden zum Erstellen von KI-Agenten"

 run_news_hound_agent(my_search_query, my_summary_focus)

Dieses Skript orchestriert den gesamten Prozess:

• Es definiert eine run_news_hound_agent Funktion, die eine search_query (wonach in Nachrichtenüberschriften/Beschreibungen gesucht werden soll) und einen summary_focus (was das LLM speziell hervorheben soll) entgegennimmt.
• Es ruft fetch_news auf, um die Rohartikel zu erhalten.
• Es reicht dann diese Artikel und den Fokus an summarize_articles weiter.
• Schließlich gibt es die Zusammenfassung in der Konsole aus und speichert sie in einer Textdatei für ein einfaches späteres Lesen.

Deinen Nachrichten-Hund-Agenten Ausführen!

Öffne jetzt dein Terminal, stelle sicher, dass deine virtuelle Umgebung aktiv ist, und führe aus:

python main_agent.py

Du solltest eine Ausgabe sehen, die anzeigt, dass der Agent Nachrichten abruft, dann zusammenfasst und schließlich dein personalisiertes Nachrichtenüberblick in der Konsole ausgibt und als Datei speichert! Der erste Lauf könnte einige Sekunden dauern, da das LLM die Anfrage verarbeitet.

Was ich daran liebe, ist das sofortige Feedback. Du gibst eine Anfrage ein, spezifizierst einen Fokus, und boom – du erhältst eine maßgeschneiderte Zusammenfassung. Keine generischen Überschriften mehr. Für mich war das ein großes „Aha!“-Moment. Es war nicht nur ein Gespräch mit einer KI; es war, eine KI dazu zu bringen, eine spezifische, wertvolle Aufgabe in meinem Namen zu erfüllen.

Feinabstimmung und Erweiterung Deines Agenten

Das ist nur der Anfang! Hier sind einige Ideen, um deinen Nachrichten-Hund noch besser zu machen:

• Mehrere Anfragen/Fokusse: Ändere main_agent.py, um für mehrere verschiedene Anfragen oder Fokusse zu laufen und mehrere Überblicke zu erstellen.
• Planung: Nutze Tools wie cron (Linux/macOS) oder den Windows Task Scheduler, um main_agent.py automatisch jeden Morgen auszuführen.
• Verschiedene LLMs: Experimentiere mit anderen LLMs. Vielleicht Anthropics Claude 3 Opus für längere Kontexte oder Llama 3 für lokale Verarbeitung.
• Ausgabeformate: Anstatt einer Textdatei, speichere die Ausgabe als HTML, Markdown-Datei oder sende sie sogar an deine E-Mail oder einen Slack-Kanal (du müsstest mit diesen APIs integrieren).
• Kontextuelle Filterung: Vor der Zusammenfassung könntest du einen Zwischenschritt hinzufügen, bei dem das LLM (oder ein einfacherer Textklassifikator) bestimmt, ob jeder abgerufene Artikel wirklich relevant für deinen spezifischen Fokus ist, um Rauschen weiter herauszufiltern.
• Erweiterte Nachrichtenquellen: Erkunde andere Nachrichten-APIs oder sogar das Webscraping bestimmter Seiten (aber achte auf die Nutzungsbedingungen!).

Mein eigener Nachrichten-Hund hat sich aus diesem grundlegenden Setup entwickelt. Ich lasse ihn jetzt jede Nacht laufen und nach Updates zu bestimmten Agenten-Frameworks suchen, die ich beobachte, und er sendet mir jeden Morgen eine Zusammenfassung per E-Mail. Es hat mir Stunden des Durchsuchens von RSS-Feeds und Twitter-Konversationen erspart. Es ist wirklich mein digitaler Forschungsassistent geworden.

Umsetzbare Erkenntnisse

Was solltest du also aus alledem mitnehmen?

1. Beginne klein, denke groß: Versuche nicht, beim ersten Versuch die nächste AGI zu bauen. Ein einzweck Agent ist ein fantastisches Lernwerkzeug.
2. Prompts sind Macht: Die Qualität deiner Ausgabe hängt direkt von der Klarheit und Spezifität deiner Prompts ab. Verbringe Zeit damit, sie zu verfeinern.
3. APIs sind deine Freunde: LLMs sind mächtig, aber sie benötigen Daten. Lerne, mit externen APIs (wie NewsAPI) zu interagieren, ist grundlegend.
4. Code ist der Kleber: Python (oder eine beliebige Skriptsprache) verwandelt eine Sammlung von leistungsstarken Komponenten in einen funktionierenden Agenten.
5. Iteriere und experimentiere: Scheue dich nicht, Modelle zu ändern, Prompts zu verfeinern oder verschiedene Datenquellen auszuprobieren. So lernst du, was am besten für deine spezifischen Bedürfnisse funktioniert.

Den Nachrichten-Hund-Agenten zu erstellen, ist eine praktische, praxisnahe Möglichkeit, die Kernkonzepte hinter KI-Agenten zu verstehen. Es zeigt dir, wie du ein LLM mit externen Tools verbindest und eine nützliche Aufgabe automatisierst. Dieses grundlegende Wissen ist das, auf dem du aufbauen wirst, während du komplexere Multi-Agenten-Systeme erkundest oder Agenten in größere Anwendungen integrierst.

Mach weiter, probiere es aus! Du wirst überrascht sein, wie schnell du deinen eigenen kleinen digitalen Assistenten zum Laufen bekommst. Und wie immer, wenn du auf ein Problem stößt oder einen coolen neuen Weg entdeckst, dies zu erweitern, hinterlasse einen Kommentar unten oder finde mich in sozialen Medien. Viel Spaß beim Agentenbau!

Verwandte Artikel

• Lernen Sie KI: Ihr vollständiger KI-Anfängerweg 2026
• KI-Agenten für Anfänger: Ihr freundlicher Leitfaden
• KI-Agenten-Tutorials mit realen Beispielen

🕒 Published: March 29, 2026