Algorithm Overview

GraphRAG.js provides multiple graph RAG algorithms, each with different strategies for building and querying knowledge graphs. All algorithms share the same API but use different approaches under the hood.

The Core Concept

All GraphRAG algorithms follow this pattern:

Documents → Graph Construction → Query Processing → Answer Generation

But they differ in:

• What nodes/edges represent (chunks, entities, facts, statements)
• How the graph is built (extraction, similarity, clustering)
• How queries are answered (vector search, traversal, PageRank, communities)

Available Algorithms

Algorithm	Status	Best For	Complexity	Cost
Similarity Graph	✅ Available	Quick prototyping, baselines	Low	Low
LightRAG	🚧 Coming Soon	General purpose, balanced	Medium	Medium
Microsoft GraphRAG	✅ Available	Deep thematic analysis	High	High
Fast GraphRAG	🚧 Coming Soon	Speed, cost efficiency	Medium	Low
AWS GraphRAG	🚧 Coming Soon	Multi-hop reasoning	High	Medium-High

Quick Comparison

Similarity Graph ✅

Available Now

The simplest baseline: chunks as nodes, similarity as edges.

import { similarityGraph } from '@graphrag-js/similarity';

const graph = createGraph({
  provider: similarityGraph({
    similarityThreshold: 0.7,
  }),
});

How it works:

1. Chunk documents
2. Create edges between similar chunks (cosine > threshold)
3. Query: Vector search + BFS expansion

Pros:

• ✅ Simple to understand
• ✅ Fast setup
• ✅ Low cost
• ✅ Good baseline

Cons:

• ❌ No entity extraction
• ❌ Limited relationship understanding
• ❌ No global reasoning

Learn more →

---

LightRAG 🚧

Coming Soon

Dual-level retrieval with entities and relationships embedded separately.

import { lightrag } from '@graphrag-js/lightrag';

const graph = createGraph({
  provider: lightrag({
    entityTypes: ['person', 'organization', 'location'],
    maxGleanings: 1,
  }),
});

How it works:

1. Extract entities and relationships via LLM
2. Create two separate vector indexes (entities + relations)
3. Query modes:
   • Local: Search entity vectors
   • Global: Search relationship vectors
   • Hybrid: Combine both

Pros:

• ✅ Balanced cost/performance
• ✅ Good for general use cases
• ✅ Fast incremental updates
• ✅ Multiple query modes

Cons:

• ❌ No community detection
• ❌ No hierarchical summaries

Status: 🚧 Implementation in progress

---

Microsoft GraphRAG ✅

Available Now

Hierarchical community detection with summarized reports. Ported from nano-graphrag.

import { microsoftGraph } from '@graphrag-js/microsoft';

const graph = createGraph({
  provider: microsoftGraph({
    entityTypes: ['organization', 'person', 'geo', 'event'],
    entityExtractMaxGleaning: 1,
    maxGraphClusterSize: 10,
  }),
});

How it works:

1. Extract entities and relationships via LLM (with gleaning)
2. Run Leiden clustering to detect communities
3. Generate hierarchical community reports via LLM
4. Query modes:
   • Local: Entity neighborhoods + community context
   • Global: Map-reduce over community reports
   • Naive: Pure vector search baseline

Pros:

• ✅ Best for thematic analysis
• ✅ Global reasoning capabilities
• ✅ Hierarchical understanding
• ✅ Well-researched (Microsoft)

Cons:

• ❌ Expensive (many LLM calls for reports)
• ❌ Slow indexing
• ❌ Complex setup

Status: ✅ Complete — 29 tests passing

---

Fast GraphRAG 🚧

Coming Soon

PageRank-based retrieval without expensive community detection.

import { fastGraph } from '@graphrag-js/fast';

const graph = createGraph({
  provider: fastGraph({
    pagerank: {
      damping: 0.85,
      maxIterations: 100,
    },
  }),
});

How it works:

1. Extract entities and relationships via LLM
2. No community detection (saves cost!)
3. Query: Personalized PageRank from seed entities
4. Token-budget truncation for context

Pros:

• ✅ Fast and cheap
• ✅ No community overhead
• ✅ Good incremental updates
• ✅ PageRank naturally surfaces importance

Cons:

• ❌ No global summaries
• ❌ Relies on good entity extraction
• ❌ May miss disconnected clusters

Status: 🚧 Planned for Phase 6

---

AWS GraphRAG 🚧

Coming Soon

Fact-centric hierarchical graph: chunks → statements → facts → entities.

import { awsGraph } from '@graphrag-js/aws';

const graph = createGraph({
  provider: awsGraph({
    semantic: {
      beamWidth: 5,
      maxPaths: 10,
    },
  }),
});

How it works:

1. Extract statements (propositions) from chunks
2. Extract facts (subject/relation/object triples) from statements
3. Extract entities from facts
4. Build hierarchical graph
5. Query modes:
   • Traversal: Top-down (chunk vectors) + bottom-up (entity keywords)
   • Semantic: Beam search through fact chains

Pros:

• ✅ Best for multi-hop reasoning
• ✅ Explicit fact representation
• ✅ Cross-document connections
• ✅ Statement-level granularity

Cons:

• ❌ Complex extraction pipeline
• ❌ Many LLM calls
• ❌ Higher latency

Status: 🚧 Planned for Phase 7

---

Choosing an Algorithm

By Use Case

Prototyping / Baseline → Use Similarity Graph ✅

General Purpose RAG → Use LightRAG 🚧 (when available)

Thematic Analysis / Research → Use Microsoft GraphRAG ✅

Fast / Cost-Effective → Use Fast GraphRAG 🚧 (when available)

Multi-Hop Reasoning → Use AWS GraphRAG 🚧 (when available)

By Dataset Size

< 10K documents → Any algorithm works

10K - 100K documents → Similarity Graph ✅ or Fast GraphRAG 🚧

100K - 1M documents → Fast GraphRAG 🚧 or LightRAG 🚧

> 1M documents → Fast GraphRAG 🚧 with distributed storage

By Query Type

Factoid questions ("What is X?") → Similarity Graph ✅ or LightRAG 🚧

Relationship queries ("How are X and Y related?") → LightRAG 🚧 or Fast GraphRAG 🚧

Thematic questions ("What are the main themes?") → Microsoft GraphRAG ✅

Multi-hop questions ("If X, then Y, then what?") → AWS GraphRAG 🚧

By Budget

Low cost → Similarity Graph ✅ (no LLM extraction) or Fast GraphRAG 🚧

Medium cost → LightRAG 🚧 or AWS GraphRAG 🚧

High cost → Microsoft GraphRAG ✅ (many LLM calls for community reports)

Implementation Roadmap

Phase	Algorithm	Status	ETA
3	Similarity Graph	✅ Complete	Available Now
4	Microsoft GraphRAG	✅ Complete	Available Now
5	LightRAG (default)	⬜ Planned	TBD
6	Fast GraphRAG	⬜ Planned	TBD
7	AWS GraphRAG	⬜ Planned	TBD

See ROADMAP.md for detailed implementation status.

Algorithm Details

Graph Structure Comparison

Algorithm	Nodes	Edges	Indexes
Similarity	Chunks	Similarity	Chunk vectors
LightRAG	Entities, Chunks	Relations, Contains	Entity vectors, Relation vectors, Chunk vectors
Microsoft	Entities, Communities	Relations, MemberOf	Entity vectors, Chunk vectors
Fast	Entities	Relations	Entity vectors (HNSW)
AWS	Chunks, Statements, Facts, Entities	Contains, Extracts, References	Chunk vectors, Statement vectors

Query Processing Comparison

Algorithm	Query Processing
Similarity	Embed query → Vector search → BFS expansion
LightRAG	Embed query → Dual vector search (entities + relations) → Expand → LLM
Microsoft	Embed query → Extract entities → Search + Community reports → LLM
Fast	Embed query → Entity search → Personalized PageRank → LLM
AWS	Embed query → Traversal (top-down + bottom-up) or Beam search → LLM

Performance Characteristics

Indexing Speed

Algorithm	Speed	Cost
Similarity	⚡⚡⚡ Fastest	$ Cheapest
Fast	⚡⚡ Fast	$$ Low
LightRAG	⚡ Medium	$$$ Medium
AWS	🐌 Slow	$$$$ High
Microsoft	🐌🐌 Slowest	$$$$$ Highest

Query Speed

Algorithm	Speed	Quality
Similarity	⚡⚡⚡ Fastest	⭐⭐ Basic
Fast	⚡⚡ Fast	⭐⭐⭐ Good
LightRAG	⚡ Medium	⭐⭐⭐⭐ Very Good
AWS	🐌 Slow	⭐⭐⭐⭐ Very Good
Microsoft	🐌 Slow	⭐⭐⭐⭐⭐ Excellent

Next Steps

• Similarity Graph - Available now ✅
• LightRAG - Coming soon 🚧
• Microsoft GraphRAG - Available now ✅
• Fast GraphRAG - Coming soon 🚧
• AWS GraphRAG - Coming soon 🚧

External Resources

• LightRAG Paper
• Microsoft GraphRAG
• Fast GraphRAG
• AWS GraphRAG Toolkit