Recherche-Workflows mit KI-Agenten

IRC-Mania Die Seite rund um Sicherheit und Programmierung

Internet, Sicherheit , Internet Relay Chat

Gesponsert

Was dieser Artikel über Recherche-Workflows mit KI-Agenten behandelt

• Wie Du Recherche-Workflows mit KI-Agenten baust.
• Wie Agenten Web-Suche, Quellenbewertung und Zusammenfassung automatisieren.
• Wie Du Faktencross-Checks und Qualitätskontrolle umsetzt.
• Praxisbeispiele für Themenrecherche, Marktanalyse und Literaturrecherche.
• Best Practices für Zuverlässigkeit, Vermeidung von Halluzinationen und Sicherheit.

Einleitung: Recherche-Workflows mit KI-Agenten verständlich erklärt

Recherche ist zeitaufwändig. Du liest Quellen, vergleichst Informationen, bewertest Glaubwürdigkeit, fasst zusammen. KI-Agenten können diesen Prozess automatisieren: Sie suchen im Web, lesen Seiten, bewerten Quellen, fassen zusammen und kreuzprüfen Fakten. Mit lokaler KI läuft alles auf Deiner Hardware, ohne dass Recherchedaten an Cloud-Provider gehen.

Dieser Artikel richtet sich an Entwicklerinnen und Entwickler, die Recherche-Workflows mit KI-Agenten bauen wollen. Du solltest verstehen, was KI-Agenten sind und wie man sie lokal mit Ollama betreibt. Grundlagen der Python-Programmierung findest Du auf IRC-Coding.de.

Warum brauche ich Recherche-Workflows mit KI-Agenten?

Stell Dir vor, Du sollst einen Bericht zu einem neuen Thema schreiben. Du verbringst Stunden mit Google, Wikipedia, Fachartikeln. Du liest, vergleichst, fasst zusammen. Ein KI-Agent kann das in Minuten erledigen: Er sucht, liest, bewertet, fasst zusammen und liefert Dir einen strukturierten Bericht mit Quellen.

Recherche-Workflows sind besonders wertvoll, wenn Du regelmäßig zu neuen Themen recherchieren musst, wenn Du viele Quellen auswerten willst oder wenn Du Recherchen reproduzierbar machen willst.

Recherche-Workflows mit KI-Agenten kurz erklärt

Ein Recherche-Workflow ist ein Agenten-Loop, der folgende Schritte wiederholt: Frage verstehen → Suchanfrage formulieren → Web-Suche → Ergebnisse lesen → Quellen bewerten → Fakten extrahieren → Kreuzprüfen → Zusammenfassen. Der Agent nutzt Tools für Web-Suche und Seitenabruf, das Sprachmodell trifft die Entscheidungen.

Der Kerngedanke lautet: Der Agent ist der Rechercheur, die Tools sind Suchmaschine und Browser, das Modell ist das Gehirn.

Für wen ist dieser Artikel gedacht?

• Wissenschaftlerinnen und Wissenschaftler, die Literaturrecherche automatisieren wollen.
• Journalistinnen und Journalisten, die schnell zu neuen Themen recherchieren müssen.
• Analystinnen und Analysten, die Markt- oder Wettbewerbsanalysen erstellen.
• Entwicklerinnen und Entwickler, die Recherche-Agenten bauen wollen.

Vorkenntnisse in Python, KI-Agenten und Ollama sind erforderlich.

Wichtige Begriffe rund um Recherche-Workflows

• Recherche-Agent - KI-Agent, der Recherchen durchführt. Wann nützlich: für automatisierte Recherche.
• Web-Suche-Tool - Tool, das Suchanfragen ausführt. Wann nützlich: damit der Agent Quellen findet.
• Quellenbewertung - Bewertung der Glaubwürdigkeit einer Quelle. Wann nützlich: um verlässliche von unzuverlässigen Quellen zu trennen.
• Faktencross-Check - Überprüfung von Fakten gegen mehrere Quellen. Wann nützlich: um Halluzinationen zu vermeiden.
• KI-Agenten - Programme, die eigenständig Aufgaben lösen. Wann nützlich: als Basis für Recherche-Agenten.
• Ollama - Lokaler Modellserver. Wann nützlich: als Gehirn des Agenten.
• Function Calling - Strukturierte KI-Antworten. Wann nützlich: für Tool-Use.
• Halluzination - Wenn das Modell falsche Fakten erfindet. Wann nützlich: das Hauptproblem bei Recherche-Agenten.

Architektur eines Recherche-Workflows

Ein typischer Recherche-Workflow besteht aus mehreren Phasen:

1. Frage verstehen: Der Agent analysiert die Frage und formuliert Suchanfragen.
2. Web-Suche: Der Agent sucht nach relevanten Quellen.
3. Seiten abrufen: Der Agent lädt die relevantesten Seiten herunter.
4. Inhalte extrahieren: Der Agent extrahiert den Text aus den Seiten.
5. Quellen bewerten: Der Agent bewertet Glaubwürdigkeit und Relevanz.
6. Fakten extrahieren: Der Agent extrahiert Fakten aus den Quellen.
7. Kreuzprüfen: Der Agent vergleicht Fakten über mehrere Quellen.
8. Zusammenfassen: Der Agent fasst die Ergebnisse zusammen.
9. Bericht erstellen: Der Agent erstellt einen strukturierten Bericht mit Quellen.

Tools für Recherche-Agenten

Web-Suche

Für die Web-Suche kannst Du verschiedene APIs nutzen:

import requests

def search_web(query, num_results=5):
    # DuckDuckGo (kostenlos, kein API-Key)
    response = requests.get(
        "https://html.duckduckgo.com/html/",
        params={"q": query}
    )
    # Ergebnisse parsen
    return parse_results(response.text)

# Alternativen:
# - SearXNG (selbst gehostet)
# - Tavily API (speziell für KI-Agenten)
# - Google Custom Search (API-Key nötig)
# - Brave Search API

Für Self-Hosting empfiehlt sich SearXNG, weil es keine API-Kosten verursacht und privat ist.

Seitenabruf

import trafilatura

def fetch_page(url):
    # Lädt die Seite und extrahiert den Text
    downloaded = trafilatura.fetch_url(url)
    text = trafilatura.extract(downloaded)
    return text

trafilatura ist eine Python-Bibliothek, die Webseiten herunterlädt und den Haupttext extrahiert, ohne Navigation, Werbung oder Footer.

Quellenbewertung

def evaluate_source(url, content):
    prompt = f"""
Bewerte die Glaubwürdigkeit dieser Quelle:
URL: {url}
Inhalt (Auszug): {content[:1000]}

Kriterien:
1. Autor/Organisation erkennbar?
2. Datum erkennbar?
3. Fakten belegt?
4. Sprache sachlich?
5. Quelle selbst zititiert?

Antworte im JSON-Format:
{{"credibility": "high|medium|low", "reason": "..."}}
"""
    response = call_ollama([
        {"role": "system", "content": "Du bist ein Quellenbewertungsexperte."},
        {"role": "user", "content": prompt}
    ])
    return parse_json(response)

Praxisbeispiel 1: Themenrecherche

Ein Agent, der ein Thema recherchiert und einen Bericht mit Quellen erstellt.

def research_topic(topic):
    # Phase 1: Suchanfragen formulieren
    queries = generate_search_queries(topic)

    # Phase 2: Web-Suche
    all_results = []
    for query in queries:
        results = search_web(query)
        all_results.extend(results)

    # Phase 3: Top-Ergebnisse abrufen
    top_results = all_results[:10]
    pages = []
    for result in top_results:
        content = fetch_page(result["url"])
        if content:
            pages.append({
                "url": result["url"],
                "title": result["title"],
                "content": content
            })

    # Phase 4: Quellen bewerten
    for page in pages:
        page["evaluation"] = evaluate_source(page["url"], page["content"])

    # Phase 5: Fakten extrahieren
    facts = []
    for page in pages:
        if page["evaluation"]["credibility"] in ["high", "medium"]:
            page_facts = extract_facts(page["content"], topic)
            facts.extend(page_facts)

    # Phase 6: Kreuzprüfen
    verified_facts = cross_check_facts(facts)

    # Phase 7: Bericht erstellen
    report = generate_report(topic, verified_facts, pages)
    return report

Suchanfragen formulieren

def generate_search_queries(topic):
    response = call_ollama([
        {"role": "system", "content": "Formuliere 5 Suchanfragen für eine Recherche. Antworte als JSON-Array."},
        {"role": "user", "content": f"Thema: {topic}"}
    ])
    return parse_json(response)

Fakten extrahieren

def extract_facts(content, topic):
    response = call_ollama([
        {"role": "system", "content": "Extrahiere Fakten zum Thema. Antworte als JSON-Array von Fakten."},
        {"role": "user", "content": f"Thema: {topic}\nInhalt: {content[:3000]}"}
    ])
    return parse_json(response)

Kreuzprüfen

def cross_check_facts(facts):
    verified = []
    for fact in facts:
        # Prüfe, ob der Fakt in mehreren Quellen bestätigt wird
        confirmations = count_confirmations(fact, facts)
        if confirmations >= 2:
            verified.append({
                "fact": fact,
                "confirmations": confirmations,
                "status": "verified"
            })
        else:
            verified.append({
                "fact": fact,
                "confirmations": confirmations,
                "status": "unverified"
            })
    return verified

Bericht erstellen

def generate_report(topic, facts, sources):
    response = call_ollama([
        {"role": "system", "content": "Schreibe einen strukturierten Bericht mit Quellenangaben."},
        {"role": "user", "content": f"""
Thema: {topic}
Verifizierte Fakten: {facts}
Quellen: {[{"url": s["url"], "title": s["title"]} for s in sources]}
"""}
    ])
    return response

Praxisbeispiel 2: Marktanalyse

Ein Agent, der einen Markt analysiert: Wettbewerber, Trends, Preise.

def market_analysis(product_category):
    # Wettbewerber finden
    competitors = research_topic(f"Wettbewerber im Markt: {product_category}")

    # Trends recherchieren
    trends = research_topic(f"Aktuelle Trends: {product_category}")

    # Preise vergleichen
    prices = research_topic(f"Preisvergleich: {product_category}")

    # Bericht kombinieren
    report = combine_reports([competitors, trends, prices])
    return report

Praxisbeispiel 3: Literaturrecherche

Ein Agent, der wissenschaftliche Literatur zu einem Thema findet.

def literature_review(topic):
    # Suchanfragen für wissenschaftliche Quellen
    queries = [
        f"{topic} site:arxiv.org",
        f"{topic} site:pubmed.ncbi.nlm.nih.gov",
        f"{topic} site:doi.org"
    ]

    # Suche ausführen
    results = []
    for query in queries:
        results.extend(search_web(query))

    # Abstracts extrahieren
    papers = []
    for result in results:
        content = fetch_page(result["url"])
        if content:
            abstract = extract_abstract(content)
            papers.append({
                "title": result["title"],
                "url": result["url"],
                "abstract": abstract
            })

    # Zusammenfassung erstellen
    summary = call_ollama([
        {"role": "system", "content": "Erstelle eine Literaturübersicht."},
        {"role": "user", "content": f"Papers: {papers}"}
    ])
    return summary

Vermeidung von Halluzinationen

Halluzinationen sind das größte Problem bei Recherche-Agenten. Das Modell erfindet Fakten, die nicht in den Quellen stehen.

Strategien gegen Halluzinationen

• Nur Fakten aus Quellen: Der Agent darf nur Fakten verwenden, die er in Quellen gefunden hat.
• Quellenangaben: Jeder Fakt muss eine Quelle haben.
• Kreuzprüfung: Fakten müssen in mindestens zwei Quellen bestätigt werden.
• Konfidenz angeben: Der Agent soll angeben, wie sicher er sich ist.
• Unsicherheit kommunizieren: Wenn der Agent unsicher ist, soll er das sagen.

def extract_facts_safe(content, topic):
    response = call_ollama([
        {"role": "system", "content": """
Extrahiere nur Fakten, die explizit im Text stehen.
Erfinde keine Fakten.
Wenn Du unsicher bist, sage "unsicher".
Jeder Fakt braucht eine Quellenangabe (Zitat aus dem Text).
Antworte als JSON-Array:
[{"fact": "...", "quote": "...", "confidence": "high|medium|low"}]
"""},
        {"role": "user", "content": f"Thema: {topic}\nInhalt: {content[:3000]}"}
    ])
    return parse_json(response)

Qualitätskontrolle

Metriken für Recherche-Qualität

• Quellenanzahl: Wie viele Quellen wurden gefunden?
• Quellenqualität: Wie glaubwürdig sind die Quellen?
• Faktenabdeckung: Wie viele Fakten wurden verifiziert?
• Konfidenz: Wie sicher ist der Agent bei den Fakten?
• Widersprüche: Gibt es widersprüchliche Fakten?

def quality_report(facts, sources):
    return {
        "total_sources": len(sources),
        "high_credibility_sources": sum(1 for s in sources if s["evaluation"]["credibility"] == "high"),
        "verified_facts": sum(1 for f in facts if f["status"] == "verified"),
        "unverified_facts": sum(1 for f in facts if f["status"] == "unverified"),
        "average_confidence": calculate_average_confidence(facts)
    }

Sicherheitshinweise

• Rate-Limits: Respektiere Rate-Limits von Such-APIs. Siehe API-Schlüssel.
• Keine sensiblen Daten: Recherchiere keine sensiblen Themen über Cloud-APIs. Nutze lokale KI.
• Audit Logging: Protokolliere alle Rechercheschritte. Siehe Audit Logging.
• Prompt Injection: Schütze den Agenten vor Prompt Injection aus Web-Inhalten. Siehe Prompt Injection Schutz.
• Guardrails: Nutze Guardrails, um schädliche Recherchen zu verhindern. Siehe Guardrails konfigurieren.

Typische Stolpersteine

• Halluzinationen: Der Agent erfindet Fakten. Nutze Quellenangaben und Kreuzprüfung.
• Schlechte Quellen: Der Agent nutzt unzuverlässige Quellen. Nutze Quellenbewertung.
• Endlosschleifen: Der Agent sucht immer weiter. Begrenze die Anzahl der Such-Schritte.
• Kontextlänge: Viele Quellen sprengen den Kontext. Nutze Summary Memory.
• Veraltete Informationen: Web-Suche liefert alte Ergebnisse. Nutze Datums-Filter.
• Bias: Der Agent bevorzugt bestimmte Quellen. Nutze diverse Suchanfragen.

Weiterführende Links und Infos zu Recherche-Workflows

• KI-Agenten Grundlagen - Was KI-Agenten sind.
• KI-Agenten mit Ollama - Agenten lokal betreiben.
• Function Calling - Tool-Use-Grundlagen.
• Ollama installieren - Backend für Agenten.
• Lokales RAG - RAG als Alternative zur Web-Suche.
• Prompt Injection Schutz - Sicherheit bei Web-Inhalten.
• Guardrails konfigurieren - Guardrails für Agenten.
• Audit Logging - Nachvollziehbarkeit.

Key Takeaways:

• Recherche-Workflows automatisieren Web-Suche, Quellenbewertung und Zusammenfassung.
• Der Agent nutzt Tools für Web-Suche und Seitenabruf, das Modell trifft Entscheidungen.
• Gegen Halluzinationen: Nur Fakten aus Quellen, Quellenangaben, Kreuzprüfung.
• Praxisbeispiele: Themenrecherche, Marktanalyse, Literaturrecherche.
• Sicherheit: Rate-Limits, Audit Logging, Prompt Injection Schutz.

FAQ: Recherche-Workflows mit KI-Agenten - Typische Fragen

Quellen und weiterführende Literatur

• Ollama Dokumentation - Offizielle Ollama-Docs.
• trafilatura - Web-Content-Extraction.
• SearXNG - Selbst gehostete Suchmaschine.
• Tavily API - Such-API für KI-Agenten.

Premium VPS Hosting

Schnelle und sichere VPS Server

Gesponsert