Standard RAG knowledge base:
  [Chunk 1: Company X acquired Company Y in 2022]
  [Chunk 2: Company Y was founded by John Smith and Mary Jones]
  [Chunk 3: Mary Jones previously built Product Z at StartupCo]
  [Chunk 4: Product Z is known for its graph-based search technology]

Query: "What technology does Company X now own through their acquisition?"

Standard RAG: May retrieve Chunk 1 (acquisition) but miss the chain
→ Incomplete answer: "Company X acquired Company Y"

Graph RAG knowledge graph:
  Company X → [ACQUIRED] → Company Y
  Company Y → [FOUNDED_BY] → Mary Jones
  Mary Jones → [CREATED] → Product Z
  Product Z → [USES_TECHNOLOGY] → Graph-Based Search

Query traversal: Company X → acquisition → Company Y → founder → Mary Jones → creation → Product Z
→ Complete answer: "Through the acquisition of Company Y, Company X now owns Product Z,
  a graph-based search technology developed by co-founder Mary Jones."

GraphRAG Pipeline:

Phase 1: Entity and Relationship Extraction
  Documents → LLM extracts → (entity, relationship, entity) triples
  "AWS launched EC2 in 2006" → (AWS, LAUNCHED, EC2), (EC2, YEAR, 2006)

Phase 2: Graph Construction
  All triples → NetworkX/Neo4j graph
  Nodes = entities, Edges = relationships with descriptions

Phase 3: Community Detection
  Leiden algorithm partitions graph into community clusters
  Community 1: AWS, EC2, S3, Lambda (AWS services)
  Community 2: Azure, AKS, CosmosDB (Azure services)
  Community 3: GCP, GKE, BigQuery (GCP services)

Phase 4: Community Summarization
  LLM generates summaries for each community
  "The AWS services community includes compute (EC2), storage (S3), and
  serverless (Lambda) offerings from Amazon Web Services..."

Phase 5: Retrieval
  Global queries: search over community summaries
  Local queries: search within specific community subgraphs

# settings.yaml configuration
# llm:
#   type: openai_chat
#   model: gpt-4o-mini
#   max_tokens: 4000
# embeddings:
#   llm:
#     type: openai_embedding
#     model: text-embedding-3-small

# Run indexing pipeline
import subprocess
subprocess.run(["python", "-m", "graphrag.index", "--root", "."])

# Query the graph
result = subprocess.run(
    ["python", "-m", "graphrag.query", "--root", ".", "--method", "global",
     "--query", "What are the main technology companies and their relationships?"],
    capture_output=True, text=True
)
print(result.stdout)

from langchain_community.graphs import Neo4jGraph
from langchain_experimental.graph_transformers import LLMGraphTransformer
from langchain_openai import ChatOpenAI

# Connect to Neo4j
graph = Neo4jGraph(
    url="bolt://localhost:7687",
    username="neo4j",
    password="your-password"
)

# Extract entities and relationships with LLM
llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)
graph_transformer = LLMGraphTransformer(
    llm=llm,
    allowed_nodes=["Person", "Company", "Product", "Technology", "Event"],
    allowed_relationships=["WORKS_AT", "FOUNDED", "ACQUIRED", "BUILT", "USES"],
)

# Process documents into graph
from langchain_core.documents import Document
docs = [Document(page_content=text) for text in document_texts]

graph_docs = graph_transformer.convert_to_graph_documents(docs)
graph.add_graph_documents(graph_docs, baseEntityLabel=True, include_source=True)

from langchain.chains import GraphCypherQAChain
from langchain_community.vectorstores import Neo4jVector

# Vector index on entity descriptions
vector_index = Neo4jVector.from_existing_graph(
    embedding=OpenAIEmbeddings(),
    url="bolt://localhost:7687",
    username="neo4j",
    password="your-password",
    node_label="Document",
    text_node_properties=["text"],
    embedding_node_property="embedding",
)

# Graph traversal for relationship queries
graph_chain = GraphCypherQAChain.from_llm(
    llm=ChatOpenAI(model="gpt-4o"),
    graph=graph,
    verbose=True,
    return_direct=False,
)

def hybrid_graph_rag(query: str) -> str:
    # Detect if query needs relationship traversal
    needs_graph = any(kw in query.lower() for kw in
        ["relationship", "connected", "acquired", "founded", "related", "how are"])

    if needs_graph:
        # Graph traversal for relationship queries
        return graph_chain.invoke({"query": query})
    else:
        # Vector search for semantic content queries
        docs = vector_index.similarity_search(query, k=5)
        return synthesize_answer(query, docs)

Graph RAG significantly outperforms standard RAG on:

✓ Multi-hop relationship queries
  "Who are the investors of companies that Microsoft acquired?"

✓ Pattern queries across entities
  "Which employees worked at both Company A and Company B?"

✓ Aggregation over entity properties
  "What technologies do our top 10 enterprise customers use?"

✓ Temporal relationship chains
  "Trace the evolution of this product from original founder to current owner"

Standard RAG still wins for:
→ Direct factual lookups ("What is the refund policy?")
→ Semantic similarity queries ("Find documents about machine learning")
→ Content-dense queries that don't involve entity relationships

LLM extraction errors compound:
  "Apple acquired Beats Electronics" → (Apple, ACQUIRED, Beats) ✓
  "Tim Cook leads Apple" → (Tim_Cook, LEADS, Apple) ✓

  But also:
  "Apple's new product" → (Apple, HAS_NEW, Product) ← vague
  "The company was profitable" → (unknown, WAS, profitable) ← entity resolution failure