Hallo zusammen, hier ist Emma von agent101.net!
Es ist März 2026, und wenn du so bist wie ich, wird dein Feed wahrscheinlich von „KI das“ und „KI jenes“ überflutet. Aber in letzter Zeit sehe ich immer häufiger eine bestimmte Art von KI auftauchen: KI-Agenten. Nicht nur die großen, fancy Modelle, sondern kleinere, fokussierte Agenten, die darauf ausgelegt sind, *Dinge* zu erledigen. Und ehrlich gesagt, habe ich mich eine Zeit lang etwas verloren gefühlt. Es klang cool, aber auch… komplex. Wie etwas, das nur hardcore Entwickler anfassen könnten.
Dann habe ich beschlossen, tatsächlich zu versuchen, einen zu bauen. Und rate mal? Es ist längst nicht so einschüchternd, wie es klingt, besonders wenn man klein anfängt. Heute möchte ich dir zeigen, wie ich meinen ersten wirklich nützlichen (zumindest für mich!) KI-Agenten gebaut habe: einen persönlichen Artikelzusammenfasser, der meine spezifischen Lesegewohnheiten versteht. Wir werden etwas Praktisches, Hands-on erstellen und hoffentlich den „Agenten“-Teil der KI für immer entmystifizieren.
Mein persönliches Informationsüberlastungsproblem (und warum ein Agent die Lösung war)
Beichte-Zeit: Ich lese SEHR VIEL. Für diesen Blog, aus Neugier, um im Technologiebereich einen klaren Kopf zu behalten. Artikel, Forschungsarbeiten, Forendiskussionen – es ist ein ständiger Strom. Und während ich das Lernen liebe, finde ich mich oft dabei, dass ich überfliege, wichtige Details verfehle oder vergesse, etwas Wichtiges wieder aufzugreifen. Ich habe versucht, Lesezeichen-Tools, Read-it-later-Apps zu verwenden, sogar einfach Links an mich selbst zu mailen (was immer in einem schwarzen Loch endet).
Mein größtes Problem? Die meisten Zusammenfasser sind einfach zu generisch. Sie geben dir die Hauptpunkte, sicher, aber sie wissen nicht, *warum* ich einen Artikel lese. Suche ich nach Einsat strategien? Nach spezifischen Codebeispielen? Den philosophischen Implikationen eines neuen Frameworks? Eine generische Zusammenfassung lässt mich oft mehr wollen oder, noch schlimmer, gibt mir eine perfekte Zusammenfassung von etwas, das mich nicht einmal interessiert hat.
Hier kam die Idee für einen persönlichen KI-Agenten ins Spiel. Was, wenn ich etwas bauen könnte, das nicht nur einen Artikel zusammenfasst, sondern ihn *für mich* zusammenfasst, basierend auf meinen aktuellen Interessen und dem Kontext, warum ich ihn lese? Etwas, das lernen könnte, was ich wichtig finde und das in seinem Output priorisieren kann?
Klingt fancy, oder? Lass es uns aufschlüsseln.
Was ist überhaupt ein KI-Agent? (Meine Meinung)
Vergiss die Sci-Fi-Roboter. Für uns Anfänger ist ein KI-Agent nicht unbedingt ein physisches Wesen. Denk daran als ein Softwarestück, das:
- Ziele: Es weiß, was es erreichen soll. (z.B. „Fasse diesen Artikel für Emma zusammen und konzentriere dich auf einsteigerfreundliche KI-Agenten-Konzepte.“)
- Werkzeuge: Es hat Zugriff auf Funktionen oder APIs, um diese Ziele zu erreichen. (z.B. ein Web-Scraper, eine API für große Sprachmodelle, ein Dateispeichersystem.)
- Wahrnehmung: Es kann Informationen aus seiner Umgebung aufnehmen. (z.B. die URL eines Artikels, meinen Prompt.)
- Entscheidungsfindung: Es kann entscheiden, welche Werkzeuge es verwenden und wie es basierend auf seinen Zielen und seiner Wahrnehmung fortfahren soll. (z.B. „Okay, ich muss zuerst den Artikelinhalt abrufen und dann mit Emmas spezifischen Anweisungen an das LLM senden.“)
- Gedächtnis (optional, aber sehr nützlich): Es kann frühere Interaktionen oder Informationen speichern, um zukünftige Aktionen zu verbessern. (z.B. „Emma mag normalerweise Codebeispiele, wenn ich Python-Artikel zusammenfasse.“)
Der Schlüssel hier ist, dass es mehr ist als nur einen API-Aufruf zu machen. Ein Agent hat ein bisschen Autonomie; er kann entscheiden, *wie* die Werkzeuge genutzt werden, um sein Ziel zu erreichen, anstatt einfach einen einzelnen Funktionsaufruf auszuführen.
Mein „Emma-Zusammenfasser“-Agent: Eine Schritt-für-Schritt-Anleitung
Okay, genug Theorie. Lass uns praktisch werden. Wir werden Python verwenden, weil es super zugänglich ist, und wir werden uns auf ein paar Bibliotheken stützen, die das Ganze viel einfacher machen.
Schritt 1: Die Grundkonfiguration (Werkzeuge bereitstellen)
Zuerst musst du Python installiert haben. Wenn du es noch nicht hast, hole es dir! Dann benötigen wir ein paar Pakete. Öffne dein Terminal oder die Eingabeaufforderung und tippe:
pip install requests beautifulsoup4 openai python-dotenv
- `requests`: Um Webseiten abzurufen.
- `beautifulsoup4`: Um das HTML zu parsen und den tatsächlichen Artikeltext zu extrahieren.
- `openai`: Um mit den Modellen von OpenAI zu interagieren (ich verwende GPT-4, weil es gut darin ist, Anweisungen zu folgen, aber du könntest auch GPT-3.5 Turbo für eine günstigere Option ausprobieren).
- `python-dotenv`: Um unsere API-Schlüssel geheim zu halten (super wichtig!).
Als Nächstes erstelle eine Datei mit dem Namen `.env` im selben Verzeichnis wie dein Python-Skript. Setze darin deinen OpenAI-API-Schlüssel:
OPENAI_API_KEY="dein_openai_api_key_hier"
Und erstelle dein Python-Skript, nennen wir es `emma_summarizer.py`.
Schritt 2: Die „Wahrnehmung“ – Abrufen des Artikelinhalts
Unser Agent muss den Artikel „sehen“. Das bedeutet, die Webseite abzurufen und den lesbaren Text zu extrahieren. Wir werden eine Funktion dafür erstellen.
# emma_summarizer.py
import requests
from bs4 import BeautifulSoup
import os
from dotenv import load_dotenv
from openai import OpenAI
# Lade Umgebungsvariablen
load_dotenv()
client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
def get_article_text(url):
try:
response = requests.get(url)
response.raise_for_status() # Generiere eine Ausnahme für HTTP-Fehler
soup = BeautifulSoup(response.text, 'html.parser')
# Versuche, gängige Artikel-Elemente zu finden
article_tags = ['article', 'main', 'div', 'p']
for tag in article_tags:
content = soup.find(tag, class_=lambda x: x and ('article' in x.lower() or 'content' in x.lower() or 'post' in x.lower()))
if content:
# Filtere offensichtliche Nicht-Inhalte wie Navigation, Fußzeilen usw. heraus
for unwanted in content.find_all(['nav', 'footer', 'aside', 'header', 'form', 'script', 'style']):
unwanted.decompose()
return content.get_text(separator='\n', strip=True)
# Fallback, falls spezifische Artikel-Tags nicht gefunden werden
paragraphs = soup.find_all('p')
full_text = '\n'.join([p.get_text(strip=True) for p in paragraphs if p.get_text(strip=True)])
return full_text if full_text else "Konnte den Artikeltext nicht extrahieren."
except requests.exceptions.RequestException as e:
return f"Fehler beim Abrufen der URL: {e}"
except Exception as e:
return f"Fehler beim Parsen des Inhalts: {e}"
Diese `get_article_text` Funktion ist die „Augen“ unseres Agenten. Sie geht zur URL, zieht das HTML herunter und versucht ihr Bestes, um den ganzen Junk (Werbung, Navigation usw.) zu entfernen, um nur den Artikeltext zu erhalten. Es ist nicht perfekt, aber ein guter Anfang!
Schritt 3: Die „Entscheidungsfindung“ & „Ziel“ – Zusammenfassung mit Kontext
Hier kommt der „Agent“-Teil wirklich zur Geltung. Wir fragen nicht nur nach einer Zusammenfassung; wir geben ihm Kontext und Präferenzen. Dies ist meine geheime Zutat für wirklich nützliche Zusammenfassungen.
# ... (vorheriger Code) ...
def summarize_article_for_emma(article_text, user_focus_prompt=""):
if len(article_text) < 50: # Willkürlich kleine Zahl, nach Bedarf anpassen
return "Artikeltext ist zu kurz für eine effektive Zusammenfassung."
# Dies ist der Kern des „Gehirns“ unseres Agents
emma_persona = """
Du bist Emma, eine Tech-Bloggerin, die auf KI-Agenten für Anfänger spezialisiert ist (agent101.net).
Bei der Zusammenfassung, priorisiere:
- Praktische Beispiele, insbesondere Python-Code.
- Schritt-für-Schritt-Anleitungen oder Tutorials.
- Erklärungen von Kernkonzepten in einfachen, nachvollziehbaren Begriffen.
- Potenzielle Herausforderungen oder häufige Stolpersteine für Anfänger.
- Das "Warum" hinter den Konzepten – wie hilft es einem Anfänger?
- Alles, was direkt relevant ist, um KI-Agenten zu bauen oder zu verstehen.
- Vermeide Fachjargon, wo einfachere Begriffe verwendet werden können.
"""
# Füge spezifischen Benutzerfokus hinzu, wenn bereitgestellt
if user_focus_prompt:
emma_persona += f"\nZusätzlich ist der Benutzer speziell an Folgendem interessiert: {user_focus_prompt}"
try:
response = client.chat.completions.create(
model="gpt-4-turbo-preview", # Oder "gpt-3.5-turbo" wenn du es bevorzugst
messages=[
{"role": "system", "content": emma_persona},
{"role": "user", "content": f"Bitte gib eine prägnante, umsetzbare Zusammenfassung des folgenden Artikels für meinen Blog, agent101.net. Mach sie etwa 300-400 Wörter lang und verwende Aufzählungspunkte für die wichtigsten Erkenntnisse, wo es angebracht ist:\n\n{article_text}"}
],
temperature=0.7 # Ein wenig kreativ, aber trotzdem geerdet
)
return response.choices[0].message.content
except Exception as e:
return f"Fehler bei der Zusammenfassung des Artikels mit OpenAI: {e}"
Merkst du den `emma_persona` String? Das ist meine Art, dem KI-Modell zu sagen, *wie* es denken und *was* es wichtig finden soll. Hier injizierst du deine eigenen Präferenzen, deine Nische, deine Ziele. Wenn ich eine Finanzbloggerin wäre, würde meine Persona von Marktentwicklungen, Anlagestrategien und Risikobewertungen sprechen. Für dich könnte es um Spielentwicklung, Kochen oder das Lernen einer neuen Sprache gehen.
Der `user_focus_prompt` ist ebenfalls wichtig. Das ermöglicht dynamisches „Gedächtnis“ oder „Kontext“ für eine bestimmte Sitzung. Wenn ich einen Artikel über ein neues KI-Framework lese, könnte ich hinzufügen `user_focus_prompt="insbesondere versuche ich herauszufinden, ob dieses Framework gut für den Einsatz kleiner Agenten ist."` Das sagt dem Agenten, dass er sich noch mehr auf diesen spezifischen Aspekt konzentrieren soll.
Schritt 4: Alles zusammenbringen (Die Orchestrierung des Agenten)
Jetzt lass uns eine einfache Hauptfunktion erstellen, um unseren Agenten auszuführen.
# ... (vorheriger Code) ...
def run_emma_summarizer():
print("Willkommen beim personalisierten KI-Artikel-Zusammenfasser von Emma!")
print("Ich werde Artikel für dich zusammenfassen, mit Fokus auf anfängerfreundliche Konzepte von KI-Agenten.")
while True:
article_url = input("\nGib die URL des Artikels ein, den du zusammengefasst haben möchtest (oder 'quit' um zu beenden): ").strip()
if article_url.lower() == 'quit':
print("Danke, dass du den Zusammenfasser benutzt hast! Viel Spaß beim Lernen!")
break
if not article_url.startswith(('http://', 'https://')):
print("Bitte gib eine gültige URL ein, die mit http:// oder https:// beginnt")
continue
user_focus = input("Gibt es einen speziellen Fokus für diese Zusammenfassung (z.B. 'Deployment', 'Codebeispiele', 'Anfänger')? (Drücke Enter um zu überspringen): ").strip()
print("\nLade den Artikelinhalt...")
full_article_text = get_article_text(article_url)
if "Error" in full_article_text or "Could not extract" in full_article_text or "too short" in full_article_text:
print(f"Fehler beim Abrufen des Artikelinhalts: {full_article_text}")
continue
print("Fasse mit deinen personalisierten Präferenzen zusammen...")
summary = summarize_article_for_emma(full_article_text, user_focus)
print("\n--- EMMA'S PERSONALISIERTE ZUSAMMENFASSUNG ---")
print(summary)
print("-----------------------------------\n")
if __name__ == "__main__":
run_emma_summarizer()
Diese `run_emma_summarizer`-Funktion ist das Steuerzentrum unseres Agenten. Sie nimmt Eingaben entgegen, ruft die richtigen Werkzeuge (`get_article_text`) auf und nutzt dann ihr "Gehirn" (`summarize_article_for_emma`), um die Informationen zu verarbeiten und ihr Ziel zu erreichen. Es ist eine einfache Schleife, aber sie zeigt das grundlegende agentische Muster.
Meine Erfahrungen und das, was ich gelernt habe
Die Verwendung dieses kleinen Agenten hat meine Forschung erheblich verändert. Anstatt mich durch einen 2000-Wörter-Artikel zu kämpfen, um den einen Absatz über Anfängerfehler zu finden, erhalte ich eine maßgeschneiderte Zusammenfassung, die oft genau das hervorhebt, was ich brauche. Es spart mir so viel Zeit!
Hier sind einige Dinge, die ich unterwegs gelernt habe:
- Die "Persona" ist alles: Je detaillierter und spezifischer du deine Systemaufforderung (die `emma_persona` in meinem Code) gestaltest, desto besser sind die Ergebnisse. Denke darüber nach, wer die KI ist, was ihre Ziele sind und welche Vorurteile/Vorlieben sie haben sollte.
- Fehlerbehandlung ist dein Freund: Web-Scraping ist chaotisch. Websites ändern sich, Inhaltsstrukturen unterscheiden sich. Meine `get_article_text`-Funktion ist nicht perfekt, aber das Hinzufügen von `try-except`-Blöcken macht den Agenten viel stabiler, als nur abzustürzen.
- Iterationen sind der Schlüssel: Meine erste Persona war nicht großartig. Ich musste sie anpassen und mehr Details hinzufügen ("priorisiere Python-Code", "vermeide Fachjargon"). Denk daran, wie beim Trainieren eines neuen Assistenten – du gibst Feedback und verfeinerst ihre Anweisungen im Laufe der Zeit.
- Beginne einfach, dann erweitere: Mein Agent fasst nur zusammen. Aber ich könnte ihn erweitern! Vielleicht könnte er Zusammenfassungen in einer lokalen Datenbank speichern, sie kategorisieren oder sogar verwandte Artikel vorschlagen. Die Schönheit der Agenten liegt in ihrer Modularität.
Umsetzbare Erkenntnisse für deine eigene Agentenreise
Du hast gesehen, wie ich meinen Agenten gebaut habe. Jetzt bist du dran. Hier sind meine Empfehlungen:
- Identifiziere dein eigenes Schmerzpunkt: Welche sich wiederholende Aufgabe oder Informationsüberlastung hast du? Es muss nicht um die Zusammenfassung von Artikeln gehen. Vielleicht geht es um das Kategorisieren von E-Mails, das Generieren von Social-Media-Untertiteln zu bestimmten Themen oder einfach darum, schnelle Antworten auf sehr spezifische Fragen basierend auf einem Textkörper zu erhalten.
- Definiere das Ziel deines Agenten: Was sollte er *tun*? Sei präzise. "Zusammenfassungen machen" ist zu vage. "Tech-Artikel für einen Anfänger-KI-Agenten-Blogger zusammenfassen, mit Fokus auf praktischen Beispielen" ist viel besser.
- Liste seine Werkzeuge auf: Auf welche APIs oder Funktionen muss er Zugriff haben? (z.B. Web-Scraper, LLM, Dateisystem, Datenbank, E-Mail-API).
- Erstelle eine Persona/Systemaufforderung: Dies ist der entscheidende Schritt, um nützliche Ergebnisse von einem LLM-gestützten Agenten zu erhalten. Verbringe Zeit damit. Sei spezifisch bezüglich seiner Rolle, seines Publikums, seiner Prioritäten und seines Ausgabeformats.
- Beginne mit dem Programmieren (klein!): Versuche nicht, am ersten Tag den nächsten Jarvis zu bauen. Wähle eine spezifische Funktion aus und bringe sie zum Laufen. Füge dann eine weitere hinzu. Iteriere. Teste. Lerne.
- Akzeptiere das Chaos: Dein erster Agent wird nicht perfekt sein. Websites werden deinen Scraper kaputt machen, LLMs werden manchmal falsch verstehen. Das gehört zum Lernprozess dazu. Debugging und Verfeinerung sind der Weg, um besser zu werden.
Der Bau dieses kleinen Zusammenfasser-Agenten hat nicht nur ein echtes Problem für mich gelöst, sondern auch meine Perspektive darauf, wozu KI-Agenten fähig sind, selbst für Anfänger, völlig verändert. Es geht nicht um Magie; es geht darum, ein komplexes Problem in kleinere, überschaubare Schritte zu zerlegen und dann einer KI die Werkzeuge und Anweisungen zu geben, um dir zu helfen, es zu lösen.
Gehe voran und baue deine eigenen nützlichen Agenten! Lass mich in den Kommentaren wissen, was du dir ausgedacht hast. Viel Spaß beim Bauen von Agenten!
🕒 Published: