VeritasGraph
A zero-trust, on-prem GraphRAG MCP server that answers questions over a governed knowledge graph and connected databases with citations, receipts and abstention.
Ask grounded questions (
query): multi-hop graph answers with[doc#chunk]citations, agroundedflag, reasoning path and ananswer_idreceipt; abstains when evidence is missing.Pre-check answerability (
check_answerable): see matched entities/glossary terms and coverage before spending an LLM call.Explore the graph without an LLM:
search_entitiesfor a relevant subgraph,get_entityfor neighbours/source chunks,get_graphfor the full graph and stats.Govern vocabulary (
get_ontology,search_terms,get_term,propose_term): inspect entity types, predicates and glossary terms by status, and propose new terms for admin certification.Audit answers (
get_answer_receipt): replay evidence ids, grounding, graph version, staleness and feedback.Track curation (
compile_status): last ontology compile run and open suggestions.Query structured data:
structured_searchthe catalog,structured_get_term,structured_list_measures, andstructured_askfor a validated read-only, row-capped SQL answer with a receipt.Build/extend the graph (write tier):
ingest_documentto extract entities from text,import_graphto bring in Graphify/Understand-Anything/AI-Atlas/generic graphs with provenance and merge strategies.Choose modes: exploratory vs governed answering.
Provides an MCP bridge integration for Unity, allowing AI agents to interact with Unity applications or data through the VeritasGraph server.
VeritasGraph โ The Governed, On-Prem GraphRAG & Agent Framework
A knowledge graph your agents can trust: every answer cites its sources, the vocabulary is governed by a certified ontology, and the system says "I don't know" instead of guessing. Runs 100% locally.
๐ฏ Traditional RAG guesses based on similarity. VeritasGraph reasons based on structure โ and refuses to answer when the evidence isn't there.
๐ Live site ยท ๐ฎ Try the Studio live ยท โญ Star ยท ๐ด Fork ยท ๐ฌ Discuss ยท ๐ Report a bug
โจ What's new
Area | What you get |
๐งญ Ontology & business glossary | Entity types, predicates (with domain/range) and glossary terms move through |
โ๏ธ Ontology compiler |
|
๐ก๏ธ Governed answers |
|
๐งพ Answer receipts | Every answer gets an |
๐ซ Strict citations & abstention | Each response carries |
๐พ Shared SQLite store | Studio, the MCP server and the CLI share one transactional store. Legacy JSON graphs are migrated on first start. |
๐ Governance | A SHA-256 hash-chained audit log with a verify endpoint, snapshots and restore (the graph is snapshotted automatically before it is cleared), and entity merge. |
๐ต๏ธ PII policy | Choose |
๐ Auth & roles | Bearer tokens with |
๐ MCP modes |
|
๐๏ธ Structured data layer | Connect read-only to Postgres, MySQL, SQLite, DuckDB, ClickHouse, Trino, Hive, Snowflake or Databricks. Govern a semantic layer and ask questions answered by SQL. |
๐งฐ |
|
๐ณ Docker |
|
Related MCP server: GraphRAG MCP
๐ Table of contents
Core concepts โ attribution ยท ontology ยท compiler ยท governed mode ยท governance ยท PII ยท structured data
๐ Quick start
Option A โ Local (Python + Ollama)
git clone https://github.com/bibinprathap/VeritasGraph.git && cd VeritasGraph
pip install -e ".[studio]" # Studio + the `veritasgraph` CLI
ollama serve & ollama pull qwen3:latest # any local chat model
export STUDIO_API_TOKENS="$(openssl rand -hex 24):admin" # auth is on by default
echo "${STUDIO_API_TOKENS%%:*}" # the token to paste into the UI
veritasgraph serve # http://127.0.0.1:8200/studio ยท API docs at /docsStudio asks for the token the first time you open it and keeps it for the browser session. To run a local demo without auth, set STUDIO_AUTH=off (Studio logs a warning on startup); never do this on a shared or public host.
Option B โ Docker Compose
STUDIO_API_TOKENS="$(openssl rand -hex 24):admin" docker compose up
docker compose exec ollama ollama pull qwen3:latestStudio is published on 127.0.0.1:8200 only.
Option C โ MCP server for your IDE agent
pip install -e .
VERITASGRAPH_MCP_MODE=read python -m veritasgraph_mcp # or: veritasgraph mcpSee MCP server for IDE registration.
One-command end-to-end demo
This builds a graph and drives a fully wired agent through graph reasoning, memory recall, PII redaction and a guardrail block:
python3 demos/agent-studio/sample_pipeline.py --model qwen3:latest๐๏ธ Architecture
flowchart LR
subgraph Ingest
D[Documents / graph.json imports] --> PII{PII policy}
PII --> X["LLM extraction<br/>(steered by certified ontology)"]
end
subgraph Store["Shared SQLite store"]
G[(Entities ยท relations ยท chunks)]
O[(Ontology & glossary)]
A[(Audit chain ยท snapshots ยท receipts)]
end
X --> G
G <--> C["Ontology compiler<br/>normalize ยท merge ยท suggest ยท validate"]
C <--> O
subgraph Query
Q[Question] --> ANS{"Answerability<br/>(governed mode)"}
ANS -->|covered| R["Entity match + multi-hop traversal"]
ANS -->|not covered| AB[Abstain]
R --> L[Local LLM]
L --> V{"Citation check<br/>(doc#chunk)"}
V -->|grounded| OUT["Answer + citations + answer_id"]
V -->|unknown citations| AB
end
G --> R
O --> ANS
OUT --> A
subgraph Surfaces
S[Studio UI & REST API]
M[MCP server]
CLI[veritasgraph CLI]
end
Surfaces --> Ingest
Surfaces --> QueryStudio, MCP and the CLI are thin layers over the same engine and store. A graph built in Studio can be queried from your IDE, and a compile run from the CLI shows up in the Studio Ontology tab. A shared job lock ensures only one compiler runs at a time.
๐ง Core concepts
Attribution, citations and abstention
Attribution is a data model, not a prompt. Provenance is stored at write time: every entity and relation keeps the chunk it came from (
doc_xxx#n, orimp_xxx#nfor imported graphs). This prevents hallucinated citations at read time.Deterministic retrieval. Graph traversal is reproducible, which separates the factual evidence trace from stochastic LLM generation.
Strict citation check. Citations in the answer are compared with the sources that were actually retrieved. Mismatches are reported in
unknown_citationsand setgrounded: false.Explicit abstention. If no entity matches the question, or governed mode can't ground the answer, the response sets
abstained: trueinstead of guessing.
Ontology & business glossary
The ontology is the governed vocabulary of the graph:
Entity types, e.g.
Drug,Enzyme,Supplier.Predicates, e.g.
inhibits, with optional domain/range constraints.Glossary terms: business definitions with synonyms, linked to entities.
stateDiagram-v2
[*] --> proposed: propose (editor, MCP write, compile suggestion)
proposed --> certified: certify (admin)
certified --> deprecated: deprecate (admin)
proposed --> deprecated: deprecate (admin)Once vocabulary is certified, it changes how the system behaves:
Extraction limits entity types to the certified list and maps synonyms to the certified predicate.
Compile uses the same mapping rules to clean up the existing graph.
Governed mode answers only when certified terms cover the question.
Manage it in the Studio Ontology tab, through /ontology in the REST API, or with the MCP tools get_ontology, search_terms, get_term and propose_term.
The ontology compiler
veritasgraph compile, POST /graphrag/compile, or a timer set with VERITASGRAPH_COMPILE_INTERVAL runs these stages:
Stage | What it does |
| Maps raw entity types to certified types and synonyms. |
| Maps raw relation labels to certified predicates. |
| Finds likely duplicate entities. It only suggests merges and never merges on its own. |
| Proposes glossary terms for well-connected entities ( |
| Flags relations that break a predicate's domain/range. |
| Flags entities with no relations. |
Only unambiguous mappings to certified vocabulary change the graph. Everything else is a suggestion that you accept or reject in Studio or via /graphrag/suggestions. Rejected suggestions are fingerprinted and don't come back. Every run is recorded (/graphrag/compile/runs) and audited.
Governed mode, answerability and receipts
|
| |
Needs certified glossary coverage | No | Yes; abstains with a reason if not covered |
Answers with unmatched citations | Returned, flagged | Withheld |
Answer receipt ( | โ | โ |
POST /graphrag/answerable(MCP:check_answerable) tells an agent whether a question can be answered before it spends a model call.GET /graphrag/answers/{id}returns the receipt: question, mode, answer, citations, grounding and feedback.POST /graphrag/answers/{id}/feedbackrecords a rating for the answer so it can be reviewed later. Any viewer can rate an answer.
Governance: audit, snapshots, merge
Hash-chained audit log. Every write (ingest, import, compile, certify, merge, clear, restore) appends a SHA-256-chained event.
GET /graphrag/audit/verifyrecomputes the chain and reports the event where it breaks (broken_at).Snapshots. Create, list and restore snapshots (
/graphrag/snapshots). Clearing the graph always takes a snapshot first. Retention is set withVERITASGRAPH_SNAPSHOT_KEEP(default 20).Entity merge.
POST /graphrag/entities/mergefolds duplicates together and keeps their relations and provenance.Import / export. Bring in
graph.jsonfrom Graphify, Understand-Anything, AI-Atlas or a generic node/edge file. Merge strategies arepreserve_curated,skip_existingandoverwrite, with a--dry-runpreview.
PII policy
VERITASGRAPH_PII_POLICY controls what happens when ingested text contains email addresses, SSNs, credit card numbers (Luhn-validated), phone numbers or IP addresses:
Policy | Behaviour |
| No detection. |
| Store the text and tag the chunks that contain PII. |
| Redact before the LLM ever sees the text. |
| Refuse the document. |
PII in chunks is redacted on read for callers below VERITASGRAPH_PII_REVEAL_ROLE (default editor).
Structured data layer
Beyond documents, VeritasGraph can govern databases. Install with pip install -e ".[structured]" and set VG_STRUCTURED_DSN to a Postgres + pgvector store.
Connect a source read-only: PostgreSQL, MySQL/MariaDB, SQLite, DuckDB, ClickHouse, Trino, Hive (
[structured-hive]), Snowflake or Databricks ([structured-saas]). Credentials are encrypted withVG_SECRET_KEY.Sync the schema, then compile a semantic layer of datasets, fields, relationships, glossary terms and measures. These follow the same
proposed โ certifiedworkflow.Ask in natural language. The answer is generated SQL over certified objects, run under a statement timeout and a row cap, and returned with a receipt.
Source DSNs are guarded:
A network allowlist (
VG_STRUCTURED_ALLOWED_NETWORKS) controls which hosts can be reached.A file root (
VG_STRUCTURED_FILE_ROOT) limits SQLite and DuckDB to approved paths.Dangerous driver options are refused.
See .env.structured.example for every setting, and the structured CLI / /structured API.
๐ฅ๏ธ VeritasGraph Studio
Studio is a local Agent Build Workspace (FastAPI + a single-page UI at /studio). You build a knowledge graph from your own documents, govern its vocabulary, and wire it into agents alongside tools, memory, data logging, guardrails and headroom-style context budgeting. You then chat with those agents and watch every stage of the orchestration pipeline.
๐ฎ Try the Studio live โ a stable URL that always redirects to the currently running Studio tunnel.

Section | What you can do |
Knowledge Graph | Ingest text or import |
Ontology | Propose and certify types, predicates and glossary terms, run compile, and accept or reject suggestions. |
Agents | Create agents with a local model, instructions, capability toggles (Knowledge Graph, Tools, Memory, Guardrails, Data log) and a headroom token budget. |
Tools / Knowledge / Guardrails / Memory / Data | Manage inventories: real HTTP tools (method, auth header, custom headers), MCP bridge connectors, PII and policy guardrails. |
Playground | Chat with an agent live and inspect the per-turn pipeline trace, reasoning path and citations. |
Evaluation / Fine-tune | Run evaluation suites with pass-rate trends, and queue and monitor fine-tune jobs. |
Orchestration pipeline (per turn): Guardrails โ Memory โ Knowledge Graph โ Headroom budget โ Tools โ Data log, with every step visible in the trace.
For full API details and curl recipes, see studio_api/README.md. For a guided enterprise scenario, see the Northwind Bank compliance playbook.
๐ Security model
Auth is on by default. Studio refuses to start unless STUDIO_API_TOKENS is set or STUDIO_AUTH=off is set explicitly.
export STUDIO_API_TOKENS="tokenA:admin,tokenB:editor,tokenC:viewer" # each token โฅ 24 charsRole | Can |
| Read everything, ask questions (graph query, answerability, playground chat, structured search and ask), and leave answer feedback. |
| Everything a viewer can, plus ingest and import, edit Studio inventories, propose ontology entries, run compile, and accept or reject suggestions. |
| Everything, including clearing the graph, restoring snapshots, certifying or deprecating vocabulary, and reindexing structured data. |
More controls:
Public routes: only
/health,/readyand/studio; the UI shell holds no data.SSRF protection: HTTP tools can't reach private, loopback or link-local addresses unless the address is listed in
STUDIO_TOOL_ALLOWED_NETWORKS.CORS: set allowed origins with
STUDIO_CORS_ORIGINS.MCP tiers:
VERITASGRAPH_MCP_MODElimits which tools an MCP client can see. In the Studio MCP bridge, tools are also limited by the caller's role.PII: see PII policy.
๐ MCP server
VeritasGraph ships a Model Context Protocol server: a zero-trust, air-gapped enterprise GraphRAG server for MCP. Claude Desktop, Cursor, VS Code, Windsurf, Cline and Continue connect over JSON-RPC 2.0 stdio with zero external data egress.
VERITASGRAPH_MCP_MODE=read python -m veritasgraph_mcpMode | Tools exposed (all prefixed |
|
|
|
|
|
|
Resources: veritasgraph://graph, veritasgraph://stats, veritasgraph://ontology. Tools that aren't in the active mode are reported as unknown tools.
See veritasgraph_mcp/README.md for Claude Desktop, Cursor and VS Code registration snippets.
Real-world deployment: the VeritasGraph MCP server runs on Azure Functions with Azure AI Foundry. It delivers GraphRAG-powered clinical decision support with verifiable citations and a compliance-ready architecture.
The challenge: 90% of Azure AI demos work. Most never ship. The gap isn't the model; it's architecture, security, state management and compliance.
The solution: VeritasGraph is deployed as a remote MCP server that Azure AI Foundry agents call to answer clinical questions with:
โ Multi-hop GraphRAG reasoning: answers are assembled from separate graph edges.
โ Verifiable citations: every claim traces to
[doc#chunk]sources.โ Production-grade architecture: externalized state, identity at the boundary, observability.
โ Compliance-ready: region-pinned, PHI-aware guardrails, semantic-layer RBAC.
Foundry Agent / MCP client
โ Identity (Entra ID + function key)
โ Azure Functions (Flex Consumption, 4 mcpToolTrigger tools)
โ veritasgraph-mcp + graphrag_engine
โ Azure OpenAI (extraction + reasoning)
โ Knowledge Graph
โ Durable Azure Files mount (externalized state)
โ Storage + App Insights (observability)Key production lessons:
State externalization. Flex Consumption wiped in-memory graphs; this was fixed with a mounted Azure Files share.
Identity at the boundary. Carry the Entra identity, and enforce Power BI RLS and Dataverse roles on behalf of the user.
Self-correcting agents. Feed errors and the schema back, and retry up to 3ร (e.g. for DAX generation).
Compliance by design. Foundry guardrails block PHI-leaking requests before they reach the model.
Observability layers. Application Insights, Foundry Traces, Evaluations and Alerts.
{
"question": "Should we adjust warfarin for patient 4471 on amiodarone?",
"answer": "Reduce the warfarin dose because amiodarone inhibits CYP2C9...",
"citations": ["doc_warfarin_note#0", "doc_warfarin_note#1"],
"reasoning_path": ["Amiodarone โ CYP2C9", "CYP2C9 โ Warfarin", "Warfarin โ Bleeding Risk"]
}
๐ From Proof of Concept to Production: Azure AI That Actually Ships
๐ป Azure AI Foundry + VeritasGraph implementation repository
๐ก Key insight: the gap between proof of concept and production is architecture, not the model. Ground it, externalize state, secure it, observe it, make it resilient and keep it compliant.
๐งฐ CLI
pip install -e ".[studio]" installs the veritasgraph command:
veritasgraph serve --host 127.0.0.1 --port 8200 # run Studio
veritasgraph mcp # run the MCP server (stdio)
veritasgraph migrate graph.json veritasgraph.db # legacy JSON โ SQLite
veritasgraph compile --actor ci # run the ontology compiler
veritasgraph export -o graph.json # export the graph
veritasgraph import graph.json --format auto --merge-strategy preserve_curated --dry-run
# Structured data layer (needs the [structured] extra + VG_STRUCTURED_DSN)
veritasgraph structured migrate # create/upgrade the semantic store
veritasgraph structured status
veritasgraph structured sync <connection> # introspect a source schema
veritasgraph structured compile <connection> # build semantic-layer proposals
veritasgraph structured reindex
veritasgraph structured ask "total revenue by region last quarter" --mode governedThe import command accepts --format values auto, graphify, understand_anything, ai_atlas and generic, and --source-type values curated, extracted and inferred.
โ๏ธ Configuration
Variable | Default | Purpose |
| โ |
|
| on | Set |
| โ | Allowed browser origins. |
| โ | CIDRs that HTTP tools may reach despite the SSRF block. |
|
| Data directory. |
|
| SQLite store shared by Studio, MCP and the CLI. A legacy |
|
| Local model server. |
|
| MCP tool tier: |
|
|
|
|
| Lowest role that sees unredacted PII. |
|
| Seconds between background compile runs ( |
|
| Minimum connections before a term is suggested. |
|
| Snapshots retained. |
| โ | Ingest chunk size. |
| โ | Structured data layer; see |
The full reference is in studio_api/README.md.
๐ API overview
The interactive OpenAPI docs are served at /docs. Main route groups:
Prefix | Highlights |
|
|
| List the ontology; |
|
|
| Agent chat with full pipeline trace |
| Studio inventories (CRUD), |
| Evaluation runs, fine-tune jobs, KPIs, draft/deploy, local models |
| MCP bridge: tools, resources, JSON-RPC ( |
TOKEN="${STUDIO_API_TOKENS%%:*}"
curl -s -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" \
-d '{"question":"Which drugs inhibit CYP2C9?","mode":"governed"}' \
http://127.0.0.1:8200/graphrag/query๐ณ Deployment
Target | How |
Docker Compose (Studio + Ollama) |
|
MCP container |
|
On-prem stack |
|
Public demo link |
|
Azure (serverless MCP) | See the Azure production use case. |
Method | Duration | Local Ollama | Setup | Best for |
Cloudflare tunnel (script above) | Unlimited* | โ | 5 min | Team evaluation |
Ngrok tunnel | Unlimited* | โ | 5 min | Team evaluation |
Hugging Face Spaces | Permanent | โ (cloud LLM) | 15 min | Public showcase |
*The free tier has some limitations. Always keep auth on for anything reachable from the internet, and rotate tokens that have been shared.
Hardware: 16+ CPU cores, 64 GB+ RAM (128 GB recommended), and an NVIDIA GPU with 24 GB+ VRAM (A100 / H100 / RTX 4090) for larger local models.
Software: Docker and Docker Compose, Python 3.10+, NVIDIA Container Toolkit.
Copy .env.example to .env and fill in environment-specific values.
Provider support (OpenAI-compatible)
Studio talks to Ollama (OLLAMA_HOST). The structured layer and the GraphRAG pipeline in graphrag-ollama-config/ work with any OpenAI-compatible API. The structured layer stays local unless you set VG_LLM_ALLOW_REMOTE to allow a remote endpoint.
Provider | API base | Example model |
Ollama (default) |
|
|
vLLM |
| any served model |
LM Studio |
| the model loaded in LM Studio |
OpenAI |
|
|
Groq |
|
|
Together AI |
|
|
Azure OpenAI, OpenRouter, Anyscale and LocalAI are also supported.
โ ๏ธ Embeddings must match your index. If you indexed with
nomic-embed-text(768 dims), you must query with the same model. Switching embedding models requires re-indexing.
๐งช Development & tests
pip install -e ".[studio,dev]"
ruff check veritasgraph studio_api veritasgraph_mcp
STUDIO_AUTH=off timeout 600 python -m pytest studio_api/tests tests -m "not ollama" -q \
--ignore=studio_api/tests/test_e2e_playwright.pyCI runs ruff and pytest on Python 3.10 and 3.12. Browser end-to-end tests live in tests/studio-e2e (see VERITASGRAPH_PLAYWRIGHT_INTEGRATION_TESTS.md). Contributions are welcome; see CONTRIBUTING.md and SECURITY.md.
๐งฉ Examples & ecosystem
Example | What it demonstrates | Run |
Studio agent pipeline: brief โ KG โ multi-hop Q&A with citations โ memory โ PII redaction โ guardrail block โ audit. |
| |
Seeds 17 tools and sample explorer agents (idempotent). |
| |
Zero-trust governed agent for medical and pharma workflows (NEECON 2026): step-up authorization, mandatory citations, hash-chained audit, 69 tests. |
| |
HIPAA-safe clinical KG: Safe Harbor de-identification, ConText NER, contradiction detection, ICD-10/RxNorm/SNOMED/LOINC normalization. |
| |
Civic incident reporting with CV validation (YOLO/VLM), KG-grounded routing and evidence fusion (architecture). |
| |
Construction drawings โ rooms, dimensions and schedules โ KG + CSV/XLSX takeoff, with every quantity traced to its sheet. | Hosted demo |
๐๏ธ Enterprise compliance โ VeritasGraph + VeritasReason
GraphRAG is great at describing what documents say. Questions like "Which purchase orders violated our Segregation-of-Duties policy last quarter?" are rule-evaluation problems over structured records. VeritasReason is a deterministic reasoning engine (forward-chaining + Rete + SPARQL) that fires policy rules over a triple store and returns auditable answers with W3C PROV-O provenance.
Policy PDFs โโ โโ ingest_structured.py (SQL โ triples + text)
โผ โผ
VeritasGraph GraphRAG VeritasReason (TripletStore + RuleSet
(quotes policy text) + ForwardChainer + PROV-O)
โโโโโโโโโโโโฌโโโโโโโโโโโโโโโโ
โผ
Compliance answer + violators table + clause citationspython tests/test_policy_compliance_demo.py # 30-second smoke test, stdlib only
pip install veritas-reason && veritasreason-policy-demoThe rules live in rules/sod_policy.yaml and the SQL โ triple mapping in ingest_structured.py. See veritas-reason/plan.md for a walkthrough.
Built with VeritasGraph
MeAkash77 / VeritasGraph-Enterprise-GraphRAG-Verifiable-AI-Platform โ enterprise GraphRAG adapter and verifiable AI platform patterns.
PTP063 / veritas-graph โ derivative project and live deployment.
RahulSagar2005 / multi-hop-rag โ multi-hop retrieval and reasoning workflows.
lukehungngo / agentwall โ agent security and governance-oriented reasoning flows.
gajanan229 / Fact-checker-Agent โ evidence-focused fact-checking.
Minh-Tam-Solution / EndiorBot โ enterprise chatbot built around graph-backed reasoning.
NistorDorinGabriel / Proiect_Licenta โ academic thesis extending VeritasGraph-inspired graph reasoning.
Building with VeritasGraph? Open a PR with a short repo description to be featured here.
๐ Guides & talks
๐ Build Governed AI Agents On-Prem (PDF): designing, wiring and shipping governed agents on your own infrastructure.
โก Live docs ยท ๐ฎ Live demo ยท ๐ Article ยท ๐ Research paper
๐ฆ Vision RAG Python package (PyPI)
Note: the
veritasgraphpackage on PyPI is the Vision RAG / tree + graph library. It is separate from the Studio / MCP / governance stack in this repository. Both install averitasgraphcommand, so use separate virtual environments if you need both.
pip install veritasgraph # basic (includes lite mode)
pip install veritasgraph[all] # + web UI, Microsoft GraphRAG, YouTube/web ingestion
veritasgraph demo --mode=lite # cloud APIs, no GPU (--mode=local for Ollama)from veritasgraph import VisionRAGPipeline, VisionRAGConfig
pipeline = VisionRAGPipeline(VisionRAGConfig(ingest_mode="document-centric")) # tables stay intact
doc = pipeline.ingest_pdf("report.pdf")
print(pipeline.get_document_tree()) # hierarchical "table of contents"
print(pipeline.navigate_to_section("Methodology")["breadcrumb"])
print(pipeline.query("What methodology was used?").answer) # graph search with section contextIngest mode | Description | Best for |
| Whole pages/sections as nodes (default) | Most documents |
| Each page = one node | Slide decks, reports |
| Each section = one node | Structured documents |
| Traditional 500-token chunks | Legacy compatibility |
Graph + Tree retrieval
Document Root
โโโ [1] Introduction
โ โโโ [1.1] Background โโโ Tree Navigation
โ โโโ [1.2] Objectives
โโโ [2] Methodology โโโโโโโโโโ Graph Links
โ โโโ relates_to โโโโโโโโโโโ [3.1] Findings
โโโ [3] ResultsThe package also includes an interactive PyVis graph explorer. It shows a query-aware subgraph, colors nodes by community, highlights query entities in red, and sizes nodes by number of connections.

Why VeritasGraph?
Feature | Vector RAG | PageIndex | VeritasGraph |
Retrieval type | Similarity | Tree search | ๐ Tree + graph reasoning |
Attribution | โ Low | โ ๏ธ Medium | โ Verified citations + receipts |
Abstains when evidence is missing | โ | โ | โ |
Governed vocabulary (ontology) | โ | โ | โ |
Tamper-evident audit | โ | โ | โ |
Multi-hop reasoning | โ | โ | โ |
Structured data (SQL) under the same governance | โ | โ | โ |
MCP server for IDE agents | โ ๏ธ Varies | โ | โ |
100% local/private | โ ๏ธ Varies | โ Cloud | โ On-premise |
Open source | โ ๏ธ Varies | โ Proprietary | โ MIT license |
Who is it for? Engineers building enterprise search, compliance assistants, research copilots, scientific literature explorers and agent memory systems: anywhere "the answer" depends on how facts connect, and where a wrong answer costs more than no answer.
๐ Acknowledgments
Builds on the foundational work of HopRAG, Microsoft GraphRAG, LangChain & LlamaIndex, and Neo4j.
๐ Awards & Citation
Presented at the International Conference on Applied Science and Future Technology (ICASF 2025) โ ๐ Appreciation Certificate.
@article{VeritasGraph2025,
title={VeritasGraph: A Sovereign GraphRAG Framework for Enterprise-Grade AI with Verifiable Attribution},
author={Bibin Prathap},
journal={International Conference on Applied Science and Future Technology (ICASF)},
year={2025}
}Star History
Available Tools
17 toolsveritasgraph_check_answerableA
Check whether the knowledge graph covers a question before asking it: returns matched entities and glossary terms, coverage and a reason. No LLM call.
Inputs: question (required), mode.
veritasgraph_compile_statusB
Last ontology compile run and the number of open curation suggestions.
Inputs: no named parameters.
veritasgraph_get_answer_receiptA
Fetch the receipt for a previous answer_id: evidence ids, grounding, the graph version it used, whether the graph changed since, and feedback.
Inputs: answer_id (required).
veritasgraph_get_entityB
One entity (by id or name) with neighbours, source chunks and glossary terms.
Inputs: entity (required).
veritasgraph_get_graphA
Return the full knowledge graph: all nodes, edges, and stats.
Inputs: no named parameters.
veritasgraph_get_ontologyB
The governed vocabulary: entity types, predicates (with domain/range) and glossary terms, each with status proposed / certified / deprecated.
Inputs: no named parameters.
veritasgraph_get_termB
One glossary term (by id or name) with its definition, synonyms, status and linked entities.
Inputs: term (required).
veritasgraph_import_graphA
Import a pre-built knowledge graph produced by another tool (Graphify graph.json, Understand-Anything KnowledgeGraph, AI Atlas taxonomy JSON, or any node/edge JSON). Imported nodes/edges are tagged with source_type provenance (curated/extracted/inferred) and their original id/version so curated content stays distinguishable.
Inputs: graph (required), title, format, source_type, +2 more.
veritasgraph_ingest_documentA
Ingest a document into the VeritasGraph knowledge graph. Chunks the text, extracts entities and relationships with a local model, and records the source chunk behind every node/edge for verifiable attribution.
Inputs: text (required), model, title.
veritasgraph_propose_termB
Propose a business glossary term (status 'proposed' until an admin certifies it), optionally linked to entity ids.
Inputs: name (required), synonyms, definition, entity_ids.
veritasgraph_queryB
Ask a question and get a graph-grounded, multi-hop answer with verifiable [doc#chunk] citations, a grounded flag, the reasoning path and an answer_id receipt. Abstains when the graph has no evidence.
Inputs: question (required), mode, model, max_depth, +1 more.
veritasgraph_search_entitiesA
Retrieve the subgraph most relevant to a query (entities, relationships, seeds) without invoking the LLM. Fast graph lookup.
Inputs: query (required), max_depth, max_nodes.
veritasgraph_search_termsB
Search the business glossary by name, synonym or definition.
Inputs: query (required), limit.
veritasgraph_structured_askA
Answer a question from connected databases with one validated, read-only, row-capped SQL query. Returns the SQL, rows and a receipt; refuses with status no_coverage when the catalog does not cover the question.
Inputs: question (required), mode, connection_id.
veritasgraph_structured_get_termA
One structured-data business term by id or name, with definition, synonyms and status.
Inputs: term (required).
veritasgraph_structured_list_measuresC
Named SQL measures with their expression, table and review status.
Inputs: status.
veritasgraph_structured_searchB
Search the structured-data catalog (terms, measures, tables, columns) by meaning and name. No SQL is run.
Inputs: query (required), k, kinds.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelogโฆ
TDQS
Scored across 17 tools
Most tools have clearly distinct targets: graph QA (query) versus SQL QA (structured_ask), full graph (get_graph) versus subgraph (search_entities) versus single entity (get_entity), each at a distinct granularity. The weakest boundary is glossary terms (search_terms/get_term) versus structured-data catalog terms (structured_search/structured_get_term), which share vocabulary and could be misselected by an agent despite the 'structured_' prefix hinting at the distinction.
The set is overwhelmingly verb_noun (get_entity, search_terms, propose_term, ingest_document, import_graph), with a coherent 'structured_' namespace for the SQL sub-domain. Minor deviations: bare 'query' lacks a noun, 'compile_status' is a noun phrase with no verb, and the structured_* tools put the namespace before the verb, inverting the dominant pattern.
17 tools spans three coherent sub-surfaces (graph QA/verification, ontology+glossary curation, structured-data access) plus ingestion, and each tool maps to a real operation. It is on the heavy side of the ideal band and a few read tools (e.g. get_term vs search_terms) could be merged, but nothing feels gratuitous.
Core workflows are covered end-to-end: ingest, query with citations, verify via receipts and check_answerable, inspect ontology and entities, and query structured data. However, the curation lifecycle is a dead end โ propose_term exists and compile_status reports open curation suggestions, but there is no tool to list, certify, update, or delete terms/suggestions, and receipts expose feedback with no way to submit it.
Maintenance
Related MCP Connectors
Cloud or self-hosted knowledge for AI agents: hybrid search, reranking, GraphRAG, scoped MCP tools.
Self-hosted AI workspace: semantic RAG document search, long-term memory, and AI chat via MCP.
Query your own knowledge graph from any MCP client. The graph lives in a database you own.
CellMath is a governed AI memory and knowledge-cell MCP server designed to stop context bloat, unverified memory drift, and agent hallucinations. Instead of dumping raw, noisy RAG chunks into every turn, CellMath organizes persistent agent knowledge into structured, isolated Knowledge Cells with causal graph edges and strict write-time governanceโkeeping the full 3-tool MCP schema ultra-compact (~1,200 tokens). Core 3-Tool Pipeline: โข vault_access โ Read-only lookup, cell hydration, and graph edge traversal with strict zero-match silence (never fabricates context when no verified cell exists). โข verify_safety โ Preflight security and policy gate that blocks destructive or unsafe operations before execution. โข vault_commit โ Governed state mutation (store, update, causal edges, session checkpoints, and 4-tier purge) enforcing source provenance. Built for Claude, Cursor, ChatGPT, Gemini, and autonomous agents over Streamable HTTP.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceAn open-source MCP server for RAG over personal documents. Supports three parallel strategies โ Traditional, Contextual, and Graph RAG โ with all data stored locally for privacy.MIT
- FlicenseNot gradedqualityDmaintenanceA local-first MCP server that transforms crypto whitepapers into a knowledge graph and vector corpus, enabling entity-filtered RAG question answering with optional knowledge graph enrichment.-
- AlicenseNot gradedqualityBmaintenanceMCP server for local RAG over personal notes, PDFs, and documents, enabling plain-English querying and hybrid search with multi-hop context expansion.MIT
- FlicenseAqualityDmaintenanceLocal-first MCP graph intelligence server providing RRF hybrid search, multi-hop traversal, source snippets, and rationale nodes for AI agents, without Docker or web UI.5-