GraphRAG: Der Durchbruch, der traditionelles RAG obsolet macht

Traditionelles RAG hat eine fundamentale Schwaeche: Es behandelt Dokumente als isolierte Fragmente. GraphRAG, eingefuehrt von Microsoft Research, aendert alles, indem es einen vollstaendigen Wissensgraphen aufbaut, bevor die erste Frage gestellt wird. Das Ergebnis? Deutliche Genauigkeitsgewinne bei Multi-Hop- und schlussfolgerungsintensiven Fragen und die beispiellose Faehigkeit, globale Fragen ueber einen gesamten Korpus zu beantworten.

TL;DR

• GraphRAG kombiniert Knowledge Graphs und Vektorsuche fuer ueberlegenes Retrieval
• Prozess: Entitaetsextraktion, Graphkonstruktion, Community-Erkennung, Community-Zusammenfassungen
• Killer Feature: Beantwortung globaler Fragen ("Was sind die Hauptthemen im Korpus?")
• Bessere Genauigkeit bei Multi-Hop- und schlussfolgerungsintensiven Fragen als Standard-RAG (der Unterschied ist bei komplexen Anfragen deutlicher als bei einfachen faktischen Fragen)
• Anwendungsfaelle: Dokumentenanalyse, Wettbewerbsintelligenz, juristische Recherche, komplexe Wissensbasen
• Einschraenkungen: Hohe Indexierungskosten, erhoehte Komplexitaet, potenziell hoehere Latenz

Das Problem mit traditionellem RAG

Standard-RAG funktioniert in drei Schritten: Dokumente in Chunks aufteilen, vektorisieren und dann die aehnlichsten Chunks zur Frage abrufen. Dieser Ansatz hat zwei grosse Schwachstellen.

Schwachstelle 1: Multi-Hop-Fragen

Frage: "Wie hat Deutschlands Energiepolitik die Entscheidungen
        Frankreichs in Bezug auf Kernenergie beeinflusst?"

Standard-RAG:
├── Chunk 1: "Deutschland hat seine Kernkraftwerke 2023 abgeschaltet..."
├── Chunk 2: "Frankreich hat sein Kernkraftprogramm wiederbelebt..."
└── ❌ Kein einzelner Chunk stellt explizit die VERBINDUNG her

GraphRAG:
├── Entitaet: Deutschland → Relation: "beeinflusste" → Entitaet: Frankreich
├── Kontext: Energiepolitik, Kernenergie, Transition
└── ✅ Der Graph erfasst die BEZIEHUNG zwischen den Entitaeten

Schwachstelle 2: Globale Fragen

Frage: "Was sind die Hauptthemen in diesem Korpus von 500 Dokumenten?"

Standard-RAG: ❌ Unmoeglich - Vektoraehnlichkeit kann nicht synthetisieren
GraphRAG: ✅ Community-Zusammenfassungen bieten einen Ueberblick

Wie GraphRAG funktioniert

Die GraphRAG-Architektur gliedert sich in vier unterschiedliche Phasen waehrend der Indexierung, gefolgt von zwei Abfragemodi.

Phase 1: Extraktion von Entitaeten und Beziehungen

Ein LLM analysiert jeden Textchunk, um Entitaeten (Personen, Organisationen, Konzepte, Orte) und die Beziehungen zwischen ihnen zu extrahieren.

DEVELOPERpython
from graphrag.index import create_pipeline
from graphrag.config import GraphRagConfig

# Extraktionskonfiguration
config = GraphRagConfig(
    llm_model="gpt-4o",
    chunk_size=1200,
    chunk_overlap=100,
    entity_extraction_prompt="""
    Extrahiere alle Entitaeten und Beziehungen aus diesem Text.

    Entitaeten: Personen, Organisationen, Technologien, Konzepte, Orte
    Beziehungen: Art der Verbindung zwischen zwei Entitaeten

    Format:
    ENTITAETEN: [(Name, Typ, Beschreibung)]
    BEZIEHUNGEN: [(Quelle, Ziel, Typ, Beschreibung)]
    """,
    max_entities_per_chunk=30,
    max_relations_per_chunk=50
)

# Indexierung starten
pipeline = create_pipeline(config)
result = await pipeline.run(documents)

Phase 2: Konstruktion des Wissensgraphen

Extrahierte Entitaeten und Beziehungen werden zusammengefuehrt, um einen kohaerenten Graphen aufzubauen. Aehnliche Entitaeten werden gruppiert (Entity Resolution).

┌─────────────────────────────────────────────────────────────────┐
│                    Knowledge Graph                               │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│    [Microsoft] ──erstellt──▶ [GraphRAG]                         │
│         │                    │                                   │
│    beschaeftigt          verbessert                              │
│         │                    │                                   │
│    [Forscher] ──veroeffentlicht──▶ [Paper 2024]                 │
│                              │                                   │
│                          referenziert                             │
│                              │                                   │
│    [Neo4j] ◀──nutzt── [Knowledge Graph]                         │
│         │                    │                                   │
│      speichert           aufgebaut von                           │
│         │                    │                                   │
│    [Entitaeten] ◀──extrahiert── [LLM]                           │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

Phase 3: Community-Erkennung

Der Leiden-Algorithmus identifiziert Communities (Cluster) von stark verbundenen Entitaeten im Graphen. Jede Community repraesentiert ein Thema oder Unterthema des Korpus.

DEVELOPERpython
import networkx as nx
from graspologic.partition import hierarchical_leiden

# NetworkX-Graph aufbauen
G = nx.Graph()
for entity in entities:
    G.add_node(entity.name, type=entity.type, description=entity.description)

for relation in relations:
    G.add_edge(
        relation.source,
        relation.target,
        type=relation.type,
        description=relation.description,
        weight=relation.confidence
    )

# Hierarchische Community-Erkennung
communities = hierarchical_leiden(
    G,
    max_cluster_size=10,
    random_seed=42
)

print(f"Anzahl erkannter Communities: {len(communities)}")
# Anzahl erkannter Communities: 47

Phase 4: Community-Zusammenfassungen

Ein LLM generiert eine Zusammenfassung fuer jede Community und erfasst die Themen, Schluesselentitaeten und wichtigen Beziehungen. Diese Zusammenfassungen sind der Schluessel zum globalen Abfragemodus.

DEVELOPERpython
community_summary_prompt = """
Hier sind die Entitaeten und Beziehungen einer thematischen Community:

Entitaeten: {entities}
Beziehungen: {relations}

Erstelle eine umfassende Zusammenfassung dieser Community, die Folgendes umfasst:
1. Das Hauptthema
2. Schluesselentitaeten und ihre Rollen
3. Wichtige Beziehungen
4. Erkenntnisse oder Schlussfolgerungen
"""

# Jede Community erhaelt ihre Zusammenfassung
for community in communities:
    summary = llm.generate(
        community_summary_prompt.format(
            entities=community.entities,
            relations=community.relations
        )
    )
    community.summary = summary

Die zwei Abfragemodi

Lokaler Modus: Spezifische Fragen

Der lokale Modus funktioniert wie ein erweitertes RAG. Er identifiziert relevante Entitaeten in der Frage, traversiert den Graphen, um Kontext zu sammeln, und generiert eine Antwort.

DEVELOPERpython
from graphrag.query import LocalSearch

local_search = LocalSearch(
    llm=llm,
    context_builder=context_builder,
    token_budget=12000,
    community_level=2  # Detailgrad
)

# Spezifische Frage
result = await local_search.search(
    "Was ist die technische Architektur von GraphRAG?"
)

print(result.response)
print(f"Verwendete Entitaeten: {result.context_data['entities']}")
print(f"Traversierte Beziehungen: {result.context_data['relationships']}")

Globaler Modus: Synthesefragen

Der globale Modus ist DAS Killer Feature von GraphRAG. Er nutzt Community-Zusammenfassungen, um Fragen zu beantworten, die einen Ueberblick ueber den gesamten Korpus erfordern.

DEVELOPERpython
from graphrag.query import GlobalSearch

global_search = GlobalSearch(
    llm=llm,
    context_builder=context_builder,
    map_llm=map_llm,        # LLM fuer Map-Schritt
    reduce_llm=reduce_llm,  # LLM fuer Reduce-Schritt
    community_level=1        # Makro-Ebene
)

# Globale Frage - mit Standard-RAG unmoeglich
result = await global_search.search(
    "Was sind die wichtigsten Herausforderungen und Trends "
    "im Bereich RAG im Jahr 2026?"
)

# Verwendet ein Map-Reduce-Muster:
# 1. Map: Jede Community-Zusammenfassung wird bewertet
# 2. Reduce: Teilantworten werden synthetisiert

Vergleich: Standard-RAG vs GraphRAG

Genauigkeits-Benchmarks (systematische Evaluierung 2025)

Die tatsaechlichen Gewinne sind differenzierter, als das Marketing vermuten laesst. Eine systematische Evaluierung von RAG und GraphRAG (Han et al., 2025, arXiv:2502.11371) zeigt, dass sich der Vorteil von GraphRAG auf Multi-Hop- und schlussfolgerungsintensive Fragen konzentriert, waehrend Standard-RAG bei einfachen faktischen Fragen wettbewerbsfaehig bleibt — oder besser ist.

Der groesste Unterschied zeigt sich bei temporalen und schlussfolgerungsintensiven Fragen, wo GraphRAG mehr als 20 Genauigkeitspunkte gewinnen kann. Bei faktischen Single-Hop-Fragen behaelt Standard-RAG oft den Vorsprung.

Implementierung mit LangChain und Neo4j

Umgebung einrichten

DEVELOPERpython
# Installation
# pip install langchain langchain-community neo4j graphrag

from langchain_community.graphs import Neo4jGraph
from langchain_openai import ChatOpenAI, OpenAIEmbeddings
from langchain.chains import GraphCypherQAChain

# Verbindung zu Neo4j
graph = Neo4jGraph(
    url="bolt://localhost:7687",
    username="neo4j",
    password="ihr-passwort"
)

# LLM fuer Extraktion und Generierung
llm = ChatOpenAI(model="gpt-4o", temperature=0)
embeddings = OpenAIEmbeddings(model="text-embedding-3-large")

Entitaetsextraktion mit LangChain

DEVELOPERpython
from langchain_experimental.graph_transformers import LLMGraphTransformer

# Dokumente in einen Graphen transformieren
transformer = LLMGraphTransformer(
    llm=llm,
    allowed_nodes=["Person", "Organization", "Technology", "Concept"],
    allowed_relationships=[
        "CREATED", "WORKS_FOR", "USES", "IMPROVES",
        "COMPETES_WITH", "PART_OF", "RELATED_TO"
    ],
    node_properties=["description"],
    relationship_properties=["description", "strength"]
)

# Dokumentkonvertierung
from langchain_core.documents import Document

documents = [
    Document(page_content="Microsoft Research hat GraphRAG 2024 erstellt..."),
    Document(page_content="Neo4j ist die am weitesten verbreitete Graphdatenbank..."),
]

graph_documents = transformer.convert_to_graph_documents(documents)

# In Neo4j einfuegen
graph.add_graph_documents(
    graph_documents,
    baseEntityLabel=True,
    include_source=True
)

Hybride Abfrage (Graph + Vektoren)

DEVELOPERpython
from langchain_community.vectorstores.neo4j_vector import Neo4jVector
from langchain.chains import RetrievalQA

# Vektorindex in Neo4j
vector_store = Neo4jVector.from_existing_graph(
    embedding=embeddings,
    graph=graph,
    node_label="Document",
    text_node_properties=["text"],
    embedding_node_property="embedding"
)

# Hybride Chain: Graph + Vektoren
class HybridGraphRAGChain:
    def __init__(self, graph, vector_store, llm):
        self.graph_chain = GraphCypherQAChain.from_llm(
            llm=llm,
            graph=graph,
            verbose=True,
            validate_cypher=True
        )
        self.vector_retriever = vector_store.as_retriever(
            search_kwargs={"k": 5}
        )
        self.llm = llm

    async def query(self, question: str) -> str:
        # 1. Graph-Kontext abrufen
        graph_context = await self.graph_chain.arun(question)

        # 2. Vektor-Kontext abrufen
        vector_docs = await self.vector_retriever.aget_relevant_documents(
            question
        )
        vector_context = "\n".join([doc.page_content for doc in vector_docs])

        # 3. Zusammenfuehren und generieren
        prompt = f"""
        Wissensgraph-Kontext:
        {graph_context}

        Dokumenten-Kontext:
        {vector_context}

        Frage: {question}

        Beantworte die Frage durch Kombination beider Kontextquellen.
        """

        return await self.llm.ainvoke(prompt)

Wann GraphRAG vs Standard-RAG verwenden

Verwenden Sie GraphRAG wenn:

• Ihr Korpus komplexe Beziehungen zwischen Entitaeten enthaelt
• Benutzer Multi-Hop-Fragen stellen (mehrere Konzepte verbinden)
• Sie globale Zusammenfassungen ueber den gesamten Korpus benoetigen
• Die Domaene reich an benannten Entitaeten ist (Recht, Medizin, Wettbewerbsintelligenz)
• Genauigkeit wichtiger ist als Latenz und Kosten

Bleiben Sie bei Standard-RAG wenn:

• Fragen hauptsaechlich einfach und faktisch sind
• Der Korpus sich haeufig aendert (inkrementelle Updates sind bei GraphRAG schwierig)
• Das Budget begrenzt ist (GraphRAG kostet 10-50x mehr fuer die Indexierung)
• Die Latenz kritisch ist (< 2 Sekunden erforderlich)
• Der Korpus klein ist (< 100 Dokumente) - der Graph bringt nicht genug Mehrwert

Entscheidungsbaum

Enthaelt Ihr Korpus komplexe Beziehungen zwischen Entitaeten?
├── Nein → Standard-RAG
└── Ja
    ├── Stellen Benutzer Multi-Hop-Fragen?
    │   ├── Nein → Standard-RAG mit angereicherten Metadaten
    │   └── Ja
    │       ├── Benoetigen Sie globale Zusammenfassungen?
    │       │   ├── Nein → GraphRAG nur Lokaler Modus
    │       │   └── Ja → Vollstaendiges GraphRAG (Lokal + Global)
    │       └── Indexierungsbudget > 50$/Monat?
    │           ├── Nein → Standard-RAG + LLM-Nachbearbeitung
    │           └── Ja → GraphRAG
    └── Aendert sich der Korpus haeufig?
        ├── Ja → Standard-RAG (oder GraphRAG mit geplanter Neuindexierung)
        └── Nein → GraphRAG

GraphRAG-Kostenoptimierung

GraphRAG-Indexierung ist teuer, da sie LLM-Aufrufe fuer jeden Chunk erfordert. So koennen Sie die Kosten senken.

Geschaetzte Kosten nach Korpusgroesse

Tools und Frameworks

Microsoft GraphRAG (offiziell)

Microsofts Open-Source-Framework, das umfassendste fuer GraphRAG.

DEVELOPERbash
pip install graphrag

# Projektinitialisierung
graphrag init --root ./mein-projekt

# Indexierung
graphrag index --root ./mein-projekt

# Lokale Abfrage
graphrag query --root ./mein-projekt --method local \
  "Was ist die Architektur von GraphRAG?"

# Globale Abfrage
graphrag query --root ./mein-projekt --method global \
  "Was sind die Hauptthemen im Korpus?"

Neo4j + LangChain

Ideal fuer die Integration in ein bestehendes System. Siehe den Implementierungsabschnitt oben.

LlamaIndex Knowledge Graph

DEVELOPERpython
from llama_index.core import KnowledgeGraphIndex, SimpleDirectoryReader
from llama_index.graph_stores.neo4j import Neo4jGraphStore

# Dokumente laden
documents = SimpleDirectoryReader("./data").load_data()

# Knowledge-Graph-Index aufbauen
graph_store = Neo4jGraphStore(
    username="neo4j",
    password="passwort",
    url="bolt://localhost:7687"
)

kg_index = KnowledgeGraphIndex.from_documents(
    documents,
    graph_store=graph_store,
    max_triplets_per_chunk=10,
    include_embeddings=True
)

# Abfrage
query_engine = kg_index.as_query_engine(
    include_text=True,
    response_mode="tree_summarize"
)
response = query_engine.query("Welche Verbindungen bestehen zwischen X und Y?")

Aktuelle Forschung und Entwicklungen

Aktuelle Entwicklungen von Microsoft GraphRAG

Seit der Version 1.0 (Dezember 2024) ist das Framework erheblich gereift (v3.1.0 im Mai 2026). Mehrere der oben genannten Einschraenkungen sind bereits adressiert:

• Native inkrementelle Indexierung: Der Befehl graphrag update berechnet das Delta zwischen dem bestehenden Index und neuen Dokumenten, um eine vollstaendige Neuindexierung zu vermeiden (verfuegbar seit v0.4.0, November 2024)
• DRIFT Search: ein Abfragemodus, der lokale und globale Suche kombiniert
• LazyGraphRAG (angekuendigt im November 2024): verschiebt LLM-Aufrufe und senkt die Indexierungskosten auf das Niveau von klassischem Vektor-RAG (etwa 0,1% der Kosten von vollem GraphRAG), mit bis zu rund 700x niedrigeren Abfragekosten bei globalen Fragen

RAPTOR (Recursive Abstractive Processing)

Ein ergaenzender Ansatz, der hierarchische Zusammenfassungen statt eines Graphen erstellt. Kann mit GraphRAG kombiniert werden, um das Beste aus beiden Welten zu erhalten.

HippoRAG (2024)

Inspiriert vom menschlichen Hippocampus-Gedaechtnis, verwendet einen personalisierten Wissensgraphen kombiniert mit einem Mechanismus zur Gedaechtniskonsolidierung. Vielversprechend fuer Langzeitsysteme.

FAQ

Ist GraphRAG fuer kleine Korpora (< 50 Dokumente) geeignet?

Nicht wirklich. Fuer kleine Korpora wird Standard-RAG mit gutem Chunking und Reranking effektiver und deutlich kostenguenstiger sein. GraphRAG beginnt ab einigen hundert Dokumenten zu glaenzen, wo die Beziehungen zwischen Entitaeten zu komplex werden, um allein durch Vektoraehnlichkeit erfasst zu werden.

Kann man GraphRAG ohne Neo4j verwenden?

Ja. Microsofts offizielles Framework verwendet seinen eigenen Speicher (Parquet + Dateien). Sie koennen auch andere Graphdatenbanken wie Amazon Neptune, ArangoDB oder TigerGraph verwenden. Neo4j bleibt jedoch dank seines ausgereiften Oekosystems und der Cypher-Abfragesprache die beliebteste Wahl.

Wie geht man mit Graph-Updates um, wenn sich der Korpus aendert?

Das war historisch die Hauptherausforderung von GraphRAG. Microsofts Framework bietet inzwischen eine native inkrementelle Indexierung ueber den Befehl graphrag update (seit v0.4.0): Er extrahiert nur Entitaeten aus neuen Dokumenten und fuehrt sie dann mit dem bestehenden Graphen zusammen, um eine vollstaendige Neuindexierung zu vermeiden. Ansaetze wie LazyGraphRAG senken die Aktualisierungskosten zusaetzlich.

Funktioniert GraphRAG gut in anderen Sprachen als Englisch?

Ja, aber mit Nuancen. Die Entitaetsextraktion funktioniert gut mit GPT-4o und Claude ueber verschiedene Sprachen hinweg. Kleinere Modelle (GPT-4o-mini, Mistral) koennen jedoch bei der Beziehungsextraktion in nicht-englischen Sprachen weniger genau sein. Testen Sie systematisch an einer Stichprobe Ihres Korpus, bevor Sie die vollstaendige Indexierung starten.

Wie hoch ist der Latenz-Overhead im Vergleich zu Standard-RAG?

Der lokale Modus fuegt etwa 1 bis 3 Sekunden hinzu (Graph-Traversierung + angereicherter Kontext). Der globale Modus kann 8 bis 15 Sekunden dauern, da er ein Map-Reduce-Muster ueber alle Community-Zusammenfassungen verwendet. Fuer Echtzeitanwendungen (Chatbot) bevorzugen Sie den lokalen Modus mit aggressivem Caching fuer haeufige Abfragen.

Fazit

GraphRAG stellt einen bedeutenden qualitativen Sprung fuer komplexe RAG-Systeme dar. Seine einzigartige Faehigkeit, globale und Multi-Hop-Fragen zu beantworten, macht es zu einem unverzichtbaren Werkzeug fuer Korpora mit komplexen Entitaetsbeziehungen.

Wichtige Erkenntnisse:

1. GraphRAG glaenzt bei Multi-Hop- und schlussfolgerungsintensiven Fragen sowie bei globalen Zusammenfassungen
2. Die Indexierungskosten sind deutlich hoeher als bei Standard-RAG (10-50x)
3. Der globale Modus ist die eigentliche Innovation: Einen gesamten Korpus ueber Community-Zusammenfassungen synthetisieren
4. Das Oekosystem ist ausgereift: Microsoft GraphRAG, LangChain, LlamaIndex, Neo4j
5. Bewerten Sie Ihren Bedarf: Wenn Ihre Fragen einfach und faktisch sind, reicht Standard-RAG

Ailog integriert fortgeschrittene Retrieval-Techniken, einschliesslich wissensbasierter Graph-Ansaetze, um die beste Leistung fuer seine Benutzer zu liefern. Testen Sie unsere Plattform kostenlos, um zu entdecken, wie fortschrittliches RAG Ihre Kundenbeziehungen transformieren kann.

Ressourcen

• Microsoft GraphRAG (GitHub) - Offizielles Framework
• GraphRAG Paper - "From Local to Global: A Graph RAG Approach to Query-Focused Summarization"
• Neo4j + LangChain - Offizielle Integration
• Retrieval-Grundlagen - RAG-Retrieval-Grundlagen
• Hybrid Search RAG - Kombination von Vektor- und lexikalischer Suche
• Agentic RAG - Autonome Agenten mit RAG