Ein LLM als Schiedsrichter im RAG-Retrieval: Den richtigen Kandidaten mit Begründung auswählen

Ein LLM als Schiedsrichter im RAG-Retrieval: Die richtigen Kandidaten mit Begründung auswählen

Retrieval-Augmented Generation (RAG) ist zu einem Eckpfeiler moderner KI-Anwendungen geworden und ermöglicht es Large Language Models (LLMs), Antworten auf externes Wissen zu stützen. Eine bleibende Herausforderung besteht jedoch: Selbst bei hochwertigem Retrievel können mehrere Kandidatendokumente zurückgegeben werden, die nicht alle gleichermaßen relevant sind. Herkömmliche Ranking-Methoden wie Kosinus-Ähnlichkeit oder BM25 erfassen oft keine nuancierte Relevanz – wie zeitlichen Kontext, Intentionsabgleich oder domänenspezifische Argumentation.

Hier kommt der **LLM-als-Schiedsrichter**-Ansatz ins Spiel: Anstatt sich ausschließlich auf Embedding-Ähnlichkeit zu verlassen, verwenden wir einen sekundären LLM-Aufruf, um abgerufene Kandidaten mit expliziter Begründung zu bewerten und zu ranken. Diese Technik, die in aktuellen Branchendiskussionen (z. B. auf *Towards Data Science*) untersucht wird, bietet einen intelligenteren, kontextbewussteren Retrieval-Schritt. In diesem Artikel gehen wir eine praktische Implementierung durch – von der Installation bis zur Nutzung – und zeigen, wie man eine RAG-Pipeline aufbaut, in der ein LLM Kandidatendokumente bewertet und Begründungen für seine Entscheidungen liefert.

Warum ein LLM als Schiedsrichter verwenden?

Herkömmliches Retrieval-Ranking hat Einschränkungen:

• **Semantische Ähnlichkeit** kann pragmatische oder kontextuelle Hinweise übersehen (z. B. ein Dokument von 2022 vs. 2024 zum gleichen Thema).
• **Keyword-basierte** Methoden versagen, wenn Abfragen abstrakt sind oder mehrstufige Argumentation erfordern.
• Es wird **keine Erklärung** geliefert, warum ein Dokument einem anderen vorgezogen wird.

Die Verwendung eines LLMs als Schiedsrichter adressiert diese Probleme:

• Das LLM kann über **zeitliche Relevanz**, **Autorität** und **Intentionsabgleich** argumentieren.
• Es gibt **menschenlesbare Begründungen** für die Bewertung jedes Kandidaten aus, was Debugging und Vertrauen ermöglicht.
• Es kann **komplexe Abfragen** verarbeiten (z. B. "Finde die aktuellste Richtlinienaktualisierung zur KI-Sicherheit, die nicht von einem Anbieter-Blog stammt").

Dieser Ansatz ergänzt die Vektorsuche: Sie rufen weiterhin die Top-K-Kandidaten über Embedding-Ähnlichkeit ab und verfeinern dann mit LLM-Argumentation. Der Schlüssel ist, dass das LLM nicht neu generiert – es *beurteilt*.

Voraussetzungen

Um diesem Tutorial zu folgen, benötigen Sie:

• **Python 3.10+** auf Ihrem System installiert.
• **OpenAI-API-Schlüssel** (oder einen anderen LLM-Anbieter) mit Zugriff auf GPT-4 oder GPT-4o-mini (aus Kostengründen). Alternativ können Sie ein lokales Modell über Ollama verwenden (z. B. `llama3` oder `mistral`).
• **Grundlegende Vertrautheit** mit Python, virtuellen Umgebungen und Befehlszeilen-Tools.
• **Mindestens 4 GB RAM** bei Verwendung eines lokalen LLMs; Cloud-API erfordert Internet.
• **pip** (Python-Paketmanager).

Wir verwenden die folgenden Python-Bibliotheken:

• `langchain` und `langchain-community` für die RAG-Orchestrierung.
• `chromadb` für die Vektorspeicherung.
• `openai` (oder `ollama`) für LLM-Aufrufe.
• `pandas` für die Datenverarbeitung.

Schritt-für-Schritt-Installation

1. Einrichten einer Python-Virtual-Umgebung

Erstellen Sie zunächst eine isolierte Umgebung, um Abhängigkeitskonflikte zu vermeiden.

python3 -m venv rag-arbiter
source rag-arbiter/bin/activate   # Unter Windows: rag-arbiter\Scripts\activate

2. Erforderliche Pakete installieren

Installieren Sie die Kernbibliotheken. Wir verwenden `langchain` für sein modulares Retrieval und LLM-Interface.

pip install langchain langchain-community chromadb openai pandas tiktoken

Wenn Sie ein lokales Modell über Ollama verwenden möchten:

pip install langchain-ollama

3. API-Schlüssel einrichten (bei Verwendung von OpenAI)

Exportieren Sie Ihren OpenAI-API-Schlüssel als Umgebungsvariable (ersetzen Sie `your-key-here` durch Ihren tatsächlichen Schlüssel).

export OPENAI_API_KEY="your-key-here"

Unter Windows (PowerShell):

$env:OPENAI_API_KEY="your-key-here"

4. (Optional) Ollama für lokale Modelle installieren und starten

Wenn Sie lokale Inferenz bevorzugen, installieren Sie Ollama von [ollama.ai](https://ollama.ai) und laden Sie ein Modell.

# Nach der Installation von Ollama
ollama pull llama3.1

Aufbau der Schiedsrichter-Pipeline

Unsere Pipeline besteht aus drei Phasen: 1. **Dokumente erfassen** in einem Vektorspeicher. 2. **Top-K-Kandidaten abrufen** mittels Embedding-Ähnlichkeit. 3. **LLM-Schiedsrichter** bewertet jeden Kandidaten mit Begründung und führt ein Neues Ranking durch.

Schritt 1: Beispieldokumente erfassen

Erstellen Sie ein Python-Skript `ingest.py`, um einen kleinen Korpus zu laden. Wir verwenden fiktive KI-Politikdokumente.

# ingest.py
import pandas as pd
from langchain_community.vectorstores import Chroma
from langchain_openai import OpenAIEmbeddings
from langchain.schema import Document

# Beispieldokumente (in der Praxis aus Dateien laden)
documents = [
    Document(page_content="Im Jahr 2024 wurde das EU-KI-Gesetz verabschiedet, das Transparenz für Hochrisikosysteme fordert.", metadata={"source": "eu_ai_act.txt", "date": "2024-06-01"}),
    Document(page_content="Google veröffentlichte 2023 neue Richtlinien für verantwortungsvolle KI-Entwicklung mit Fokus auf Fairness.", metadata={"source": "google_ai_blog.txt", "date": "2023-03-15"}),
    Document(page_content="Microsofts Responsible AI Standard (2022) beschreibt Prinzipien für menschliche Aufsicht.", metadata={"source": "microsoft_ai_blog.txt", "date": "2022-11-01"}),
    Document(page_content="OpenAI kündigte 2024 GPT-4o-mini an, ein kosteneffizientes Modell für Entwickler.", metadata={"source": "openai_news.txt", "date": "2024-07-01"}),
    Document(page_content="Die US-Exekutivanordnung von 2023 zur KI-Sicherheit schreibt Berichterstattung für große Modelle vor.", metadata={"source": "us_eo.txt", "date": "2023-10-30"}),
]

# Embeddings initialisieren (OpenAI)
embeddings = OpenAIEmbeddings(model="text-embedding-3-small")

# Vektorspeicher erstellen
vectorstore = Chroma.from_documents(
    documents,
    embeddings,
    persist_directory="./chroma_db"
)
print("Dokumente erfolgreich erfasst.")

Führen Sie das Skript aus:

python ingest.py

Schritt 2: Kandidaten abrufen

Erstellen Sie nun eine Retrieval-Funktion, die Top-K-Kandidaten abruft.

# retrieve.py
from langchain_community.vectorstores import Chroma
from langchain_openai import OpenAIEmbeddings

embeddings = OpenAIEmbeddings(model="text-embedding-3-small")
vectorstore = Chroma(persist_directory="./chroma_db", embedding_function=embeddings)

def retrieve_candidates(query: str, k: int = 5):
    """Gibt die Top-k-Dokumente mit Metadaten zurück."""
    results = vectorstore.similarity_search_with_score(query, k=k)
    # Für den Schiedsrichter formatieren
    candidates = []
    for doc, score in results:
        candidates.append({
            "content": doc.page_content,
            "metadata": doc.metadata,
            "similarity_score": round(score, 4)
        })
    return candidates

Schritt 3: LLM-Schiedsrichter-Funktion

Der Kern unseres Ansatzes: Das LLM bewertet jeden Kandidaten und gibt eine Bewertung (1-10) mit einer Begründung zurück.

# arbiter.py
from langchain_openai import ChatOpenAI

# LLM initialisieren (GPT-4o-mini für Kosteneffizienz verwenden)
llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)

def arbiter_score(query: str, candidate: dict) -> dict:
    """LLM bitten, ein einzelnes Kandidatendokument zu bewerten."""
    prompt = f"""Sie sind ein Retrieval-Schiedsrichter. Bewerten Sie die Relevanz des folgenden Dokuments für die Benutzerabfrage.
Abfrage: {query}
Dokument: {candidate['content']}
Metadaten (Quelle, Datum): {candidate['metadata']}

Geben Sie eine JSON-Antwort mit:
- "score": Ganzzahl 1-10 (10=perfekt relevant)
- "reason": prägnante Erklärung (maximal 2 Sätze)

Antwort:"""
    
    response = llm.invoke(prompt)
    # Antwort parsen (vereinfacht: gültiges JSON annehmen)
    import json
    try:
        result = json.loads(response.content)
    except:
        result = {"score": 5, "reason": "Parsing-Fehler"}
    return result

Schritt 4: Vollständige Pipeline mit Neusortierung

Kombinieren Sie Retrieval und Schiedsgericht in einer Funktion.

# pipeline.py
from retrieve import retrieve_candidates
from arbiter import arbiter_score

def rag_with_arbiter(query: str, k: int = 5):
    """Kandidaten abrufen, bewerten und neu sortieren."""
    # Schritt 1: Abrufen
    candidates = retrieve_candidates(query, k=k)
    
    # Schritt 2: Jeden Kandidaten bewerten
    scored_candidates = []
    for cand in candidates:
        arbiter_result = arbiter_score(query, cand)
        cand["llm_score"] = arbiter_result["score"]
        cand["reason"] = arbiter_result["reason"]
        scored_candidates.append(cand)
    
    # Schritt 3: Nach LLM-Bewertung neu sortieren (absteigend)
    scored_candidates.sort(key=lambda x: x["llm_score"], reverse=True)
    
    return scored_candidates

Anwendungsbeispiele

Beispiel 1: Einfache Abfrage

Führen Sie eine Abfrage aus, um den Schiedsrichter in Aktion zu sehen.

# example1.py
from pipeline import rag_with_arbiter

query = "Was sind die neuesten KI-Regulierungen im Jahr 2024?"
results = rag_with_arbiter(query, k=3)

for i, r in enumerate(results, 1):
    print(f"Rang {i}: Bewertung {r['llm_score']}/10")
    print(f"  Dokument: {r['content'][:80]}...")
    print(f"  Begründung: {r['reason']}")
    print(f"  Quelle: {r['metadata']['source']}")
    print()

**Erwartete Ausgabe (Beispiel):**

Rang 1: Bewertung 9/10
  Dokument: Im Jahr 2024 wurde das EU-KI-Gesetz verabschiedet...
  Begründung: Erwähnt direkt 2024-Regulierungen; hochrelevant.
  Quelle: eu_ai_act.txt

Rang 2: Bewertung 7/10
  Dokument: Die US-Exekutivanordnung von 2023 zur KI-Sicherheit...
  Begründung: Relevant, aber von 2023, nicht explizit 2024.
  Quelle: us_eo.txt

Rang 3: Bewertung 4/10
  Dokument: Google veröffentlichte 2023 neue Richtlinien für...
  Begründung: Fokussiert auf Fairness, nicht auf Regulierungen; älter.
  Quelle: google_ai_blog.txt

Beispiel 2: Komplexe Abfrage mit zeitlicher Argumentation

# example2.py
from pipeline import rag_with_arbiter

query = "Finde die aktuellste Ankündigung eines kosteneffizienten Modells von OpenAI"
results = rag_with_arbiter(query, k=5)

for r in results:
    print(f"Bewertung: {r['llm_score']} | {r['metadata']['source']} | Begründung: {r['reason']}")

**Erwartete Ausgabe:**

Bewertung: 10 | openai_news.txt | Passt direkt: GPT-4o-mini ist ein kosteneffizientes Modell von OpenAI aus 2024.
Bewertung: 3 | eu_ai_act.txt | Nicht über OpenAI oder Modellankündigungen.
Bewertung: 2 | microsoft_ai_blog.txt | Irrelevant: Microsoft, nicht OpenAI.
...

Beispiel 3: Debugging mit Begründungen

Die Begründungen ermöglichen es Ihnen zu verstehen, *warum* ein Dokument niedrig eingestuft wurde.

# debug.py
results = rag_with_arbiter("KI-Sicherheitsrichtlinien der US-Regierung", k=4)
for r in results:
    if r["llm_score"] < 5:
        print(f"Niedrige Bewertung für {r['metadata']['source']}: {r['reason']}")

**Ausgabe:**

Niedrige Bewertung für openai_news.txt: Behandelt ein Modell, keine Sicherheitsrichtlinien oder Regierung.
Niedrige Bewertung für eu_ai_act.txt: EU-Regulierung, nicht US-Regierung.

Erweiterte Konfiguration

Verwendung lokaler Modelle (Ollama)

Ersetzen Sie OpenAI durch ein lokales LLM aus Datenschutz- oder Kostengründen.

# arbiter_ollama.py
from langchain_ollama import ChatOllama

llm = ChatOllama(model="llama3.1", temperature=0)

# Gleiche arbiter_score-Funktion wie zuvor, nur mit diesem llm

Batch-Bewertung für Effizienz

Bei vielen Kandidaten reduziert die Batch-Verarbeitung die Latenz.

# batch_arbiter.py
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate

llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)

prompt = ChatPromptTemplate.from_template(
    "Bewerten Sie bei der Abfrage: {query}\nJedes Dokument (1-10) mit einer Begründung.\nDokumente:\n{docs}"
)

def batch_arbiter(query: str, candidates: list):
    docs_text = "\n---\n".join([f"Dok {i+1}: {c['content']}" for i, c in enumerate(candidates)])
    response = llm.invoke(prompt.format(query=query, docs=docs_text))
    # Strukturierte Ausgabe parsen (Implementierung hängt von Ihrem Prompt-Design ab)
    return response.content

Fazit

Die Verwendung eines LLMs als Schiedsrichter im RAG-Retrieval verwandelt einen einfachen Ranking-Schritt in einen argumentationsbewussten Prozess. Indem Sie das LLM bitten, Kandidaten mit expliziten Begründungen zu bewerten, gewinnen Sie:

• **Höhere Relevanz**: Das LLM erfasst Nuancen wie zeitlichen Kontext und Intention.
• **Transparenz**: Jedes Ranking wird mit einer menschenlesbaren Erklärung geliefert.
• **Flexibilität**: Sie können den Schiedsrichter-Prompt an domänenspezifische Kriterien anpassen (z. B. "bevorzuge peer-reviewte Quellen").

Der Nachteil sind erhöhte Latenz und Kosten – jede Abfrage verursacht einen zusätzlichen LLM-Aufruf. Für Anwendungen, bei denen die Retrieval-Qualität entscheidend ist (z. B. juristische Recherche, medizinische Q&A oder Unternehmenswissensdatenbanken), überwiegt der Nutzen jedoch den Aufwand.

Um loszulegen, klonen Sie die obigen Code-Ausschnitte und experimentieren Sie mit Ihren eigenen Dokumenten. Da LLMs sich ständig verbessern (wie aktuelle Ankündigungen von OpenAI, Google und Microsoft zeigen), wird der Schiedsrichter-Ansatz nur noch leistungsfähiger – und noch wichtiger für den Aufbau vertrauenswürdiger, kontextbewusster KI-Systeme.