Fortgeschrittene RAG-Techniken: LongRAG, Self-RAG und GraphRAG erklärt

LongRAG, Self-RAG, GraphRAG – Techniken der nächsten Generation

Inhaltsverzeichnis

Retrieval-Augmented Generation (RAG) hat sich weit über eine einfache Vektorsimilaritätssuche hinausentwickelt. LongRAG, Self-RAG und GraphRAG repräsentieren den Stand der Technik dieser Fähigkeiten.

Moderne RAG-Systeme müssen massive Dokumente verarbeiten, komplexe Entitätsbeziehungen verstehen und vieles mehr.

a-pirate-captain Dieses schöne Bild wurde vom KI-Modell Flux 1 dev generiert.

Die Evolution über das grundlegende RAG hinaus

Traditionelle RAG-Systeme folgen einem einfachen Muster: Dokumente werden in Chunks unterteilt, in Vektoren eingebettet, ähnliche Chunks werden per Kosinussimilarität abgerufen und einem LLM zugeführt. Während dieser Ansatz für viele Anwendungsfälle effektiv ist, stoßen hiermit drei entscheidende Szenarien an ihre Grenzen:

Das Verständnis der Unterschiede zwischen Search, Deepsearch und Deep Research hilft zu klären, warum fortgeschrittene RAG-Varianten für komplexe Informationsabrufaufgaben notwendig sind. Für eine tiefere Einarbeitung in diese Konzepte siehe Search vs. Deepsearch vs. Deep Research.

  1. Langstreckenabhängigkeiten: Wichtige Kontextinformationen können sich über Tausende von Tokens über mehrere Chunks hinweg erstrecken.
  2. Abruf-Sicherheit: Das System hat keine Möglichkeit zu beurteilen, ob der abgerufene Inhalt tatsächlich relevant ist.
  3. Komplexität der Beziehungen: Vektorsimilarität kann intricate Verbindungen zwischen Entitäten nicht erfassen.

Fortgeschrittene RAG-Varianten lösen diese Einschränkungen mit spezialisierten Architekturen, die auf bestimmte Herausforderungen zugeschnitten sind.

LongRAG: Die Eroberung erweiterter Kontexte

Architekturüberblick

LongRAG überdenkt die Chunking-Strategie grundlegend, indem es LLMs mit erweiterten Kontextfenstern (32K, 100K oder sogar 1M Tokens) nutzt. Anstatt Dokumente in kleine 512-Token-Chunks aufzuteilen, verwendet LongRAG einen hierarchischen Ansatz:

Dokumentebene-Einbettung: Das gesamte Dokument (oder sehr große Abschnitte) wird als eine einzige Einheit verarbeitet. Eine dokumentebennahe Einbettung erfasst die allgemeine semantische Bedeutung und erhält dabei den vollständigen Text für die nachgelagerte Verarbeitung.

Minimale Fragmentierung: Wenn das Chunking notwendig ist, verwendet LongRAG viel größere Chunks (4K–8K Tokens) mit erheblichen Überlappungen (20–30 %). Dies erhält den narrativen Fluss und reduziert die Kontextfragmentierung.

Kontextmontage: Zum Abrufzeitpunkt liefert LongRAG vollständige Dokumente oder große, kohärente Abschnitte statt verstreuter Fragmente. Das LLM erhält einen kontinuierlichen Kontext, der strukturelle und semantische Beziehungen erhält.

Implementierungsstrategie

Hier ist eine konzeptionelle Implementierung in Python mit modernen Embedding-Modellen:

from typing import List, Dict
import numpy as np

class LongRAGRetriever:
    def __init__(self, model, chunk_size=8000, overlap=1600):
        self.model = model
        self.chunk_size = chunk_size
        self.overlap = overlap
        self.doc_embeddings = []
        self.documents = []
    
    def create_long_chunks(self, text: str) -> List[str]:
        """Create overlapping large chunks"""
        chunks = []
        start = 0
        while start < len(text):
            end = start + self.chunk_size
            chunk = text[start:end]
            chunks.append(chunk)
            start += (self.chunk_size - self.overlap)
        return chunks
    
    def index_document(self, doc: str, metadata: Dict):
        """Index document with hierarchical embedding"""
        # Embed entire document
        doc_embedding = self.model.embed(doc)
        
        # Create large chunks with overlap
        chunks = self.create_long_chunks(doc)
        chunk_embeddings = [self.model.embed(c) for c in chunks]
        
        self.doc_embeddings.append({
            'doc_id': len(self.documents),
            'doc_embedding': doc_embedding,
            'chunk_embeddings': chunk_embeddings,
            'chunks': chunks,
            'full_text': doc,
            'metadata': metadata
        })
        self.documents.append(doc)
    
    def retrieve(self, query: str, top_k: int = 3) -> List[Dict]:
        """Retrieve relevant long-form content"""
        query_embedding = self.model.embed(query)
        
        # Score at document level first
        doc_scores = [
            np.dot(query_embedding, doc['doc_embedding'])
            for doc in self.doc_embeddings
        ]
        
        # Get top documents
        top_doc_indices = np.argsort(doc_scores)[-top_k:][::-1]
        
        results = []
        for idx in top_doc_indices:
            doc_data = self.doc_embeddings[idx]
            
            # For each document, find best chunks
            chunk_scores = [
                np.dot(query_embedding, emb)
                for emb in doc_data['chunk_embeddings']
            ]
            best_chunk_idx = np.argmax(chunk_scores)
            
            # Return extended context around best chunk
            context_chunks = self._get_extended_context(
                doc_data['chunks'], 
                best_chunk_idx
            )
            
            results.append({
                'text': ''.join(context_chunks),
                'score': doc_scores[idx],
                'metadata': doc_data['metadata']
            })
        
        return results
    
    def _get_extended_context(self, chunks: List[str], 
                             center_idx: int) -> List[str]:
        """Get extended context around relevant chunk"""
        start = max(0, center_idx - 1)
        end = min(len(chunks), center_idx + 2)
        return chunks[start:end]

Anwendungsfälle und Leistung

LongRAG excelled in Szenarien, in denen der Kontext von großer Bedeutung ist:

  • Analyse von Rechtsdokumenten: Verträge und Rechtsschriften haben oft Abhängigkeiten, die sich über Dutzende von Seiten erstrecken.
  • Retrieval von Forschungsarbeiten: Das Verständnis der Methodik erfordert kohärente Abschnitte, keine isolierten Absätze.
  • Code-Repositories: Funktionen und Klassen müssen in ihrem Modul-Kontext verstanden werden.

Leistungseigenschaften:

  • Latenz: Höher aufgrund der Verarbeitung großer Chunks (2–5× langsamer als Standard-RAG)
  • Genauigkeit: 15–25 % Verbesserung in Long-Form-QA-Benchmarks
  • Speicher: Erfordert 3–4× mehr Speicher für Kontextfenster

Self-RAG: Reflexiver Abruf

Grundprinzipien

Self-RAG führt eine metakognitive Schicht in RAG-Systeme ein. Anstatt blind abzurufen und zu generieren, reflektiert das System aktiv über seine eigenen Prozesse durch spezielle Reflexionstokens. Dieselbe selbstreflektierende, iterative Abruf-Idee taucht auf Anwendungsebene in selbst gehosteten Deep-Research-Systemen wieder auf – siehe Self-Hosted Deep Research Systems: 12 Tools Compared, um zu sehen, wie Tools wie Local Deep Research und lukeswade/deep-research ihre eigenen Evidenzlücken bewerten und entscheiden, was als Nächstes gesucht werden soll:

Retrieve-Token: Entscheidet, ob für eine gegebene Abfrage ein Abruf notwendig ist. Relevance-Token: Bewertet, ob abgerufene Dokumente tatsächlich relevant sind. Support-Token: Prüft, ob die generierte Antwort durch den abgerufenen Inhalt gestützt wird. Critique-Token: Bewertet die Gesamtqualität der generierten Antwort.

Architekturkomponenten

Die Self-RAG-Architektur besteht aus drei ineinandergreifenden Phasen:

class SelfRAGSystem:
    def __init__(self, retriever, generator, critic):
        self.retriever = retriever
        self.generator = generator
        self.critic = critic
    
    def generate_with_reflection(self, query: str, 
                                 max_iterations: int = 3):
        """Generate answer with self-reflection"""
        
        # Phase 1: Decide if retrieval needed
        retrieve_decision = self.critic.should_retrieve(query)
        
        if not retrieve_decision:
            # Direct generation without retrieval
            return self.generator.generate(query)
        
        # Phase 2: Retrieve and evaluate relevance
        retrieved_docs = self.retriever.retrieve(query)
        relevant_docs = []
        
        for doc in retrieved_docs:
            relevance_score = self.critic.assess_relevance(
                query, doc
            )
            if relevance_score > 0.7:  # Threshold
                relevant_docs.append(doc)
        
        if not relevant_docs:
            # Fallback to generation without retrieval
            return self.generator.generate(query)
        
        # Phase 3: Generate and verify support
        best_answer = None
        best_score = -1
        
        for _ in range(max_iterations):
            # Generate candidate answer
            answer = self.generator.generate(
                query, context=relevant_docs
            )
            
            # Evaluate support and quality
            support_score = self.critic.check_support(
                answer, relevant_docs
            )
            quality_score = self.critic.assess_quality(answer)
            
            total_score = 0.6 * support_score + 0.4 * quality_score
            
            if total_score > best_score:
                best_score = total_score
                best_answer = answer
            
            # Early stopping if high quality achieved
            if total_score > 0.9:
                break
        
        return {
            'answer': best_answer,
            'confidence': best_score,
            'sources': relevant_docs,
            'reflections': {
                'retrieved': retrieve_decision,
                'relevance': len(relevant_docs),
                'support': support_score
            }
        }

Training der Reflexionsmechanismen

Self-RAG erfordert das Training der Critic-Komponente, um zuverlässige Bewertungen vorzunehmen. Dies umfasst typischerweise:

  1. Supervised Fine-Tuning an Datensätzen mit Annotationen zu Relevanzurteilen
  2. Reinforcement Learning mit Belohnungen für genaue Vorhersagen
  3. Kontrastives Lernen, um gestützte und nicht gestützte Behauptungen zu unterscheiden

Die Reflexionstokens können implementiert werden als:

  • Spezielle Tokens im Wortschatz (wie [RETRIEVE], [RELEVANT])
  • Separate Classifier-Köpfe auf dem Modell
  • Externe Critic-Modelle (Ensemble-Ansatz)

Produktionsbetrachtungen

Bei der Bereitstellung von Self-RAG in Produktionssystemen:

Latenz-Auswirkungen: Jeder Reflexionsschritt fügt 20–40 % Overhead zur Inferenz hinzu. Balancieren Sie Gründlichkeit mit den Anforderungen an die Antwortzeit.

Konfidenzschwellen: Passen Sie die Reflexionsschwellen an Ihren Anwendungsfall an. Juristische oder medizinische Anwendungen benötigen eine höhere Konfidenz als allgemeine Chatbots.

Überwachung: Verfolgen Sie die Reflexionsentscheidungen, um Muster zu identifizieren. Wenn der Abruf selten benötigt wird, könnten Sie von einer einfacheren Architektur profitieren.

GraphRAG: Knowledge-Graph-gestützter Abruf

Konzeptionelle Grundlage

GraphRAG transformiert das Abrufproblem von der Vektorsimilarität zur Graphenbetrachtung. Anstatt semantisch ähnliche Textschnipsel zu finden, identifiziert GraphRAG relevante Teilgraphen verbundener Entitäten und Beziehungen.

Entitätsextraktion: Identifizierung benannter Entitäten, Konzepte und ihrer Typen Beziehungsabbildung: Extraktion von Beziehungen zwischen Entitäten (temporal, kausal, hierarchisch) Grafkonstruktion: Aufbau eines Wissensgraphs mit Entitäten als Knoten und Beziehungen als Kanten Teilgraph-Abruf: Gegeben eine Abfrage, werden relevante verbundene Teilgraphen gefunden

Pipeline für die Grafkonstruktion

Der Aufbau eines Wissensgraphs aus unstrukturiertem Text umfasst mehrere Stufen:

class GraphRAGBuilder:
    def __init__(self, entity_extractor, relation_extractor):
        self.entity_extractor = entity_extractor
        self.relation_extractor = relation_extractor
        self.graph = NetworkGraph()
    
    def build_graph(self, documents: List[str]):
        """Build knowledge graph from documents"""
        for doc in documents:
            # Extract entities
            entities = self.entity_extractor.extract(doc)
            
            # Add entities as nodes
            for entity in entities:
                self.graph.add_node(
                    entity['text'],
                    entity_type=entity['type'],
                    context=entity['surrounding_text']
                )
            
            # Extract relationships
            relations = self.relation_extractor.extract(
                doc, entities
            )
            
            # Add relationships as edges
            for rel in relations:
                self.graph.add_edge(
                    rel['source'],
                    rel['target'],
                    relation_type=rel['type'],
                    confidence=rel['score'],
                    evidence=rel['text_span']
                )
    
    def enrich_graph(self):
        """Add derived relationships and metadata"""
        # Compute node importance (PageRank, etc.)
        self.graph.compute_centrality()
        
        # Identify communities/clusters
        self.graph.detect_communities()
        
        # Add temporal ordering if timestamps available
        self.graph.add_temporal_edges()

Abfrageverarbeitung mit Grafen

GraphRAG-Abfragen beinhalten mehrstufiges Reasoning über den gesamten Wissensgraph:

class GraphRAGRetriever:
    def __init__(self, graph, embedder):
        self.graph = graph
        self.embedder = embedder
    
    def retrieve_subgraph(self, query: str, 
                         max_hops: int = 2,
                         max_nodes: int = 50):
        """Retrieve relevant subgraph for query"""
        
        # Identify seed entities in query
        query_entities = self.entity_extractor.extract(query)
        
        # Find matching nodes in graph
        seed_nodes = []
        for entity in query_entities:
            matches = self.graph.find_similar_nodes(
                entity['text'],
                similarity_threshold=0.85
            )
            seed_nodes.extend(matches)
        
        # Expand subgraph via traversal
        subgraph = self.graph.create_subgraph()
        visited = set()
        
        for seed in seed_nodes:
            self._expand_from_node(
                seed, 
                subgraph, 
                visited,
                current_hop=0,
                max_hops=max_hops
            )
        
        # Rank nodes by relevance
        ranked_nodes = self._rank_subgraph_nodes(
            subgraph, query
        )
        
        # Extract and format context
        context = self._format_graph_context(
            ranked_nodes[:max_nodes],
            subgraph
        )
        
        return context
    
    def _expand_from_node(self, node, subgraph, visited,
                         current_hop, max_hops):
        """Recursively expand subgraph"""
        if current_hop >= max_hops or node in visited:
            return
        
        visited.add(node)
        subgraph.add_node(node)
        
        # Get neighbors
        neighbors = self.graph.get_neighbors(node)
        
        for neighbor, edge_data in neighbors:
            # Add edge to subgraph
            subgraph.add_edge(node, neighbor, edge_data)
            
            # Recursively expand
            self._expand_from_node(
                neighbor,
                subgraph,
                visited,
                current_hop + 1,
                max_hops
            )
    
    def _format_graph_context(self, nodes, subgraph):
        """Convert subgraph to textual context"""
        context_parts = []
        
        for node in nodes:
            # Add node context
            context_parts.append(f"Entity: {node.text}")
            context_parts.append(f"Type: {node.entity_type}")
            
            # Add relationship information
            edges = subgraph.get_edges(node)
            for edge in edges:
                context_parts.append(
                    f"- {edge.relation_type} -> {edge.target.text}"
                )
        
        return "\n".join(context_parts)

Microsofts GraphRAG-Implementierung

Microsofts GraphRAG verfolgt einen einzigartigen Ansatz, indem es Community-Zusammenfassungen generiert:

  1. Aufbau des initialen Graphen aus Dokumenten mit LLM-basierter Entitäts-/Beziehungsextraktion
  2. Community-Erkennung Verwendung des Leiden-Algorithmus oder ähnlichen
  3. Generierung von Zusammenfassungen für jede Community unter Verwendung von LLMs
  4. Hierarchische Struktur: Aufbau mehrerer Ebenen von Community-Abstraktionen
  5. Abfragezeitpunkt: Abruf relevanter Communities und Traverse zu spezifischen Entitäten

Dieser Ansatz ist besonders effektiv für:

  • Explorative Abfragen („Was sind die Hauptthemen in diesem Korpus?")
  • Mehrstufiges Reasoning („Wie ist A über B mit C verbunden?")
  • Temporale Analyse („Wie haben sich die Beziehungen dieser Entität entwickelt?")

Vergleichende Analyse

Wann welche Variante verwenden

Verwenden Sie LongRAG, wenn:

  • Dokumente eine starke interne Kohärenz haben
  • Die Kontextfenster Ihres LLMs große Eingaben unterstützen (32K+)
  • Die Beantwortung von Abfragen das Verständnis von Langstreckenabhängigkeiten erfordert
  • Sie mit strukturierten Dokumenten arbeiten (Berichte, Papiere, Bücher)

Verwenden Sie Self-RAG, wenn:

  • Genauigkeit und Vertrauenswürdigkeit entscheidend sind
  • Sie nachvollziehbare Abrufentscheidungen benötigen
  • Falsch-positive Treffer aus irrelevanten Abrufen kostspielig sind
  • Die Komplexität der Abfragen stark variiert (einige benötigen Abruf, andere nicht)

Verwenden Sie GraphRAG, wenn:

  • Ihr Fachgebiet reiche Entitätsbeziehungen aufweist
  • Abfragen mehrstufiges Reasoning beinhalten
  • Temporale oder hierarchische Beziehungen wichtig sind
  • Sie die Verbindungen zwischen Entitäten verstehen müssen

Vergleich der Leistungsindikatoren

Metrik Standard RAG LongRAG Self-RAG GraphRAG
Indexierungszeit 1x 0.8x 1.1x 3-5x
Abfragelatenz 1x 2-3x 1.4x 1.5-2x
Speichernutzung 1x 3-4x 1.2x 2-3x
Genauigkeit (QA) Basis +15-25% +20-30% +25-40%*
Interpretierbarkeit Gering Mittel Hoch Hoch

*GraphRAG-Verbesserungen sind stark domänenabhängig

Hybride Ansätze

Die leistungsfähigsten Produktionssysteme kombinieren oft mehrere Techniken:

LongRAG + GraphRAG: Verwenden Sie die Graphenstruktur, um relevante Dokumentcluster zu identifizieren, und rufen Sie dann vollständige Dokumente statt Fragmente ab.

Self-RAG + GraphRAG: Wenden Sie Reflexionsmechanismen auf Graphen-Traverse-Entscheidungen an (welche Pfade gefolgt werden, wann die Expansion gestoppt wird).

Drei-Stufen-Pipeline: Verwenden Sie GraphRAG für den initialen entitätsbasierten Abruf → Self-RAG für die Relevanzfilterung → LongRAG für die Kontextmontage.

Implementierungserwägungen

Embedding-Modelle

Verschiedene RAG-Varianten haben unterschiedliche Anforderungen an Embeddings:

LongRAG: Benötigt Embeddings, die sowohl auf Dokument- als auch auf Chunk-Ebene gut funktionieren. Bedenken Sie Modelle, die mit kontrastivem Lernen an langen Sequenzen trainiert wurden.

Self-RAG: Profitiert von Embeddings, die semantische Nuancen für eine feinkörnige Relevanzbewertung erfassen.

GraphRAG: Erfordert entitätsbewusste Embeddings. Modelle, die an Entitätsverknüpfungsaufgaben feingestimmt wurden, performen besser.

Die Wahl des Embedding-Modells beeinflusst die Leistung erheblich. Wenn Sie mit lokalen Modellen arbeiten, bieten Tools wie Ollama eine einfache Möglichkeit, verschiedene Embedding-Modelle zu testen, bevor Sie sich für eine Produktionsbereitstellung entscheiden.

Chunking-Strategien im neuen Licht

Traditionelles Chunking fester Größe ist für fortgeschrittenes RAG nicht ausreichend:

Semantisches Chunking: Aufteilung an natürlichen Grenzen (Absätze, Abschnitte, Themenwechsel) Rekursives Chunking: Erstellung hierarchischer Chunks mit Eltern-Kind-Beziehungen Sliding Window: Verwendung überlappender Chunks, um den Kontext an den Grenzen zu erhalten Strukturbewusst: Wahrung der Dokumentstruktur (Markdown-Überschriften, XML-Tags, Code-Blöcke)

Für Python-basierte Implementierungen bieten Bibliotheken wie LangChain und LlamaIndex eingebauten Support für diese Chunking-Strategien.

Reranking-Integration

Reranking verbessert die Abrufqualität in allen RAG-Varianten erheblich. Nach dem initialen Abruf bewertet ein spezialisiertes Reranking-Modell die Ergebnisse neu, basierend auf Abfrage-Dokument-Interaktionsmerkmalen. Dies bietet einen erheblichen Genauigkeitsvorteil (10–20 %) mit minimalem Latenzeffekt, wenn es durchdacht integriert wird.

Skalierung auf die Produktion

Indexierungspipeline:

  • Verwendung verteilter Verarbeitung (Ray, Dask) für große Dokumentkorpora
  • Implementierung der inkrementellen Indexierung für Echtzeit-Updates
  • Speichern von Embeddings in optimierten Vektordatenbanken (Pinecone, Weaviate, Qdrant)

Abfrageoptimierung:

  • Cache häufiger Abfragen und ihrer Ergebnisse
  • Implementierung von Query-Routing (unterschiedliche RAG-Varianten für verschiedene Abfragetypen)
  • Verwendung der annäherndsten Nachbarn-Suche für sublineares Skalieren

Überwachung:

  • Verfolgung der Abruf-Relevanzscores
  • Überwachung der Reflexionsentscheidungen in Self-RAG
  • Messung der Graphen-Traverse-Pfade und -Tiefen
  • Protokollierung von Konfidenzscores und Nutzerfeedback

Reale Anwendungen

Suche in technischer Dokumentation

Ein großer Cloud-Anbieter implementierte GraphRAG für seine Dokumentation:

  • Entitäten: API-Endpunkte, Parameter, Fehlercodes, Dienstnamen
  • Beziehungen: Abhängigkeiten, Versionskompatibilitäten, Migrationspfade
  • Ergebnis: 35 % Reduktion der Support-Tickets, 45 % schnellere Lösungszeit

Juristische Discovery

Ein Legal-Tech-Unternehmen kombinierte Self-RAG mit LongRAG:

  • Self-RAG filtert irrelevante Dokumente frühzeitig aus
  • LongRAG erhält den Kontext in den beibehaltenen Dokumenten
  • Anwälte überprüfen 60 % weniger falsch-positive Treffer
  • Die Erhaltung kritischer Kontextinformationen verbesserte sich von 71 % auf 94 %

Literaturrecherche in der Forschung

Akademische Suchmaschine mit hybriden Ansatz:

  • GraphRAG identifiziert Zitationsnetzwerke und Forschungsgemeinschaften
  • LongRAG ruft vollständige Abschnitte ab und erhält dabei den Methodik-Kontext
  • 40 % Verbesserung bei der Entdeckung relevanter Papiere
  • Verkürzung der Zeit für Literaturreviews von Wochen auf Tage

Fortgeschrittene Themen

Multi-Modales RAG

Erweiterung dieser Varianten, um Bilder, Tabellen und Code zu verarbeiten:

  • Visuelle Verankerung: Verknüpfung von Text-Entitäten mit Bildern in Dokumenten
  • Tabellenverständnis: Parsern von strukturierten Daten in Graphenformat
  • Code-Analyse: Aufbau von Abhängigkeitsgraphen aus Codebasen

Adaptives RAG

Dynamische Auswahl der RAG-Strategie basierend auf den Eigenschaften der Abfrage:

  • Klassifizierer für Abfragekomplexität
  • Detektor für Dokumenttypen
  • Kosten-Nutzen-Optimierer für die Strategiewahl

RAG mit Privatsphärenschutz

Implementierung dieser Varianten mit Datenschutzbeschränkungen:

  • Föderatives Retrieval über Datensilos hinweg
  • Differenzielle Privatsphäre in Embeddings
  • Verschlüsselte Ähnlichkeitssuche

Erste Schritte

Schnelle Einführung mit Python

Für diejenigen, die beabsichtigen, diese Techniken zu implementieren, ist ein solides Python-Fundament unerlässlich. Das reichhaltige Ökosystem von Python für maschinelles Lernen macht es zur natürlichen Wahl für die RAG-Entwicklung.

Hier ist ein einfacher Einstiegspunkt für Experimente:

# Install dependencies
# pip install sentence-transformers faiss-cpu langchain

from sentence_transformers import SentenceTransformer
import faiss
import numpy as np

# Basic setup for experimenting with long chunks
model = SentenceTransformer('all-MiniLM-L6-v2')

documents = [
    # Your long-form documents here
]

# Create embeddings
embeddings = model.encode(documents)

# Build FAISS index
dimension = embeddings.shape[1]
index = faiss.IndexFlatL2(dimension)
index.add(embeddings.astype('float32'))

# Query
query = "Your question here"
query_embedding = model.encode([query])
distances, indices = index.search(
    query_embedding.astype('float32'), k=3
)

Framework-Auswahl

LangChain: Beste für schnelles Prototyping, umfangreiche Integrationen LlamaIndex: Optimierte für Dokumentindexierung und Abruf Haystack: Produktionsreif, starke Pipeline-Abstraktionen Custom: Wenn Sie volle Kontrolle und Optimierung benötigen

Evaluierungsrahmen

Implementieren Sie eine strenge Evaluierung vor der Produktionsbereitstellung:

Retrieval-Metriken:

  • Precision@K, Recall@K, MRR (Mean Reciprocal Rank)
  • NDCG (Normalized Discounted Cumulative Gain)

Generationsmetriken:

  • ROUGE, BLEU für Textähnlichkeit
  • BERTScore für semantische Ähnlichkeit
  • Human evaluation für Qualitätsbewertung

End-to-End-Metriken:

  • Task success rate
  • User satisfaction scores
  • Latency percentiles (p50, p95, p99)

Fazit

Die Landschaft der RAG-Systeme hat sich erheblich über die grundlegende Vektorsimilaritätssuche hinaus verfeinert. LongRAG, Self-RAG und GraphRAG adressieren jeweils spezifische Einschränkungen traditioneller Ansätze:

LongRAG löst das Problem der Kontextfragmentierung, indem es erweiterte Kontextfenster und minimales Chunking umarmt. Es ist die erste Wahl, wenn die Dokumentkohärenz wichtig ist und Sie über die Rechenressourcen verfügen, um große Kontexte zu verarbeiten.

Self-RAG fügt Retrieval-Systemen eine entscheidende Selbstwahrnehmung hinzu. Indem es über seine eigenen Entscheidungen reflektiert, reduziert es falsch-positive Treffer und verbessert die Vertrauenswürdigkeit – entscheidend für Hochrisiko-Anwendungen, in denen Genauigkeit wichtiger ist als Geschwindigkeit.

GraphRAG schaltet die Macht der strukturierten Wissensrepräsentation frei. Wenn Ihr Fachgebiet komplexe Beziehungen zwischen Entitäten umfasst, kann graphenbasiertes Retrieval Verbindungen aufdecken, die die Vektorsimilarität völlig verpasst. Die tiefere Frage, wie Wissen strukturiert werden soll, bevor es abgerufen wird – und warum Repräsentation genauso wichtig ist wie Abruf – wird in Retrieval vs. Representation in Knowledge Systems erörtert.

Die Zukunft von RAG involviert wahrscheinlich hybride Ansätze, die die Stärken dieser Varianten kombinieren. Ein Produktionssystem könnte GraphRAG verwenden, um relevante Entitätscluster zu identifizieren, Self-RAG zum Filtern und Validieren der Abrufe und LongRAG zum Zusammenstellen eines kohärenten Kontexts für das LLM.

Da LLMs weiter verbessert werden und Kontextfenster wachsen, werden wir noch ausgefeiltere RAG-Varianten sehen. Der Schlüssel liegt im Verständnis Ihrer spezifischen Anforderungen an den Anwendungsfall – Dokumentstruktur, Abfragemuster, Genauigkeitsanforderungen und Berechnungsbeschränkungen – und der Auswahl der geeigneten Technik oder Kombination davon.

Das Tooling-Ökosystem reift rapidly, mit Frameworks wie LangChain, LlamaIndex und Haystack, die zunehmend ausgefeilte Unterstützung für diese fortgeschrittenen Muster bieten. Kombiniert mit leistungsfähigen lokalen LLM-Runtimes und Embedding-Modellen war es nie einfacher, mit produktionsreifen RAG-Systemen zu experimentieren und sie bereitzustellen.

Beginnen Sie mit den Grundlagen, messen Sie die Leistung streng und entwickeln Sie Ihre Architektur weiter, wie es die Anforderungen diktieren. Die hier besprochenen fortgeschrittenen RAG-Varianten bieten eine Roadmap für diese Evolution.

Externe Referenzen

Abonnieren

Neue Beiträge zu Systemen, Infrastruktur und KI-Engineering.