GraphRAG (Graph-based RAG)

Composants

1. Entity & Relationship Extraction

Prompt LLM appliqué chunk par chunk pour extraire entités et relations.

Tu es un extracteur d'entités. Pour ce texte, identifie :

1. Toutes les ENTITÉS (personnes, organisations, concepts, lieux, dates)
2. Toutes les RELATIONS entre ces entités

Format JSON :
{
  "entities": [
    {"name": "...", "type": "person|org|concept|place|date", "description": "..."}
  ],
  "relationships": [
    {"source": "...", "target": "...", "type": "...", "description": "..."}
  ]
}

Texte: {chunk}

Coût : 1 appel LLM par chunk de 1k tokens. Pour 1M tokens corpus → ~1k appels.

2. Graph storage

3. Community Detection (Leiden)

L'algorithme Leiden (Traag et al. 2019, successeur de Louvain) partitionne le graphe en communautés denses à plusieurs niveaux de granularité.

import igraph as ig
import leidenalg

g = build_graph_from_neo4j()
partition = leidenalg.find_partition(
    g,
    leidenalg.ModularityVertexPartition,
    resolution_parameter=1.0,
)
# partition.membership = [community_id pour chaque node]

Multi-résolution : on lance Leiden avec différents resolution_parameter pour créer une hiérarchie :

• Résolution faible (0.5) : peu de grosses communautés (vue macro)
• Résolution haute (2.0) : beaucoup de petites communautés (vue micro)

4. Community Summarization

Pour chaque communauté détectée, un LLM génère un résumé structuré :

Cette communauté contient les entités suivantes :
{entities_in_community}

Et les relations suivantes :
{relationships_in_community}

Génère un résumé structuré :
- Theme : ...
- Key entities : ...
- Key relationships : ...
- Insights : ...

Ces résumés sont stockés et indexés.

5. Query Routing

Le LLM classifie la query :

• Local : "Qui est X ?" "Quels sont les concepts liés à Y ?"
• Global : "Quels sont les principaux thèmes ?" "Résume les tendances..."

6. Local Search

Récupère le sous-graphe autour d'une entité, sérialise et passe au LLM.

7. Global Search

Map-reduce : pour chaque community summary, génère une réponse partielle, puis combine en réponse finale.

Gains mesurés (papier Microsoft)

Bénéfices typiques : pour des questions de synthèse globale, GraphRAG domine. Pour des questions factuelles ponctuelles, vector RAG suffit.

GraphRAG vs Vector RAG vs Hybrid

Règle : utiliser GraphRAG en complément, pas en remplacement. Hybrid (vector + graph) est souvent optimal.

Frameworks production

Pipeline minimal (Microsoft GraphRAG)

pip install graphrag

# 1. Init projet
python -m graphrag.index --init --root ./graphrag_workspace

# 2. Configurer .env (OpenAI/Azure key)
echo "GRAPHRAG_API_KEY=sk-..." > ./graphrag_workspace/.env

# 3. Mettre les documents dans ./graphrag_workspace/input/

# 4. Build le graphe (coûteux : ~$10-50 pour 1M tokens corpus)
python -m graphrag.index --root ./graphrag_workspace

# 5. Query
python -m graphrag.query \
  --root ./graphrag_workspace \
  --method global \
  "Quelles sont les principales tendances ?"

Coût et latence

Build : très coûteux. Pour 1M tokens corpus :

• Entity extraction : ~$5-15 (GPT-4o-mini)
• Community detection : gratuit (algo)
• Community summaries : ~$5-15
• Total build : $10-30 pour ~1M tokens corpus, 1-shot

Query :

• Local search : ~$0.001-0.01
• Global search : ~$0.05-0.5 (map-reduce sur community summaries)

→ GraphRAG est rentable si vous réutilisez beaucoup le corpus. Pour du one-shot, c'est trop cher.

Quand utiliser GraphRAG

✅ Bons cas :

• Research synthesis : "Quelles sont les avancées en X depuis Y ?"
• Executive summaries : "Résume les rapports de Q4"
• Multi-document reasoning : "Compare les positions de A et B sur le sujet C"
• Scientific literature review : "Quels sont les courants de pensée en Z ?"
• Legal case law : "Quelles jurisprudences relient X et Y ?"
• Knowledge base auditing : "Quelles connaissances sont liées à Z ?"
• Narrative understanding : "Quelle est l'histoire de cette entité ?"

❌ Mauvais cas :

• Single fact lookup : "Qui est le PDG de X ?" → vector RAG suffit
• Simple Q&A : "Quelle est la couleur de Y ?" → trop coûteux
• Latency-critical (<500ms) → trop lent
• Corpus très petit (<100k tokens) → overkill
• Corpus changeant en temps réel → graph rebuild coûteux

Anti-patterns

1. Utiliser GraphRAG pour du fact lookup → vector RAG est meilleur et 10x moins cher
2. Pas de multi-resolution Leiden → on perd la hiérarchie d'abstraction
3. Pas de schéma d'entités défini → extraction inconsistante
4. Mêmes prompts d'extraction pour tous les domaines → résultats médiocres
5. Pas de cache d'extraction → re-extraire = re-payer
6. Graph qui grandit indéfiniment sans pruning → query slow
7. Pas de versioning du graph → impossible de rollback
8. Confondre Leiden et Louvain → Leiden est strictement supérieur (utilise Leiden)
9. Pas de query routing → tout passe en global search → trop cher
10. Construction one-shot sans incremental update → re-build complet à chaque ajout
11. Pas de monitoring de la qualité du graph → drift silencieux
12. Visualisation négligée → impossible de débugger les problèmes d'extraction

GraphRAG + vector hybride

Le meilleur setup en 2026 = hybride :

• Vector RAG pour les questions factuelles (rapide, pas cher)
• GraphRAG pour les questions globales (riche, structuré)
• Query classifier en amont pour router

def hybrid_rag(query):
    intent = classify_intent(query)
    if intent == "factual":
        return vector_rag(query)
    elif intent == "global":
        return graphrag_global(query)
    else:
        return graphrag_local(query)

Quand déléguer

• RAG vector classique → agent rag-architect (ce plugin)
• Choix vector DB → skills pinecone-patterns / weaviate-patterns / qdrant-patterns (ce plugin)
• Auto-correction RAG → skill corrective-rag (ce plugin)
• Implémentation production → agent rag-architect (ce plugin)
• MCP Neo4j → MCP server officiel Neo4j si disponible

Ressources

• Paper Microsoft : https://arxiv.org/abs/2404.16130
• Microsoft GraphRAG : https://github.com/microsoft/graphrag
• LightRAG (HKU) : https://github.com/HKUDS/LightRAG
• FalkorDB : https://www.falkordb.com/
• Neo4j GraphRAG : https://neo4j.com/labs/genai-ecosystem/graphrag/
• Leiden algorithm paper : https://www.nature.com/articles/s41598-019-41695-z