GraphRAG Feature & Pricing Matrix

Matrix 01

What each project is actually for

Projects that share the “GraphRAG” label solve substantially different problems. This is the most important matrix in the report.

Shortlist positioning, best fit and boundary
Shortlist	Designed to do	Best fit	Not primarily
nano-graphrag	Small implementation of Microsoft-style GraphRAG	Learning, source study and controlled experiments	A complete multi-tenant production platform
Microsoft GraphRAG	Batch extraction, graph communities and hierarchical reports over documents	Whole-corpus themes plus entity-focused questions	A supported managed product or native graph database
LightRAG	Lighter graph/vector RAG server with several retrieval modes and storage adapters	General self-hosted GraphRAG, incremental documents and multimodal files	A formal ontology or symbolic-rule engine
HippoRAG	Long-term memory retrieval using a KG and Personalized PageRank	Associative, multi-hop and continual-learning research	A turnkey enterprise knowledge platform
Graphiti	Bi-temporal context graph that evolves episode by episode	Agent memory, changing facts and historical questions	Static whole-corpus community summarization
KAG + OpenSPG	Schema-constrained domain knowledge plus logical-form-guided reasoning	Professional domains with rules, terminology and factual multi-hop questions	A minimal plug-and-play RAG library
Neo4j GraphRAG + Graph Builder	Practical KG construction and multiple retrieval patterns on Neo4j	Property-graph applications, Cypher and managed graph infrastructure	Database-neutral GraphRAG
TrustGraph	Full context-engineering and agent backend using ontology, graph/vector retrieval and provenance	Sovereign, explainable, multi-tenant context infrastructure	A small embeddable library

Matrix 02

Capability comparison

✓ explicit core capability ◐ limited, indirect or secondary — not explicit in reviewed README

Capabilities explicitly described by current project documentation
Capability	nano	Microsoft	LightRAG	HippoRAG	Graphiti	KAG / OpenSPG	Neo4j	TrustGraph
Automatic entity/relation extraction	✓	✓	✓	✓	✓	✓	✓	✓
Formal schema/ontology	—	◐	◐	—	✓	✓	✓	✓
Vector + graph retrieval	✓	✓	✓	✓	✓	✓	✓	✓
Lexical/keyword retrieval	—	—	◐	◐	✓ BM25	✓ exact/text	✓ full-text	◐
Whole-corpus global summary	✓ top communities	✓ map-reduce reports	✓ global/mix	—	—	—	◐ global-vector	—
Incremental ingestion	✓ report rebuild	◐ batch-biased	✓	✓ continual	✓ real-time episodes	✓ iterative	◐ pipeline-driven	✓ flows
Selective deletion/retraction	◐	◐	✓ affected-KG rebuild	◐	✓ temporal invalidation	◐	◐ app logic	◐ version/flow
Explicit temporal validity/history	—	—	—	—	✓ bi-temporal	—	—	◐ freshness/version
Symbolic rules/logical reasoning	—	—	—	—	—	✓ KGDSL/reasoner	◐ Cypher traversal	◐ ontology policy
Multi-hop/associative retrieval	◐	◐ DRIFT/local	◐ relationship chains	✓ PPR	✓ graph search	✓	✓ graph/Cypher	✓ traceable paths
Multimodal document reasoning	—	—	✓ VLM + parsers	—	—	◐ processing	◐ varied sources	◐ media stack
Built-in web UI	—	—	✓	—	— core	◐	✓ Graph Builder	✓
REST API / MCP	Library	CLI/Python	✓ REST	Library	✓ REST/MCP	SDK/server	Python + app API	✓ API/MCP
Built-in multi-tenancy/isolation	—	—	◐ workspaces/auth	—	◐ groups	◐ project/domain	App/database dependent	✓ workspace/collection/flow

Whole-corpus specialist

Microsoft global search uses community reports in a map-reduce query. It is distinctive—and resource intensive.

Temporal specialist

Graphiti uniquely models fact-validity windows and preserves superseded facts as history.

Semantic-control specialist

KAG/OpenSPG provides the strongest schema, normalization and rule model, with the highest up-front modeling work.

Full-stack specialist

TrustGraph supplies orchestration, storage, ingestion, retrieval, MCP and UI—along with the largest operations surface.

Matrix 03

Architecture, storage and deployment

Storage, model integration, deployment shape and principal operational concern
Shortlist	Storage	Model choices	Deployment	Main operational concern
nano	Disk KV, nano-vectordb, NetworkX; Neo4j/HNSW/Milvus/FAISS options	OpenAI, Bedrock; examples for Ollama, DeepSeek and sentence-transformers	Python package, single host by default	Incremental inserts avoid duplicate chunks but recompute communities and reports
Microsoft	Parquet tables plus configured vector store; no graph DB required	Configurable model providers and LiteLLM	CLI or Python index/query pipelines	Many standard-index LLM passes; version/config changes can require migration or re-indexing
LightRAG	KV, vector, graph and document-status roles; unified or specialized production backends	Separate extraction, query, keyword and VLM roles; hosted or local providers	REST server/Web UI via Docker, or Python core	Storage tuning; embedding-dimension changes require vector-state rebuilding
HippoRAG	Local output/index artifacts in packaged workflow	OpenAI-compatible, Bedrock and local vLLM	Python research/library workflow	GPU/model capacity and independent validation of research results
Graphiti	Neo4j, FalkorDB or Neptune; Neptune also uses OpenSearch Serverless	OpenAI default; Anthropic, Gemini, Groq and compatible/local servers	Python core, FastAPI and MCP	Structured-output reliability, graph operations and ongoing extraction/deduplication
KAG/OpenSPG	OpenSPG engine with pluggable graph and algorithm services	LLMs plus NLP/deep-learning operators	Engine, builder, reasoner, SDK/server and domain solution	Schema governance, entity alignment, custom operators and integration complexity
Neo4j	Neo4j 5.x + APOC; vectors in Neo4j or external Weaviate/Pinecone/Qdrant	Ollama, OpenAI/Azure, Google, Cohere, Anthropic, Mistral and Bedrock	Python package, Graph Builder UI/backend, self-managed or Aura	Neo4j capacity and production caution around experimental KG-builder APIs
TrustGraph	Cassandra, Qdrant, Garage object storage and Pulsar or RabbitMQ	Hosted providers or local vLLM, Ollama, TGI, LM Studio and Llamafiles	Multi-container Docker/Podman or Kubernetes	Largest platform-operations footprint, though fewer mandatory external services

Matrix 04

Production reference architectures

Stripe and Cerebras demonstrate production patterns, but neither publishes a reusable end-to-end knowledge-base implementation. They are references, not additional open-source shortlist candidates.

Stripe and Cerebras compared as production reference architectures
Reference	Scope and interface	Retrieval and storage	Graph / Tree-sitter	Security	Openness and price	Atlas lesson
Stripe AI knowledge base	Hosted MCP for searching Stripe documentation and support material, alongside narrowly scoped API discovery, planning, read and write tools	Backend retrieval, ranking and storage are not publicly disclosed	No public evidence of a knowledge graph or Tree-sitter	OAuth or restricted API keys, account scope, constrained tools and confirmation for consequential actions	Client and agent tooling is MIT; hosted KB backend is proprietary. No separate public KB/MCP list price found.	Expose knowledge and actions as safe, task-oriented tools—not storage or a generally privileged agent
Cerebras Knowledge	Internal enterprise knowledge across Slack, code, documents and operational systems, delivered through web, automation and simple MCP retrieval primitives	PostgreSQL text, embeddings and metadata; full-text/vector retrieval with source signals, freshness, rank fusion, reranking and context restoration	Not GraphRAG. Cerebras names CocoIndex; current CocoIndex code indexing uses Tree-sitter, making this an indirect connection rather than proof of Cerebras's exact deployed splitter version.	Authentication, authorization, auditing, analytics and project/source scoping; exact row-level ACL mechanics are not public	Internal system with no public price; individual infrastructure components are independently available	Build an ACL-aware hybrid baseline first; add graphs only for measured multi-hop, temporal or ontology gains

Stripe: control-plane reference

Narrow MCP tools, scoped credentials and human confirmation establish a strong boundary around knowledge and actions.

Cerebras: retrieval reference

Incremental ingestion, source-specific processing, hybrid ranking and evidence packaging create a strong non-graph baseline.

Tree-sitter's role

Tree-sitter preserves code structure before embedding or graph extraction; it is an ingestion technique, not a graph engine.

Matrix 05

Pricing and cost tendency

Relative cost is an architectural judgment, not an equal-corpus price benchmark. A fair comparison fixes corpus, model quality, schema, update rate, query mix, latency SLO and evaluation target.

Repository cost, managed options, public list price and self-hosted cost drivers
Shortlist	Repository	Managed option	Public list price	Self-hosted cost drivers	Cost tendency
nano	MIT · $0	None published	Not applicable	Extraction/summary models, embeddings, optional graph/vector DB	Low lab infrastructure; medium–high indexing tokens
Microsoft	MIT · $0	Repository is not an officially supported offering	No GraphRAG product price	LLM extraction and summaries, community reports, query model, embeddings, vector storage	High standard indexing/global search; FastGraphRAG is cheaper
LightRAG	MIT · $0	None published	Not applicable	Four storage roles, four model roles, embeddings, reranker and parsers	Medium with local models; rises with multimodal/production backends
HippoRAG	MIT · $0	None published	Not applicable	LLM/embedding APIs or GPU-hosted vLLM, index storage	Low–medium offline per README; verify independently
Graphiti	Apache-2.0 · $0 self-hosted	Zep	Free: 10k credits/month. Flex: $125/month or $1,250/year. Flex Plus: $375/month or $3,750/year. Enterprise: negotiated.	Models, embeddings/reranker, graph DB and continuous episode processing	Medium–high self-hosted; managed scales with episode bytes
KAG/OpenSPG	Apache-2.0 · $0	No public managed price found	Not published	Graph engine, compute, LLMs, NLP operators, modeling team and operations	High engineering/fixed cost
Neo4j	GraphRAG/Builder · $0	AuraDB	Free: $0. Professional: $65/GB/month; 1 GB example $65.70/month. Business Critical: $146/GB/month, 2 GB minimum; 2 GB example $292/month.	Database capacity, extraction/generation, embeddings, app compute, optional vector DB	Low prototype cost; predictable DB + variable models
TrustGraph	Apache-2.0 · $0	Optional support; no fixed public support price	Vendor illustration for 1M docs/10M queries: $5k–$9k/month ($3k–$5k infrastructure + $2k–$4k LLM). Not a quote.	Multi-container storage/messaging, compute/GPU, models, OCR and operations	High fixed platform cost; improves economically at scale

Why Microsoft-style indexing is usually expensive

Standard GraphRAG uses models for entity and relationship extraction, entity and relationship summaries, optional claims and community reports. FastGraphRAG replaces much extraction with NLP while retaining model-generated community reports. Microsoft estimates graph extraction at roughly 75% of standard indexing cost.

monthly total = ingestion model calls
              + embedding and reranking calls
              + query-generation calls
              + graph, vector and object storage
              + compute or GPU
              + observability, backups and network
              + engineering and on-call operations

Matrix 06

Select by requirement, not popularity

First and second project to evaluate for each architectural priority
Priority	Evaluate first	Compare against
Learn internals	nano	Microsoft GraphRAG
Whole-corpus themes	Microsoft GraphRAG	LightRAG global/mix
General self-hosted document GraphRAG	LightRAG	Neo4j ecosystem
Multi-hop retrieval research	HippoRAG	KAG
Changing agent memory	Graphiti	TrustGraph
Formal ontology and deterministic rules	KAG/OpenSPG	TrustGraph
Managed property graph	Neo4j/Aura	Graphiti/Zep for agent memory
Sovereign full context platform	TrustGraph	LightRAG + selected infrastructure
Lowest-cost learning prototype	nano + local models	Graph Builder + AuraDB Free

Decision method

Recommended four-hypothesis proof of concept

Baseline: lexical + vector RAG without a graph.
Document GraphRAG: LightRAG and Microsoft on whole-corpus and entity questions.
Temporal memory: Graphiti on corrections, superseded facts and historical questions.
Controlled domain graph: Neo4j or KAG/OpenSPG on schema-constrained multi-hop questions.

Hold the generator model constant where possible. Measure retrieval precision/recall, multi-hop accuracy, faithfulness, provenance correctness, ACL leakage, indexing and query cost, update/deletion latency, P50/P95 latency, failure rate and engineer-days to production.

Evidence

Official sources reviewed