What is the difference between Knowledge Graph RAG and normal RAG?

Knowledge Graph RAG vs Normal RAG

These two RAG approaches organize and retrieve information differently, each suited for different types of questions.

Core Difference

When Each Excels

Normal RAG (Vector-based):

textCopy
Q: "What is the company's refund policy?"
A: Retrieves the chunk containing refund policy → Great!

Q: "How does product A compare to product B?"
A: May retrieve chunks about A and B separately → OK

Q: "What products does the company that made X acquire from Y?"
A: Fails — can't reason about company relationships → Poor

Graph RAG:

textCopy
Q: "What is the company's refund policy?"
A: Entity lookup + vector search → Good (but overkill)

Q: "Who are all the researchers who worked on both GPT and Claude?"
A: Graph traversal: [GPT researchers] ∩ [Claude researchers] → Excellent!

Q: "What's the connection between OpenAI and Anthropic?"
A: Traverses graph: [OpenAI] --employees_left--> [Anthropic founders] → Perfect

Architecture Comparison

Normal RAG:

pythonCopy
# Simple, fast, good for most use cases
def normal_rag(question: str) -> str:
    chunks = vector_db.search(question, k=5)
    context = "\n".join(chunks)
    return llm.invoke(f"Context: {context}\n\nQ: {question}")

Knowledge Graph RAG:

pythonCopy
import networkx as nx

def kg_rag(question: str, graph: nx.DiGraph, vector_db) -> str:
    # 1. Vector search for initial context
    chunks = vector_db.search(question, k=3)

    # 2. Extract entities from question
    key_entities = extract_entities(question)  # LLM-based

    # 3. Traverse knowledge graph
    graph_facts = []
    for entity in key_entities:
        if entity in graph:
            # Get direct relationships
            for neighbor, edge_data in graph[entity].items():
                graph_facts.append(f"{entity} --{edge_data['rel']}--> {neighbor}")

            # Multi-hop: also get neighbors of neighbors
            for neighbor in graph.neighbors(entity):
                for hop2, hop2_data in graph[neighbor].items():
                    graph_facts.append(f"{entity} --[via {neighbor}]--> {hop2}")

    # 4. Combine for richer context
    context = "\n".join(chunks + graph_facts)
    return llm.invoke(f"Context:\n{context}\n\nQ: {question}")

Performance Characteristics

Hybrid Approach

Microsoft's GraphRAG and most production systems use both:

textCopy
Query
  ├── Vector Search (semantic similarity) ──────→ Relevant chunks
  └── Graph Traversal (entity relationships) ──→ Related facts
              ↓                                         ↓
                    Combined context
                          ↓
                    LLM generates answer

Use Case Guide