Samyama Graph Database

A Unified Graph-Vector Engine with In-Database Optimization

v0.5.12 | Built in Rust | Powered by Mechanical Sympathy
Madhulatha Mandarapu & Sandeep Kunkunuru

The Fragmentation Problem

Modern AI and industrial applications require four distinct workloads:

Result: Data silos, synchronization overhead, operational complexity.

The Samyama Solution

One binary. Four workloads. Zero GC pauses.

                    ┌──────────────────────────────────┐
                    │        OpenCypher + RESP          │
                    ├──────────┬───────────┬────────────┤
                    │  Graph   │  Vector   │ Optimization│
                    │  Engine  │  Search   │  22 Solvers │
                    ├──────────┴───────────┴────────────┤
                    │    Vectorized Executor (28 ops)    │
                    ├───────────────────────────────────┤
                    │  RocksDB + MVCC + Raft Consensus  │
                    └───────────────────────────────────┘

• Property Graph with ~90% OpenCypher coverage
• HNSW Vector Index with Cosine, L2, Dot Product
• CSR Analytics Engine with 14 graph algorithms
• 22 Metaheuristic Solvers (Jaya, PSO, DE, NSGA-II, ...)

Why Rust?

• Memory safety without garbage collection (ownership + borrowing)
• Zero-cost abstractions (traits, generics, iterators)
• Fearless concurrency (Send/Sync + Rayon data parallelism)
• Compiles to a single static binary

Core Architecture: Mechanical Sympathy

  NodeId (u64) ──→ Vec<Vec<Node>>     ← Versioned Arena (O(1) access)
  EdgeId (u64) ──→ Vec<Vec<Edge>>     ← Contiguous memory layout

  ColumnStore:  "age"  → [25, 30, 42, 28, ...]   ← Cache-friendly arrays
                "name" → ["Alice", "Bob", ...]

Key Design Decisions:

Late Materialization (ADR-012)

Before: Scan clones full nodes at every operator stage.
After: Scan produces Value::NodeRef(id) — properties resolved only at RETURN.

  Scan ──→ Filter ──→ Expand ──→ Project ──→ Limit
  (IDs)    (IDs)      (IDs)     (resolve)   (output)

Bottleneck analysis: Parse (54%) + Plan (44%) >> Execute (2%).

Query Engine: 28 Physical Operators

Hybrid Volcano-Vectorized model with batch size 1,024:

Cost-based optimizer uses GraphStatistics for index selection and predicate pushdown.

Graph Analytics: CSR Projection

The GraphView projects into Compressed Sparse Row for OLAP:

  out_offsets:  [ 0,  2,  4,  5,  7 ]
  out_targets:  [ 1,  3,  0,  2,  3,  0,  1 ]
  weights:      [1.0,2.0,1.0,3.0,1.0,2.0,4.0]

14 algorithms across 5 categories:

PCA & Dimensionality Reduction

Two solvers with automatic selection:

// Via SDK
let result = client.pca("Person", &["age", "income", "score"],
    PcaConfig { n_components: 2, solver: PcaSolver::Auto, ..default() }
).await?;
// result.components, result.explained_variance, result.transform()

GPU PCA (Enterprise): 5 WGSL shaders with tiled covariance (64-sample tiles), fused power iteration + normalize in single dispatch. Threshold: 50K nodes, d > 32.

In-Database Optimization

22 metaheuristic solvers — no data movement to Python.

CALL algo.or.solve({
  algorithm: 'NSGA2',
  label: 'Generator',
  objectives: ['cost', 'emissions'],
  constraints: [{ property: 'load', max: 500.0 }],
  population_size: 100
}) YIELD pareto_front

All solvers leverage Rayon for parallel fitness evaluation. Multi-objective solvers use the Constrained Dominance Principle for feasibility-first Pareto optimization.

Vector Search & Graph RAG

HNSW indexing (via hnsw_rs) with three distance metrics:

Graph RAG = Vector search + Graph traversal in one query:

CALL vector.search('embedding_idx', $query_vector, 10) YIELD node, score
MATCH (node)-[:AUTHORED]->(paper)-[:CITES]->(ref)
RETURN paper.title, ref.title, score

Filters applied inside the execution engine, not post-hoc.

Agentic Enrichment (GAK)

Generation-Augmented Knowledge: The inverse of RAG.

  Query hits missing data
       │
       ▼
  Event Trigger fires
       │
       ▼
  AgentRuntime activates
       │
       ├──→ WebSearchTool (discovers information)
       ├──→ NLQClient (generates Cypher)
       │
       ▼
  CREATE commands fill knowledge gap
       │
       ▼
  Database self-evolves

Safety: Schema validation, destructive query rejection, rate limiting.
NLQ Providers: OpenAI, Gemini, Ollama, Claude.

RDF & SPARQL Support

Native RDF support via the oxrdf crate:

Property Graph to RDF bidirectional mapping framework defined.

Developer Ecosystem (v0.5.12)

// Rust SDK — Embedded (zero overhead)
let client = EmbeddedClient::new();
client.query("default", "CREATE (n:Person {name: 'Alice'})").await?;

// Extension traits for algorithms & vectors
let scores = client.page_rank(config, "Person", "KNOWS").await?;
let results = client.vector_search("idx", &query_vec, 10).await?;

Samyama Enterprise Edition

Production-grade capabilities for mission-critical deployments:

RPO: zero data loss. RTO: minutes (full), seconds (WAL replay).

GPU Acceleration: The Crossover Point

GPU crossover: ~100K nodes for general algorithms, ~50K for PCA.
Below threshold, CPU-GPU memory transfer overhead dominates.

Performance Summary (Mac Mini M4, 16GB)

LDBC Graphalytics Validation

Industry-standard benchmark for graph analytics correctness:

S-size datasets: cit-Patents (3.8M vertices, 16.5M edges), datagen-7_5-fb (633K vertices, 68.4M edges), wiki-Talk (2.4M vertices, 5.0M edges).

Distributed Consensus (Raft)

  Client ──→ Leader ──→ Append to Log
                  │
                  ├──→ Follower 1 (AppendEntries)
                  ├──→ Follower 2 (AppendEntries)
                  │
                  ← Quorum (2/3) ──→ Commit to GraphStore
                  │
                  └──→ OK to Client

• CP trade-off: Strong consistency via quorum commits
• Leader election: Automatic failover within 1-2 heartbeat intervals
• Tenant-level sharding: SeaHash(tenant_id) % num_shards
• Enterprise: HTTP/2 transport, TLS, snapshot streaming to lagging followers

Research Foundation

Samyama implements algorithms from 30+ peer-reviewed papers:

Summary

Samyama is a unified graph-vector database that eliminates the need for separate systems:

• 4 workloads in 1 binary: Graph + Vector + Analytics + Optimization
• Memory safe: Rust ownership — zero GC pauses, zero data races
• Hardware accelerated: GPU compute shaders for large-scale analytics
• AI-native: Graph RAG, Agentic Enrichment, Natural Language Queries
• Industry validated: 28/28 LDBC Graphalytics, 115K QPS OLTP
• Multi-language: Rust, Python, TypeScript SDKs + CLI + OpenAPI

https://samyama.ai | https://x.com/Samyama_AI