Samyama Graph

A Rust-native graph-vector database for GraphRAG, knowledge graphs, and billion-edge analytics.

The graph database that queried 1 billion edges for $2.50

💬 Join the Samyama OSS community on WhatsApp — questions, help, and updates.

What is Samyama Graph?

Samyama Graph is a Rust-native graph-vector database that lets developers store, query, search, and analyze connected data in one system.

It brings together graph traversal, OpenCypher-style querying, vector search, graph algorithms, and Redis-compatible access, making it useful for GraphRAG, knowledge graphs, AI agent memory, and large-scale relationship analytics.

Quickstart

Option 1 — Run with Docker Compose

Step 1 — Prerequisites

• ✅ Docker Desktop installed and running — Watch setup video →
• ✅ No AWS account or credentials needed — the image is publicly available

Step 2 — Pull the Docker image

docker pull public.ecr.aws/f9f6l5u4/samyama-graph:1.1.0

Step 3 — Docker Compose setup

Create a clean folder, then create docker-compose.yml inside it.

Linux & Mac:

mkdir -p samyama-graph
cd samyama-graph
touch docker-compose.yml

Windows (PowerShell):

mkdir C:\samyama-graph
cd C:\samyama-graph
notepad docker-compose.yml

ℹ️ Replace <your-openai-api-key> with your actual key. Generate one at platform.openai.com/api-keys.

version: "3.9"
services:
  samyama-graph:
    image: public.ecr.aws/f9f6l5u4/samyama-graph:1.1.0
    container_name: samyama-graph
    restart: unless-stopped
    ports:
      - "6379:6379"
      - "8080:8080"
    environment:
      EMBED_ENABLED: "true"
      EMBED_PROVIDER: openai
      EMBED_MODEL: text-embedding-3-small
      EMBED_API_KEY: <your-openai-api-key>
      EMBED_DIMENSION: 1024
    volumes:
      - samyama-data:/app/samyama_data
    networks:
      - samyama-network
networks:
  samyama-network:
    driver: bridge
volumes:
  samyama-data:

Step 4 — Start the server

docker compose up -d

Server will be available at http://localhost:8080

Step 5 — Verify it's running

docker ps
docker logs -f samyama-graph

You should see samyama-graph with status Up.

Step 6 — Samyama Visualizer

Visualize your imported graph data using the Samyama cloud visualizer at https://graph.samyama.cloud/

1. Open https://graph.samyama.cloud/ in your browser.
2. Sign up for a new account, or sign in if you already have one.
3. From the left sidebar, click Home.
4. In the connection field, enter your local graph server URL: http://localhost:8080.
5. Click Connect — the status will change to Connected.

curl -X POST http://localhost:8080/api/tenants \
  -H "Content-Type: application/json" \
  -d '{"id": "dbms-research", "name": "dbms-research"}'

curl.exe -X POST http://localhost:8080/api/tenants `
  -H "Content-Type: application/json" `
  -d '{"id": "dbms-research", "name": "dbms-research"}'

curl -X POST http://localhost:8080/api/snapshot/import \
  -F "file=@./samyama-graph/dbms-research.sgsnap" \
  -F "tenant_id=dbms-research"

curl.exe -X POST http://localhost:8080/api/snapshot/import `
  -F "file=@C:\samyama-graph\dbms-research.sgsnap" `
  -F "tenant_id=dbms-research"

Step 8 — Stop / reset

Stop the server:

docker compose down

Reset all data (⚠️ deletes volume):

docker compose down -v

⚠️ This deletes all graph data stored in the Docker volume.

Option 2 — Build from source

System packages. zstd-sys generates its bindings with bindgen, which needs libclang. Without it the build fails part-way through with a misleading 'stddef.h' file not found.

# Debian / Ubuntu
sudo apt-get install -y build-essential cmake pkg-config libssl-dev clang libclang-dev

# Fedora / RHEL
sudo dnf install -y gcc gcc-c++ cmake pkgconf-pkg-config openssl-devel clang clang-devel

# macOS — the Xcode Command Line Tools already provide clang
xcode-select --install

Then, with a stable Rust toolchain from rustup:

# Build from source
git clone https://github.com/samyama-ai/samyama-graph && cd samyama-graph
cargo build --release
./target/release/samyama    # RESP on :6379, HTTP on :8080

# Connect with any Redis client
redis-cli -p 6379
GRAPH.QUERY mydb "CREATE (a:Person {name: 'Alice'})-[:KNOWS]->(b:Person {name: 'Bob'})"
GRAPH.QUERY mydb "MATCH (a)-[:KNOWS]->(b) RETURN a.name, b.name"

What can you build with Samyama Graph?

Samyama Graph is useful when your application needs both connected-data reasoning and semantic retrieval.

You can use it to build:

• GraphRAG systems that combine vector search with graph traversal
• Knowledge graph applications for enterprise, research, healthcare, and operations data
• AI agent memory where entities, tools, actions, and context are stored as a graph
• Biomedical and clinical graphs across papers, trials, pathways, drugs, and conditions
• Fraud and investigation graphs for relationship discovery and pattern analysis
• Infrastructure and dependency graphs for impact analysis and root-cause exploration
• Large-scale graph analytics using built-in graph algorithms

We loaded the entire PubMed corpus — every article published since 1966 — plus ClinicalTrials.gov, Reactome pathways, and DrugBank into one graph. Then we asked:

"What drugs are most tested in cancer clinical trials?"

MATCH (m:MeSHTerm)<-[:ANNOTATED_WITH]-(a:Article)
      -[:REFERENCED_IN]->(t:ClinicalTrial)-[:TESTS]->(i:Intervention)
WHERE m.name = 'Neoplasms'
RETURN i.name, count(DISTINCT t) AS trials
ORDER BY trials DESC LIMIT 5

5.2 seconds. One query. Four databases. 74 million nodes. 1 billion edges. A single machine.

See all 100 benchmark queries →

⭐ Find this useful? A GitHub star helps more developers discover Samyama Graph.

Demo

Cricket KG — 36K nodes, 1.4M edges, live graph simulation

Click for full demo (1:56)

Infrastructure failure-propagation

One query family — reachability, criticality, N-1 contingency — runs identically across infrastructure domains. Both demos use real CC BY 4.0 data.

Power Grid — IEEE 14-bus system (pglib-opf): degree centrality → connectivity → N-1 line contingency.

Telecom — GÉANT 2012 pan-European backbone (Internet Topology Zoo): 40 PoPs across 37 countries; N-1 link contingency exposes 8 single points of failure.

Case Studies — prove it yourself

case_studies/ lets anyone who clones this repo download a real public knowledge graph, import it, run showcase Cypher (and vector search), and render the session as a narrated GIF — one command, no database to install. Every showcase query is gated to return real rows before any GIF is recorded (see the Definition of Done).

cargo build --release && pip install rich requests
cd case_studies/cricket && ./run.sh          # fetch snapshot → import → validate → demo
RECORD=1 ./run.sh                            # also (re)generate demo.gif

Each snapshot is small enough to run on a laptop; every query returns real rows. GIFs can't pause in a browser, so each domain also ships its demo.cast — replay it pausably (space) with asciinema play case_studies/<domain>/demo.cast.

surveillance + health-determinants + health-systems federate by Country.iso_code into a public-health trifecta. Browse the catalogue →

Why Samyama Graph?

If your data has relationships, you need a graph database. If your graph database can't handle a billion edges on a single machine, you need Samyama.

The 30-Second Tour

Cypher queries — MATCH, CREATE, MERGE, aggregations, path finding, 30+ functions. Coverage against the openCypher TCK is not yet measured; see docs/CYPHER_COMPATIBILITY.md for a per-feature matrix verified by an executable probe.

MATCH (a:Person)-[:KNOWS*1..3]->(b:Person)
WHERE a.name = 'Alice'
RETURN b.name, length(shortestPath(a, b))

Graph algorithms — PageRank, WCC, SCC, BFS, Dijkstra, LCC, CDLP, Triangle Count. All rayon-parallelized.

CALL pagerank('social') YIELD nodeId, score
RETURN nodeId, score ORDER BY score DESC LIMIT 10

Vector search — HNSW indexing for semantic search and Graph RAG.

CREATE VECTOR INDEX paper_idx FOR (p:Paper) ON (p.embedding) OPTIONS {dimensions: 384, similarity: 'cosine'}

CALL vector.search('Paper', 'embedding', [0.1, 0.2, 0.3], 10) YIELD node, score

Natural language — Ask questions in English. The LLM translates to Cypher.

NLQ "Who are Alice's friends of friends that work at Google?"
→ MATCH (a:Person {name:'Alice'})-[:KNOWS]->()-[:KNOWS]->(fof)-[:WORKS_AT]->(c:Company {name:'Google'}) RETURN fof.name

AI agents — Auto-generated MCP servers from your graph schema.

pip install samyama[mcp]
samyama-mcp-serve --demo cricket    # Instant AI agent tools for any graph

Benchmarks

Run them: cargo bench --bench <name> (benches/). The vector, optimization, and micro/MVCC suites are self-contained; LDBC needs a data download.

HIER (benchmarks/hier/) is a category for subsumption and hierarchical roll-up over time, geography and ontology — the workload the LDBC and FinBench suites do not contain. Every query is checked against an unindexed run of the same question, so a speedup is only reported alongside an identical answer. Latest: 108/108 agree; roll-up is flat at 15–20 ns from a 1-node subtree to a 137,257-node one. Against Neo4j on an identical graph it is 94× faster across the 58 queries expressible on both, with no class losing — though without the index Samyama is 1.6× slower than Neo4j, so the index is the differentiator rather than the engine.

Scale: 74M Nodes, 1 Billion Edges

Loaded in 31 minutes from snapshots. 96 of 100 queries return real data across all four KGs. Full results →

Cross-KG Query Highlights

LDBC Compliance

Concurrent Performance

Examples

Run them all in one command: ./scripts/run_all_examples.sh --batch builds every example, starts a server, and runs each in turn with a pass/fail summary (the orchestrator for the examples/ directory).

Domain Knowledge Graphs

19 demo examples + 11 data loaders in examples/; optimization/use-case demos: grid_dispatch_demo, amr_stewardship_demo, healthcare_allocation_demo, wildfire_evac_demo, pca_demo, sdk_demo, …

Data Loaders

Related Repositories

samyama-graph is the engine. Per-domain KGs and companion projects live separately and can be loaded into it:

• KGs: pubmed-kg (66M / 1B), clinicaltrials-kg (7.8M / 27M), druginteractions-kg (245K / 388K), pathways-kg (119K / 835K), cricket-kg (36K / 1.4M), imdb-kg (1.94M / 2.63M), football-kg (16K / 12K), assetops-kg (13K / 13K), powergrid-kg (pglib-opf — infrastructure), telecom-kg (Internet Topology Zoo — infrastructure)
• Benchmarks: biomedqa — 40-question pharmacology benchmark across three KGs
• Companions: graphrag-rs — doc-to-KG + MCP server; optimization_algorithms — PyPI rao-algorithms package (PyO3 bindings over crates/samyama-optimization/)

Architecture

samyama
├── graph/         Property graph model (Node, Edge, GraphStore, CSR adjacency)
├── query/         OpenCypher engine
│   ├── cypher.pest    PEG grammar
│   ├── executor/      Volcano iterator + WCO LeapFrog TrieJoin
│   └── planner.rs     Cost-based graph-native query planner
├── protocol/      RESP3 server (Redis-compatible, Tokio async)
├── persistence/   RocksDB + WAL + multi-tenancy
├── vector/        HNSW vector index
├── snapshot/      Portable .sgsnap v2 (CSR + ColumnStore)
├── raft/          Distributed consensus (openraft)
└── nlq/           Natural language → Cypher (OpenAI, Gemini, Ollama, Claude)

Companion crates:

• samyama-graph-algorithms — PageRank, BFS, Dijkstra, WCC, SCC, LCC, CDLP, Triangle Count (all rayon-parallelized)
• samyama-optimization — 15+ metaheuristic solvers (Jaya, Rao, GWO, NSGA-II, TLBO)
• samyama-sdk — Rust SDK with embedded and remote clients

Documentation

Enterprise Edition

Everything above is open source (Apache 2.0). Samyama Enterprise adds:

• GPU acceleration (wgpu + CUDA)
• OpenTelemetry OTLP metrics
• Prometheus + Grafana monitoring
• Backup & disaster recovery
• ADMIN commands + audit trail
• Ed25519 signed license tokens

Contact us →

Contributing

Contributions are welcome — bug reports, docs, tests, and code. See CONTRIBUTING.md for development setup, build/test commands, and the pull request workflow. Good first areas are listed there.

• 🐛 Found a bug or have an idea? Open an issue.
• 💬 Questions or general discussion? Join the community chat.

License

Apache License 2.0 — use it in production, contribute back if you'd like.

Samyama (Sanskrit: संयम) — the union of focused query, sustained analysis, and unified insight.