Warum RAG immer noch falsche Antworten liefert: Hybrider Suchalgorithmus, Reranking und Recall@K
Saubere Datenblöcke garantieren keine guten Antworten. Sehen Sie, wo die Vektorabrufung versagt und wie Fusion, ein Cross-Encoder-Reranker, HyDE sowie die Recall@K-Messung dies beheben.
Quellen: The AI Series: The Hardest Part of RAG, Part 2 — Why Perfect Chunks Still Give You Bad Retrieval
Ein häufiges Muster in RAG-Projekten: Die Parsierarbeit ist abgeschlossen. Die Fragmente sind sauber, Tabellen werden als Markdown ausgegeben, und jedes Fragment enthält eine Seitennummer sowie einen Abschnittstitel. Dennoch erhalten Nutzer in der Produktion weiterhin falsche Antworten auf Fragen, die das System eigentlich mühelos beantworten sollte. Die Fragmente sind nicht das Problem – der Datenabrufmechanismus holt einfach weiterhin die falschen Fragmente.
Gute Parsierung liefert gute Daten, doch gute Daten garantieren keinen guten Datenabruf. Das sind getrennte Probleme, wobei dem zweiten weitaus weniger Aufmerksamkeit geschenkt wird, als es verdient.
Was eine Ähnlichkeitssuche im Hintergrund tut
Viele Teams betrachten similarity_search() als Schwarzes Loch, weshalb ein kurzer Blick hinein hilfreich ist. Ein Embedding-Modell wandelt Text in eine Liste von Zahlen, also einen Vektor, um – der sich in einem Raum mit 384 bis 3072 Dimensionen befindet, je nach Modell. Texte mit ähnlicher Bedeutung sollen sich in der Nähe voneinander befinden, während unverwandte Texte weit voneinander entfernt sind.
Eine vereinfachte Version mit nur 4 Dimensionen sorgt dafür, dass die Zahlen lesbar bleiben:
"How do I reset my password?" → [0.81, 0.12, -0.44, 0.09]
"Steps to change your password" → [0.79, 0.15, -0.41, 0.11]
"How do I cancel my subscription?"→ [0.22, 0.68, 0.05, -0.39]
Zwei Vektoren werden mithilfe der Kosinusähnlichkeit verglichen, die misst, inwieweit sie in dieselbe Richtung zeigen, wobei die Länge ignoriert wird. Ein Wert von 1,0 bedeutet dieselbe Richtung, 0 bedeutet keine Beziehung, und negative Werte bedeuten entgegengesetzte Richtungen.
from numpy import dot
from numpy.linalg import norm
def cosine_similarity(a, b):
return dot(a, b) / (norm(a) * norm(b))
query = [0.80, 0.13, -0.42, 0.10] # "reset my password"
print(cosine_similarity(query, [0.81, 0.12, -0.44, 0.09])) # 0.998 - very close
print(cosine_similarity(query, [0.22, 0.68, 0.05, -0.39])) # 0.310 - far apart
Hinter dem Satz „KI versteht die Frage“ steckt nichts weiter als das. Es handelt sich dabei um Geometrie und nicht um Verständnis, und die Geometrie erklärt die Fehler: Die KI kann nicht erkennen, dass „nicht erlaubt“ die Bedeutung von „erlaubt“ umkehrt, noch dass „Error 4092“ ein wörtlicher String ist, der vom Benutzer abgeglichen werden muss.
Vier Arten, wie die Informationsabrufung versagt
Wenn ein Absatz auf einen einzigen Punkt zusammengefasst wird, gehen Informationen verloren. Sobald ein System das Demo-Bereich verlässt, treten weiterhin dieselben vier Fehler auf.
- Lexikalische Unübereinstimmung. Jemand sucht nach einem exakten Fehlercode oder Produkt-ID, die Embedding-Technologie behandelt dies jedoch als gewöhnlichen Token, wodurch der für diesen präzisen String vorgesehene Teil die Top 10 verpasst.
Eine Demo mit 20 Dokumenten zeigt keines dieser Probleme. Sie treten erst auf, wenn das Korpus echte Duplikate, Überschneidungen und Mehrdeutigkeiten enthält – was jedes Produktionsystem auszeichnet.
Ein Pipeline-Verfahren anstelle einer einzigen Anfrage
Ein einziger Aufruf an einen Vektorlagers ist kein Suchsystem. Ein widerstandsfähiges System weist mehrere Phasen auf:
Jede Phase existiert, weil die vorherige allein unzureichend ist. Das ist der größte Denkwechsel zwischen einer RAG-Demo und RAG in der Produktion: Jede Phase behebt eine bestimmte Schwäche in der vorherigen Phase, und keine davon dient nur der Verzierung.
Hybrische Suche mit Rangfusion
Die Vektorsuche kommt mit exakten Übereinstimmungen nur schlecht zurecht, während die Schlüsselwortsuche (BM25) bei konzeptuellen Übereinstimmungen schwach abschneidet. Anstatt sich für eine Methode zu entscheiden, sollten beide eingesetzt und die Ergebnisse miteinander kombiniert werden.
Die rekursive Rangfusion ist die einfachste Methode, um zwei gerankte Listen zu verbinden, wenn ihre Bewertungen nicht auf derselben Skala liegen. Eine typische Implementierung sieht so aus:
from collections import defaultdict
def reciprocal_rank_fusion(result_lists, k=60):
scores = defaultdict(float)
for result_list in result_lists:
for rank, doc_id in enumerate(result_list):
scores[doc_id] += 1 / (k + rank + 1)
return sorted(scores, key=scores.get, reverse=True)
vector_ids = [d.metadata["chunk_id"] for d in vector_store.similarity_search(query, k=20)]
bm25_ids = [d.metadata["chunk_id"] for d in bm25_index.search(query, k=20)]
final_ranking = reciprocal_rank_fusion([vector_ids, bm25_ids])
Ein häufiger früher Fehler besteht darin, die beiden Ergebnislisten ohne Zusammenführung zu verknüpfen. Die Liste, die zuerst kommt, dominiert stillschweigend den endgültigen Kontext, was den Zweck des Einsatzes von zwei Strategien zunichtemacht.
Neubewertung
Die schwierigste Phase der Analyse ist die Extraktion von Tabellen, während bei der Suche die Neubewertung eine zentrale Rolle spielt. Embedding-Modelle kodieren eine Abfrage sowie jedes Dokument unabhängig voneinander und vergleichen anschließend die Ergebnisse. Ein Neubewertungsmodul, in der Regel ein Cross-Encoder, liest Abfrage und Dokumentteile gemeinsam und gibt direkt eine Relevanzbewertung aus. Dies kostet mehr Zeit, weshalb es nur auf den 20 bis 50 besten Kandidaten nach der Zusammenführung angewendet wird – niemals auf dem gesamten Index.
from sentence_transformers import CrossEncoder
reranker = CrossEncoder("BAAI/bge-reranker-base")
def rerank(query, candidates, top_n=5):
pairs = [(query, c["text"]) for c in candidates]
scores = reranker.predict(pairs)
for c, s in zip(candidates, scores):
c["rerank_score"] = float(s)
return sorted(candidates, key=lambda c: c["rerank_score"], reverse=True)[:top_n]
In einem internen Support-Suchsystem erhöhte ein nach der Fusion eingefügter Neurangier den Recall@5 von etwa 61 % auf 84 %, ohne dass das Embedding-Modell oder die Chunk-Größe verändert wurden. Diese einzige Änderung überwog die Summe aller anderen Schritte im Prozess, wodurch sie zur üblichen ersten Empfehlung wird, wenn die Antworten von RAG plausibel, aber nicht ganz korrekt erscheinen.
Die Lücke im Wortschatz schließen
Manchmal ist der Index in Ordnung, das eigentliche Problem liegt jedoch in der Formulierung. Nutzer verwenden eine lockere Sprache („Warum lässt es mich nicht einloggen?“), während die Dokumentation formell ist („Authentifizierungsfehler können auftreten, wenn die Sitzungstoken ablaufen.“).
Zwei Techniken adressieren dieses Problem. Bei der Abfragenumformung lässt ein LLM eine vage Frage in einer Form wiederholen, die der Formulierung des Quellmaterials näherkommt. HyDE (Hypothetical Document Embeddings) geht einen Schritt weiter: Das LLM entwirft eine kurze, imaginäre Antwort, und dieser Text – nicht die ursprüngliche Frage – wird eingebettet und gesucht, denn eine plausible Antwort liegt im Vektorraum viel näher bei echten Antworten als die Frage selbst.
def hyde_retrieve(query, llm, vector_store, k=5):
hypothetical = llm.invoke(f"Write a short passage answering: {query}")
return vector_store.similarity_search(hypothetical, k=k)
Ein Support-Ticket-System, das dieses Verfahren anwendet, konnte einen erheblichen Anteil der Anfragen zurückgewinnen, die zuvor keine nützlichen Ergebnisse geliefert hatten – allein schon deshalb, weil Nutzer und Dokumentation unterschiedliche Ausdrucksweisen verwenden.
Die Rückholleistung direkt messen
Ein verlockender Kurzweg besteht darin, die Rückholleistung danach zu beurteilen, ob die endgültige Antwort des LLM plausibel klingt. Das verrät jedoch fast nichts darüber, in welcher Phase ein Fehler auftrat.
Es wird ein kleiner, beschrifteter Datensatz benötigt – selbst 50 bis 100 Paare aus Anfrage und korrektem Teilinhalt – damit Recall@K bereits vor Einbeziehung des LLM gemessen werden kann. Recall@K fragt: Von den Teilen, die tatsächlich die Antwort enthalten, wie viele befinden sich unter den ersten K Ergebnissen?
def recall_at_k(retrieved_ids, relevant_ids, k):
top_k = set(retrieved_ids[:k])
return len(top_k & relevant_ids) / len(relevant_ids) if relevant_ids else 0.0
Ohne dieses Werkzeug ist jede Änderung der Chunk-Größe, des Embedding-Modells oder des Rerankers nur eine Vermutung, die sich als Verbesserung ausgibt.
Problemstellen und eine sinnvolle Architektur
Das Erhöhen von k behebt selten schwache Suchleistungen, da es dem LLM hauptsächlich mehr Ablenkungen liefert. Die erste Woche mit der Anpassung der Chunk-Größe zu verbringen, lohnt sich ebenfalls nicht im Vergleich zum Fortschritt, den ein Reranker bringt. Schließlich sollte das Bewertungsset bereits vor dem Auftreten von Beschwerden erstellt werden, denn die Diagnose der Probleme danach kostet einen ganzen Entwicklungszyklus.
Eine vernünftige Architektur für den Aufbau dieser Schicht: Qdrant für die Vektorsuche, BM25 über OpenSearch in Kombination mit RRF, ein selbst gehosteter BGE-Reranker mit Cohere Rerank als gehosteter Ersatz sowie HyDE für konversationellen Abfragen.
Wo die Antwortqualität wirklich herkommt
Die Debatten konzentrieren sich meist darauf, welches LLM die flüssigste Endantwort liefert, doch der eigentliche entscheidende Faktor liegt bereits vor dem Modell: Wurden überhaupt die richtigen Datenabschnitte abgerufen? Ein brillantes Modell liefert bei falschem Kontext stets eine brillante, selbstsichere, aber falsche Antwort.
Die Parsing-Funktion bringt die Daten ins System, während die Abrufmechanismen bestimmen, ob der richtige Teil der Daten das Modell erreicht. Wenn einer dieser Schritte fehlerhaft ist, kann das anschließende Prompt-Engineering die Antwort nicht retten. Bei zuverlässigem Datenabruf stellt sich die nächste Frage, wie man automatisch und end-to-end überprüfen kann, ob das System angemessen über die abgerufenen Daten reflektiert, anstatt die Ausgaben nacheinander zu prüfen.
Verwandte Artikel
- RAG bei zehn Millionen Dokumenten – Abfristundenoptimierung: Kanäle, Router, Agenten und Bewertungsmethoden — Ein Abfrakanal mit einer Laufzeit von unter 200 ms, der SQL-Filter, hybride Suche und Neubewertung sowie Abfragerouting, agentebasierte Orchestrierung, Bewertungskennzahlen und ein Qdrant-Pipeline-Skript umfasst.
- Spring AI-Rezept: Filtern von RAG-Ergebnissen mithilfe von Metadaten nach Spieltitel — Eine Anleitung zu Spring AI, bei der Dokumente mit einem Titel versehen werden, ein LLM zur Auswahl des richtigen Wertes aus der Frage verwendet wird und anschließend die Vektorsuche darauf gefiltert wird.