GraphRAG: Graph-Based Retrieval-Augmented Generation

GraphRAG is an advanced form of Retrieval-Augmented Generation (RAG) that combines Knowledge Graphs with vector search to provide LLMs with structured, relationship-aware context. Unlike traditional RAG which retrieves isolated text chunks, GraphRAG retrieves interconnected entities, relationships, and reasoning paths.

Traditional RAG vs GraphRAG

Traditional RAG Architecture

// 1. Embed documents as chunks
const chunks = chunkDocument(document);
const embeddings = await embedModel.embed(chunks);
await vectorDB.insert(embeddings);

// 2. Retrieve similar chunks
const query = "How does X affect Y?";
const similarChunks = await vectorDB.search(query, { topK: 5 });

// 3. Concatenate chunks as context
const context = similarChunks.map(c => c.text).join("\n\n");

// 4. Generate response
const response = await llm.generate({ context, query });

Limitations:

• ❌ No understanding of relationships between chunks
• ❌ Can't reason across multiple hops
• ❌ No structured entity representation
• ❌ Redundant or contradictory information
• ❌ Limited to semantic similarity only

GraphRAG Architecture

// 1. Build Knowledge Graph from documents
await trustgraph.ingest({
  sources: ["documents/"],
  extractEntities: true,
  buildRelationships: true
});

// 2. Hybrid retrieval: Vector + Graph
const context = await trustgraph.retrieve({
  query: "How does X affect Y?",
  strategy: "graph-rag",

  // Vector search for semantic similarity
  vectorTopK: 10,

  // Graph traversal for relationships
  graphDepth: 3,
  includeRelationships: true,

  // Combine both approaches
  fusion: "weighted"
});

// 3. Context includes entities, relationships, and paths
// {
//   entities: [{ id, type, properties, source }],
//   relationships: [{ source, type, target, properties }],
//   paths: [["X", "affects", "intermediate", "causes", "Y"]],
//   provenance: [...]
// }

// 4. Generate with structured context
const response = await trustgraph.generate({ context, query });

Advantages:

• ✅ Understands relationships between entities
• ✅ Multi-hop reasoning across the graph
• ✅ Structured entity representation
• ✅ Consistent, non-contradictory information
• ✅ Combines semantic similarity with graph structure
• ✅ Provenance tracking to sources

How GraphRAG Works

1. Document Ingestion and Graph Building

GraphRAG starts by building a Knowledge Graph from your documents:

// Automatic entity and relationship extraction
await trustgraph.ingest({
  source: "documents/research_papers/",

  pipeline: {
    // Extract entities (people, organizations, concepts, etc.)
    entityExtraction: {
      types: ["person", "organization", "concept", "location", "event"],
      model: "ner-large"
    },

    // Extract relationships between entities
    relationshipExtraction: {
      types: ["works_at", "researches", "cites", "collaborates_with"],
      model: "relation-extraction"
    },

    // Resolve entity references
    entityResolution: {
      deduplication: true,
      linkToKnowledgeBase: true
    },

    // Build graph structure
    graphConstruction: {
      createNodes: true,
      createEdges: true,
      inferRelationships: true
    }
  }
});

Result: A structured Knowledge Graph with entities and relationships.

2. Hybrid Retrieval

When a query arrives, GraphRAG combines vector search and graph traversal:

async function hybridRetrieval(query: string) {
  // A. Vector Search - Find semantically similar entities
  const vectorResults = await trustgraph.vectorSearch({
    query,
    topK: 20,
    entityTypes: ["concept", "person", "organization"]
  });

  // B. Graph Traversal - Explore relationships
  const graphContext = await trustgraph.graphTraversal({
    startNodes: vectorResults.map(r => r.entityId),
    maxDepth: 3,
    relationshipTypes: ["related_to", "causes", "influenced_by"],
    includeProperties: true
  });

  // C. Path Finding - Discover reasoning chains
  const paths = await trustgraph.findPaths({
    query,
    startNodes: vectorResults.slice(0, 5).map(r => r.entityId),
    maxPathLength: 4,
    pathRanking: "relevance"
  });

  // D. Fusion - Combine results
  return {
    entities: [...vectorResults, ...graphContext.entities],
    relationships: graphContext.relationships,
    paths: paths,
    scores: computeFusionScores(vectorResults, graphContext, paths)
  };
}

3. Context Construction

Build rich, structured context from hybrid retrieval results:

function constructGraphRAGContext(retrievalResults) {
  return {
    // Primary entities (high relevance)
    primaryEntities: retrievalResults.entities
      .filter(e => e.score > 0.8)
      .map(formatEntity),

    // Supporting entities (lower relevance but connected)
    supportingEntities: retrievalResults.entities
      .filter(e => e.score > 0.5 && e.score <= 0.8)
      .map(formatEntity),

    // Relationships showing connections
    relationships: retrievalResults.relationships
      .map(r => `${r.source} --[${r.type}]--> ${r.target}`),

    // Reasoning paths for multi-hop questions
    reasoningPaths: retrievalResults.paths
      .map(formatPath),

    // Provenance for transparency
    sources: retrievalResults.entities
      .flatMap(e => e.provenance)
      .map(formatSource)
  };
}

4. LLM Generation

Generate responses using the structured context:

const response = await llm.generate({
  systemPrompt: `
You are an AI assistant with access to a Knowledge Graph.
Use the entities, relationships, and reasoning paths provided
to answer questions accurately. Always cite entity IDs.
  `,

  context: constructGraphRAGContext(retrievalResults),

  userQuery: query,

  constraints: {
    // Ground responses in the graph
    mustUseProvidedEntities: true,
    citeEntityIds: true,
    explainReasoning: true
  }
});

Multi-Hop Reasoning

GraphRAG's key strength is multi-hop reasoning - answering questions that require traversing multiple relationships:

Example: "How did AI research influence modern healthcare?"

// Traditional RAG would retrieve disconnected chunks about:
// - "AI research history"
// - "Modern healthcare technology"
// But wouldn't connect them

// GraphRAG finds the path:
const path = await trustgraph.findReasoningPath({
  start: "AI research",
  end: "modern healthcare",
  maxHops: 4
});

// Result:
// [
//   "AI Research",
//   "--[led_to]-->",
//   "Machine Learning",
//   "--[enabled]-->",
//   "Medical Imaging AI",
//   "--[improves]-->",
//   "Diagnostic Accuracy",
//   "--[component_of]-->",
//   "Modern Healthcare"
// ]

// LLM gets structured path showing the connection

Example: Investment Network Analysis

const query = "Which startups are indirectly connected to Venture Capital Firm X?";

const context = await trustgraph.retrieve({
  query,
  strategy: "graph-rag",

  // Start from VC firm
  startEntities: ["venture_capital_firm_x"],

  // Find indirect connections
  graphDepth: 3,
  relationshipTypes: [
    "invested_in",
    "founded_by",
    "partners_with",
    "acquired"
  ],

  // Include path explanations
  includePaths: true
});

// Returns:
// - Direct investments (1 hop)
// - Portfolio company connections (2 hops)
// - Founder's other ventures (3 hops)
// With full relationship paths explaining each connection

GraphRAG Retrieval Strategies

1. Entity-Centric Retrieval

Focus on specific entities and their neighborhoods:

const context = await trustgraph.retrieve({
  query: "Tell me about Company X's technology stack",
  strategy: "entity-centric",

  // Identify main entity
  entityExtraction: true,

  // Get entity neighborhood
  neighborhood: {
    depth: 2,
    relationshipTypes: ["uses", "built_with", "integrates"]
  }
});

2. Path-Based Retrieval

Find reasoning paths between concepts:

const context = await trustgraph.retrieve({
  query: "How does concept A relate to concept B?",
  strategy: "path-based",

  // Extract entities from query
  entityExtraction: true,

  // Find paths connecting them
  pathFinding: {
    maxPaths: 5,
    maxLength: 4,
    rankBy: "relevance"
  }
});

3. Community-Based Retrieval

Retrieve entire communities of related entities:

const context = await trustgraph.retrieve({
  query: "Explain the fintech ecosystem",
  strategy: "community-based",

  // Detect community around concepts
  communityDetection: {
    algorithm: "louvain",
    minCommunitySize: 10,
    includeInterCommunityLinks: true
  }
});

4. Temporal Graph Retrieval

Include time-aware context:

const context = await trustgraph.retrieve({
  query: "How has AI evolved over the last decade?",
  strategy: "temporal",

  // Time-based filtering
  temporal: {
    startDate: "2015-01-01",
    endDate: "2025-12-24",
    includeEvolutionPaths: true,
    sortBy: "chronological"
  }
});

Advantages of GraphRAG

1. Better Context Quality

Traditional RAG:

Context:
"AI is transforming industries..."
"Healthcare technology improves patient outcomes..."
"Machine learning models require data..."

❌ Disconnected statements ❌ No clear relationships ❌ Redundant information

GraphRAG:

Context:
Entities:
- AI Research (concept) → properties: {...}
- Healthcare (industry) → properties: {...}

Relationships:
- AI Research --[enables]--> Medical Imaging
- Medical Imaging --[improves]--> Healthcare

Paths:
- AI Research → enables → Medical Imaging → improves → Healthcare

✅ Structured entities ✅ Explicit relationships ✅ Clear reasoning paths

2. Multi-Hop Reasoning

Traditional RAG struggles with questions requiring multiple reasoning steps:

Question: "How might climate change affect the tech industry?"

Traditional RAG: Retrieves separate chunks about climate change and tech industry, but struggles to connect them.

GraphRAG: Finds paths like:

Climate Change
  → causes → Extreme Weather Events
  → disrupts → Supply Chains
  → impacts → Semiconductor Manufacturing
  → critical_for → Tech Industry

3. Reduced Hallucinations

GraphRAG constrains the LLM to entities and relationships that exist in the graph:

const response = await trustgraph.generate({
  context: graphContext,

  // Validation: Only use graph entities
  grounding: {
    mode: "strict",
    validateEntities: true,
    validateRelationships: true
  }
});

// Post-generation validation
const validation = await trustgraph.validateResponse(
  response,
  graphContext
);

if (!validation.valid) {
  console.warn("Hallucinated facts:", validation.hallucinated);
  // Regenerate or reject response
}

4. Explainable Reasoning

GraphRAG provides transparent reasoning paths:

const response = await trustgraph.generate({
  query: "How are companies A and B connected?",
  context: graphContext,
  explainReasoning: true
});

console.log(response.reasoning);
// {
//   path: ["Company A", "invested_in", "Startup X", "acquired_by", "Company B"],
//   entities: [...],
//   sources: ["document_42.pdf", "database_record_123"]
// }

Implementing GraphRAG with TrustGraph

TrustGraph provides native GraphRAG capabilities:

import { TrustGraph } from "@trustgraph/sdk";

const trustgraph = new TrustGraph({
  endpoint: "http://localhost:8001"
});

// 1. Ingest documents and build graph
await trustgraph.ingest({
  sources: ["documents/"],
  extractEntities: true,
  buildRelationships: true
});

// 2. Query with GraphRAG
const result = await trustgraph.query({
  query: "How does AI impact healthcare?",

  // GraphRAG configuration
  retrievalStrategy: "graph-rag",
  vectorTopK: 20,
  graphDepth: 3,
  includeRelationships: true,
  includePaths: true,

  // Generation configuration
  model: "gpt-4-turbo",
  temperature: 0.3,
  explainReasoning: true
});

console.log(result.answer);
console.log(result.reasoning);
console.log(result.sources);

Best Practices

1. Build Rich Graphs: Extract comprehensive entities and relationships during ingestion
2. Tune Retrieval Parameters: Balance vector search breadth with graph traversal depth
3. Use Relationship Types: Leverage typed relationships for precise context
4. Include Reasoning Paths: Provide multi-hop paths for complex questions
5. Validate Responses: Check that LLM outputs match graph entities
6. Monitor Performance: Track retrieval quality and response accuracy
7. Iterate on Schema: Refine entity and relationship types based on use case

GraphRAG vs Traditional RAG Summary

Related Concepts

• Context Engineering - Optimizing context for LLMs
• Knowledge Graph - Graph structure fundamentals
• Agent Memory - Persistent memory for agents
• Semantic Structures - Structured knowledge representation

Learn More

• TrustGraph Documentation
• Building RAG Applications
• TrustGraph vs LangChain
• TrustGraph GitHub