Inhaltscreate AI-Agent Tutorial

Tutorial zum KI-Agenten für Inhalte erstellen

KI-Agenten verändern, wie wir komplexe Aufgaben angehen, indem sie über die einfache Ausführung von Skripten hinaus autonom Entscheidungen treffen und Probleme lösen. Für die Inhaltserstellung bedeutet dies, von manueller Schreib- und Bearbeitungsarbeit zu intelligenten Systemen zu wechseln, die in der Lage sind, Inhalte mit minimaler menschlicher Aufsicht zu generieren, zu optimieren und sogar zu veröffentlichen. Dieses Tutorial bietet einen technischen Überblick und praktische Beispiele für den Aufbau von KI-Agenten, die speziell für die Inhaltserstellung konzipiert sind. Wenn Sie neu im breiteren Konzept der KI-Agenten sind, sollten Sie mit Dem vollständigen Leitfaden für KI-Agenten im Jahr 2026 für grundlegendes Wissen beginnen.

Die Architektur des KI-Agenten für die Inhaltserstellung verstehen

Ein KI-Agent zur Inhaltserstellung besteht typischerweise aus mehreren miteinander verbundenen Komponenten, die jeweils für einen bestimmten Schritt im Lebenszyklus des Inhalts verantwortlich sind. Diese Schritte umfassen oft Recherche, Gliederung, Entwurf, Bearbeitung und Optimierung. Die Kernkomponenten sind in der Regel:

• Wahrnehmungsmodul: Sammelt Informationen aus externen Quellen (Web, Datenbanken, APIs) basierend auf einem gegebenen Prompt oder Ziel.
• Planungsmodul: Formuliert eine Strategie oder Reihenfolge von Aktionen, um das Ziel der Inhaltserstellung zu erreichen. Dies kann das Aufteilen einer komplexen Aufgabe in kleinere Teilaufgaben umfassen.
• Aktionsmodul: Führt die geplanten Aktionen aus und interagiert oft mit großen Sprachmodellen (LLMs) oder anderen Tools, um Text zu generieren, Informationen zusammenzufassen oder spezifische Operationen durchzuführen.
• Speichermodul: Speichert kontextuelle Informationen, frühere Interaktionen, generierte Entwürfe und Lerninhalte, um zukünftige Entscheidungen zu informieren.
• Feedback-/Verfeinerungsmodul: Bewertet den generierten Inhalt anhand vordefinierter Kriterien (z.B. Lesbarkeit, SEO-Score, Einhaltung des Prompts) und schlägt Überarbeitungen vor oder löst weitere Aktionen aus.

Die iterative Natur der Inhaltserstellung macht KI-Agenten besonders gut geeignet für diesen Bereich. Ein Agent kann ein Thema recherchieren, einen Abschnitt entwerfen, dessen Qualität bewerten und dann überarbeiten, wobei er diesen Zyklus wiederholt, bis das gewünschte Ergebnis erzielt ist.

Einrichten Ihrer Umgebung

Für dieses Tutorial verwenden wir hauptsächlich Python aufgrund seiner umfangreichen Bibliotheken für KI und Webinteraktionen. Stellen Sie sicher, dass Sie Python 3.9+ installiert haben. Wir werden auch beliebte Bibliotheken wie LangChain für die Orchestrierung von Agenten, die OpenAI-API für den Zugriff auf LLMs und requests/BeautifulSoup für das Web-Scraping verwenden.

pip install langchain openai beautifulsoup4 requests python-dotenv

Es ist eine gute Praxis, API-Schlüssel mithilfe von Umgebungsvariablen zu verwalten. Erstellen Sie eine .env-Datei im Stammverzeichnis Ihres Projekts:

OPENAI_API_KEY="your_openai_api_key_here"

Erstellen eines einfachen Forschungs- und Gliederungsagenten

Beginnen wir mit dem Aufbau eines Agenten, der ein Thema recherchieren und eine grundlegende Gliederung erstellen kann. Dieser Agent wird die Websuche nutzen, um Informationen zu sammeln, und ein LLM, um diese in eine Gliederung zu synthetisieren. Wir werden das Agentenframework von LangChain verwenden, das eine solide Möglichkeit bietet, Werkzeuge und einen Agentenausführenden zu definieren. Für eine tiefere Erkundung der LangChain-Spezifika verweisen Sie auf unser LangChain für KI-Agenten: Vollständiges Tutorial.

Werkzeugdefinition: Websuche

Unser Agent muss in der Lage sein, im Web zu suchen. Wir können dies mit einer einfachen Funktion erreichen, die eine Suchmaschine abfragt (z.B. Google Search API oder einen benutzerdefinierten Scraper).

import os
from dotenv import load_dotenv
from langchain.agents import initialize_agent, AgentType, Tool
from langchain_openai import ChatOpenAI
from langchain.tools import BaseTool
from bs4 import BeautifulSoup
import requests
import re

load_dotenv()

# Platzhalter für ein robusteres Websuchwerkzeug
# In einer realen Anwendung könnten Sie die Google Custom Search API oder SerpAPI verwenden
class WebSearchTool(BaseTool):
 name = "Websuche"
 description = "Durchsucht das Web nach Informationen zu einer bestimmten Anfrage."

 def _run(self, query: str) -> str:
 try:
 # Beispiel: Verwendung einer einfachen Google-Suche mit requests
 # Dies ist nicht für den Produktiveinsatz geeignet, zeigt jedoch das Konzept
 headers = {
 "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36"
 }
 search_url = f"https://www.google.com/search?q={query}"
 response = requests.get(search_url, headers=headers)
 response.raise_for_status() # Eine Ausnahme für HTTP-Fehler auslösen

 soup = BeautifulSoup(response.text, 'html.parser')
 
 # Auszüge aus den Suchergebnissen extrahieren
 snippets = []
 for g in soup.find_all(class_='g'): # Google-Suchergebnisse haben normalerweise die Klasse 'g'
 title_tag = g.find('h3')
 snippet_tag = g.find(class_='VwiC3b') # Beschreibungsausschnitt
 if title_tag and snippet_tag:
 snippets.append(f"Title: {title_tag.get_text()}\nSnippet: {snippet_tag.get_text()}")
 
 if not snippets:
 return "Keine relevanten Suchergebnisse gefunden."
 
 return "\n---\n".join(snippets[:3]) # Top 3 Snippets zurückgeben
 except requests.exceptions.RequestException as e:
 return f"Fehler während der Websuche: {e}"
 except Exception as e:
 return f"Ein unerwarteter Fehler ist aufgetreten: {e}"

 def _arun(self, query: str):
 raise NotImplementedError("Dieses Werkzeug unterstützt derzeit keine asynchronen Operationen.")

web_search_tool = WebSearchTool()

Agenteninitialisierung und -ausführung

Jetzt werden wir unser LLM und den Agenten initialisieren. Der Agent erhält eine Aufgabe und entscheidet, wann er das Websuchwerkzeug einsetzt und wann er das LLM zur Verarbeitung von Informationen verwendet.

llm = ChatOpenAI(temperature=0, model="gpt-4-turbo-preview") # Verwendung eines fähigen LLM

tools = [web_search_tool]

agent = initialize_agent(
 tools,
 llm,
 agent=AgentType.OPENAI_FUNCTIONS, # Verwendet die Funktionalität zum Funktionsaufruf von OpenAI
 verbose=True,
 handle_parsing_errors=True
)

def generate_outline(topic: str):
 prompt = f"Recherchiere '{topic}' und erstelle eine detaillierte Gliederung für einen Artikel. Die Gliederung sollte eine klare Einführung, 3-5 Hauptabschnitte mit Unterpunkten und einen Schluss enthalten. Konzentriere dich auf Schlüsselkriterien und potenzielle Unterthemen, die für ein technisches Publikum relevant wären."
 print(f"\n--- Erstelle Gliederung für: {topic} ---")
 result = agent.run(prompt)
 return result

# Beispielverwendung
topic_1 = "Die Rolle von KI-Agenten in der SEO-Automatisierung"
outline_1 = generate_outline(topic_1)
print(f"\nErstellte Gliederung für '{topic_1}':\n{outline_1}")

topic_2 = "Fortgeschrittene Techniken zur Datenanalyse mit KI-Agenten"
outline_2 = generate_outline(topic_2)
print(f"\nErstellte Gliederung für '{topic_2}':\n{outline_2}")

Dieser Agent wird zuerst das Werkzeug „Websuche“ verwenden, um Informationen über das Thema zu sammeln. Dann speist er diese Informationen zusammen mit dem Prompt in das LLM ein, um die Gliederung zu erstellen. Dies demonstriert die Wahrnehmungs- und Planungsmodule in Aktion, wobei das LLM sowohl als Planer als auch als Ausführer von Aktionen (Texterstellung) agiert.

Erweiterung auf Inhaltserstellung und -verfeinerung

Nachdem eine Gliederung erstellt wurde, besteht der nächste Schritt darin, den tatsächlichen Inhalt zu entwerfen. Wir können unseren Agenten erweitern, um eine Gliederung zu übernehmen und Abschnitte eines Artikels zu generieren. Dies beinhaltet oft iterative Aufrufe an das LLM, möglicherweise mit unterschiedlichen Prompts für jeden Abschnitt.

Hinfügungen eines Inhaltsentwurf-Werkzeugs

Anstatt eines „Werkzeugs“ im traditionellen Sinne kann das Entwerfen von Inhalten als direkte Interaktion mit dem LLM betrachtet werden, geleitet durch den Plan des Agenten.

from langchain.chains import LLMChain
from langchain.prompts import PromptTemplate

# Definiere eine Kette für das Entwerfen von Inhalten basierend auf einem Gliederungspunkt
drafting_prompt_template = PromptTemplate(
 input_variables=["topic", "section_title", "section_context"],
 template="Du bist ein erfahrener technischer Autor. Schreibe einen detaillierten und informativen Abschnitt für einen Artikel über '{topic}'. "
 "Der Abschnittsüberschrift ist '{section_title}'. Hier ist etwas Kontext und verwandte Informationen:\n{section_context}\n\n"
 "Stelle sicher, dass der Inhalt gut strukturiert ist, klare Sprache verwendet und umsetzbare Erkenntnisse für ein technisches Publikum bietet. "
 "Ziele auf 200-300 Worte für diesen Abschnitt."
)

drafting_chain = LLMChain(llm=llm, prompt=drafting_prompt_template)

def generate_section(topic: str, section_title: str, context: str):
 print(f"\n--- Abschnitt entwerfen: {section_title} ---")
 # Hier könnte 'context' aus vorherigen Web-Suchen oder generierten Gliederungen stammen
 response = drafting_chain.run(topic=topic, section_title=section_title, section_context=context)
 return response

# Beispiel zur Generierung eines Abschnitts basierend auf einem Gliederungspunkt
# Für einen vollständigen Artikel würdest du die Gliederung analysieren und durch die Abschnitte iterieren
sample_topic = "Die Rolle von KI-Agenten in der SEO-Automatisierung"
sample_section_title = "Keyword-Recherche und -Analyse mit KI-Agenten"
sample_context = "KI-Agenten können den Prozess der Identifizierung von hochwertigen Keywords, der Analyse von Wettbewerbsstrategien und der Vorhersage von Suchtrends automatisieren. Dies umfasst das Scrapen von Suchergebnissen, das Verarbeiten großer Datensätze von Keywords und die Verwendung von natürlicher Sprachverarbeitung, um die Suchintention zu verstehen. Relevante Tools: Google Keyword Planner, SEMrush, Ahrefs."

# In einem vollständigen Agenten würde der Kontext dynamisch generiert oder aus dem Gedächtnis abgerufen
# Beispielsweise durch das Durchführen einer zielgerichteten Web-Suche nach 'Keyword-Recherche mit KI-Agenten'
# Hier wird die iterative Wahrnehmung und Handlungsweise eines Agenten leistungsstark.
drafted_section = generate_section(sample_topic, sample_section_title, sample_context)
print(f"\nEntwurf Abschnitt:\n{drafted_section}")

Dieser Ansatz zeigt, wie ein Agent die komplexe Aufgabe “Artikel verfassen” in “Abschnitt 1 schreiben,” “Abschnitt 2 schreiben,” usw. zerlegen kann, wobei das LLM für jede Teilaufgabe verwendet wird. Der Agent würde den Fluss verwalten und relevanten Kontext (aus der Recherche oder vorherigen Abschnitten) an die Entwurfsvorlage weitergeben. Für eine spezifische Anwendung wie SEO-Automatisierung mit KI-Agenten würde dieser Prozess mit SEO-spezifischen Tools und Metriken integriert werden.

Feedback und Verfeinerung einbeziehen

Ein echter KI-Agent erzeugt nicht nur; er verfeinert auch. Dies beinhaltet die Bewertung des Outputs und das Vornehmen von Verbesserungen. Für Inhalte könnte das Folgendes bedeuten:

• Lesbarkeitsscore: Verwendung von Bibliotheken wie textstat, um Flesch-Kincaid, Gunning-Fog, etc. zu überprüfen.
• SEO-Optimierung: Überprüfung der Keyword-Dichte, LSI-Keywords, Überschriftenstruktur.
• Grammatik und Stil: Verwendung von LLMs oder speziellen Tools (z.B. LanguageTool API).
• Einhaltung der Vorgabe: Sicherstellen, dass der Inhalt alle Aspekte der ursprünglichen Anfrage anspricht.

Lass uns einen einfachen Verfeinerungsschritt hinzufügen, um einen Abschnitt basierend auf einem Stil-Guide zu verbessern.

# Verfeinerungsvorlagen
refinement_prompt_template = PromptTemplate(
 input_variables=["content", "feedback"],
 template="Du bist ein erfahrener Redakteur. Verbessere den folgenden Inhalt basierend auf dem gegebenen Feedback. "
 "Fokussiere auf Klarheit, Prägnanz und technische Genauigkeit. Stelle sicher, dass er einem professionellen Ton entspricht. "
 "Zu verfeinernder Inhalt:\n---\n{content}\n---\nFeedback: {feedback}\n\nÜberarbeiteter Inhalt:"
)

refinement_chain = LLMChain(llm=llm, prompt=refinement_prompt_template)

def refine_content(content: str, feedback: str):
 print(f"\n--- Inhalt mit Feedback verfeinern: {feedback} ---")
 revised_content = refinement_chain.run(content=content, feedback=feedback)
 return revised_content

# Beispiel zur Verwendung von Verfeinerung
feedback_string = "Mache die Sprache direkter und weniger ausführlich. Füge ein spezifisches Beispiel eines KI-Tools hinzu, das für die Keyword-Recherche verwendet wird."
refined_draft = refine_content(drafted_section, feedback_string)
print(f"\nVerfeinerter Abschnitt:\n{refined_draft}")

In einem vollständig autonomen Agenten würde das “Feedback” von einem anderen Modul erzeugt werden (z.B. ein “SEO Auditor”-Tool, ein “Lesbarkeitsprüfer”-Tool oder sogar ein separater LLM-Aufruf, der als Kritiker agiert), anstatt fest kodiert zu sein. Dieser iterative Feedbackprozess ist ein Markenzeichen intelligenter Agenten. Dieser Prozess ähnelt dem, wie ein Datenanalyse-KI-Agent mit Python seine Analyse schrittweise basierend auf Zwischenresultaten oder Benutzerfeedback verfeinern könnte.

Wichtige Erkenntnisse

• Modularer Entwurf ist entscheidend: Zerlege die Inhaltserstellung in unterscheidbare, handhabbare Module (Recherche, Gliederung, Entwurf, Verfeinerung, Optimierung). Dies ermöglicht einfachere Entwicklung, Tests und Wartung.
• LLMs für Kernaufgaben nutzen: Große Sprachmodelle sind hervorragend für Textgenerierung, Zusammenfassungen und Verständnis. Nutze sie strategisch im Workflow deines Agenten.
• Tools erweitern die Fähigkeiten des Agenten: Integriere spezialisierte Tools (Web-Scraper, Such-APIs, SEO-Prüfer, Grammatik-Tools), um die Fähigkeiten des LLM zu ergänzen und reale Interaktionen zu ermöglichen.
• Iterative Verfeinerung ist entscheidend: Implementiere Feedback-Schleifen, in denen der Agent seine eigene Ausgabe bewertet und Verbesserungen vornimmt. Dies ähnelt den Workflows der menschlichen Inhaltserstellung.
• Kontextmanagement ist von größter Bedeutung: Agenten müssen den Kontext über mehrere Schritte hinweg aufrechterhalten. Dies beinhaltet das Weitergeben relevanter Informationen (Forschungsergebnisse, vorherige Entwürfe, Gliederungspunkte) an nachfolgende Aktionen.
• Prompt Engineering für Kontrolle: Gestalte die Eingabeaufforderungen für deine LLM-Interaktionen sorgfältig, um dessen Verhalten zu lenken und sicherzustellen, dass der erzeugte Inhalt spezifische Anforderungen erfüllt (Ton, Länge, Stil).
• Sicherheits- und ethische Überlegungen: Sei dir bei der Datensicherheit beim Scrapen bewusst, vermeide die Generierung von schädlichen oder verzerrten Inhalten und lege klar offen, wenn KI verwendet wird.

Fazit

Der Aufbau von KI-Agenten zur Erstellung von Inhalten geht über einfache Skriptautomatisierung hinaus hin zu anspruchsvollen, autonomen Systemen. Durch die Kombination von LLMs mit spezialisierten Tools und die Annahme einer iterativen, feedbackgesteuerten Architektur können Entwickler leistungsstarke Agenten schaffen, die in der Lage sind, komplexe Inhalts-Workflows zu bewältigen. Die bereitgestellten Beispiele zeigen die grundlegenden Schritte, von der Recherche und Gliederung bis hin zu Entwurf und Verfeinerung. Während die Rahmenbedingungen für KI-Agenten sich weiterentwickeln und die Fähigkeiten von LLMs expandieren, können wir erwarten, dass noch fortschrittlichere und integrierte Agenten zur Erstellung von Inhalten zur Norm werden.

🕒 Published: March 27, 2026