Samyama: A Unified Graph-Vector Database with In-Database Optimization, Agentic Enrichment, and Hardware Acceleration
Listen
Radio episode about this paper
Transcript
Introduction to the show: ident: Computer Science. The day in computer science: software, systems and theory on arXiv.
Tom: I'm Tom.
Jane: And I'm Jane, here with Lu, Meng and our in-house large language model, Lalam.
Tom: We're looking at the paper: "Samyama: A Unified Graph-Vector Database with In-Database Optimization, Agentic Enrichment, and Hardware Acceleration".
Jane: Here's the gist of the paper. Samyama is presented as an AI-native database that treats graphs, vectors, and optimization as first-class citizens within a single memory-safe engine The single most informative sentence about the paper's subject and finding is Samyama (Sanskrit for “Integration”) is designed as an AI-native database that treats graphs, vectors, and optimization as first-class citizens within a single memory-safe engine.
Tom: Unified System Architecture Samyama is built on a modern Rust stack for memory safety and zero-cost abstractions Figure 1 illustrates the overall system architecture The system architecture shows the Client Interface, Query Engine, Graph Engine, Vector Engine, Semantic Search, and Optimization components interacting through a cost-based planner.
Jane: Core Engineering Contributions The engineering contributions include several key features designed for performance and utility These contributions are organized into primary research and engineering categories.
Title and authors: Tom: So we're looking at this paper today, "Samyama: A Unified Graph-Vector Database with In-Database Optimization, Agentic Enrichment, and Hardware Acceleration." The title itself tells you a lot—it’s about bringing graphs, vectors, and optimization together into one system that is memory safe.
Jane: It sounds like they're tackling the huge problem of data fragmentation where you have to move data around between different databases for graph stuff, vector stores for AI search, and solvers for optimization problems. So what does Samyama actually do to fix that?
Lu: They position Samyama as an AI-native database, treating graphs and vectors as first-class citizens inside a single engine written in Rust. That memory safety part is huge because it usually means you get performance without having to worry about crashing your whole system with memory errors when you're running complex stuff like this.
Meng: Rust for the backend suggests they are focused on raw performance and efficiency, which is what we need when you're dealing with billions of edges and vectors. But I have to ask, how do you actually keep everything that diverse in one place without it becoming a nightmare to manage?
Lalam: From my perspective, the paper promises an AI-native structure where the graph structure and the vector search are inherently linked within the same engine. It’s about treating these different data types as just different ways of looking at the same underlying information.
Tom: Exactly. So they are aiming for a system that doesn't force you to choose between having a fast graph database or a good vector store, because they build both into one place using this unified approach.
Jane: And the authors say this unification is achieved by organizing their contributions into primary research and engineering categories, which is helpful for seeing the scope of what they built.
The paper's summary: Tom: Okay, so summarizing Samyama: it’s a system that combines a RocksDB-backed store with MVCC, a vectorized executor, and this cost-based planner to figure out the best way to run queries across all those components.
Jane: That planner is key because it decides how to use the graph engine or the vector engine based on what you’re asking for, which sounds like it saves a ton of planning time that usually happens outside the database.
Lu: They also have this thing called late materialization for graphs, which uses something called NodeRef-based lazy property resolution to get a four point zero to four point seven times speedup in traversal speed. That means they don't load every single piece of graph data at once; they only load it when you actually need it.
Meng: A four point seven times speedup sounds impressive, but I’m wondering about the trade-offs there. Does that lazy loading introduce latency spikes when you finally do request all those properties? What's the cost of that on real-time queries?
Lalam: The engineers also built in this agentic enrichment part, which is called Generation-Augmented Knowledge or GAK. This lets the system use LLM tool-calling agents to autonomously expand a graph by generating Cypher commands when it needs more information.
Tom: So we're talking about a database that can not only query existing data fast but also intelligently ask an LLM to find new connections or details in the graph on its own. That’s pretty ambitious integration.
Jane: And they claim this system has been run at billion-edge scale, specifically seventy-four point three million nodes and one point zero seven billion edges from four biomedical sources on just two point five dollars of spot compute time <ref:2603.08036#pg1,edges from four biomedical sources on>.
The paper's improvements: Tom: Let's talk about the specific technical improvements they highlight. First up is this in-database metaheuristic optimization, where they say you can access twenty-two different solvers directly through the query language, which completely eliminates that ETL overhead we talked about earlier.
Jane: That’s a big deal for things like supply chain optimization because normally you have to pull data out, run a solver in Python or Gurobi somewhere else, and then pull the answer back in. Eliminating that round trip cuts out all that operational complexity.
Lu: And they also added agentic enrichment, GAK again, which uses LLM tool-calling agents like a WebSearchTool or an NLQClient to discover information and generate Cypher create commands on the fly. It’s how the graph actually expands autonomously.
Meng: From a deployment standpoint, I'm interested in how they handle the scale of this optimization part. If you have twenty-two solvers accessible directly, does that mean you have to manage twenty-two different kinds of execution environments running inside your database? That sounds complicated at scale.
Lalam: The agentic enrichment also allows for cross-domain knowledge graph federation, which they demonstrated by building a six knowledge graph federation spanning molecular biology to population health and passing one hundred thirty six or one hundred forty benchmark queries.
Tom: So they’re not just optimizing within one domain; they’s bridging different scientific fields, like biology and health, all through this single unified engine.
Conclusion: Jane: So to wrap up the Samyama paper, we're looking at a system that integrates graphs, vectors, and optimization into a single memory safe engine using Rust. The core idea is treating these three things as native database features.
Tom: They show significant performance gains with late materialization for graphs and they’ve made in-database solvers accessible directly so you don't have to move data around for complex math problems.
Lu: It really shows the ambition of AI-native databases, moving toward a system where the AI part is not just an add-on but fundamentally built into the storage and query layers.
Meng: From an engineering view, the billion edge scale with that low compute cost is what catches my eye for production deployment, assuming you can manage that complexity we discussed earlier.
Lalam: And they showed this system can actually use LLMs to dynamically enrich its knowledge graph using agentic enrichment and federation across different scientific domains.
Jane: It suggests a future where complex AI tasks, from reasoning to data retrieval, happen seamlessly within one unified database environment instead of being stitched together by separate tools.
Tom: That's the big picture here—a single memory safe engine handling everything from simple queries to complex optimization and autonomous graph expansion.
Jane: We’ll leave you with this paper on Samyama, a unified graph-vector database with in-database optimization, agentic enrichment, and hardware acceleration.
Madhulatha Mandarapu, Sandeep Kunkunuru
VaidhyaMegha Private Limited
cs.DB
Submitted: 2026-03-09
Updated: 2026-11-13
Comments: 20 pages, 4 figures. v4 adds Section 7.6 on synthetic workload compilation and privacy-preserving graph twins, and corrects the v1-v2 hardware history note
License: http://creativecommons.org/licenses/by/4.0/
Importance score: 97/100
The gist: Samyama is presented as an AI-native database that treats graphs, vectors, and optimization as first-class citizens within a single memory-safe engine The single most informative sentence about the…
Key concepts
- Late Materialization
- This technique delays the loading of graph properties until they are actually needed during a query. By resolving properties on demand through a ColumnStore operator, Samyama reduces memory bandwidth usage by 4-5x and speeds up graph traversal by 4.0–4.7x.
- In-Database Metaheuristic Optimization
- This feature allows complex optimization solvers to run directly inside the database using Cypher procedures. This eliminates the need to move data out of the system for optimization tasks, saving significant time and avoiding costly ETL processes.
- Agentic Enrichment (GAK)
- This enables autonomous graph expansion by leveraging Large Language Models (LLMs). Agents use tools like WebSearchTool or NLQClient to discover new information and generate Cypher commands on their own, allowing the knowledge graph to grow dynamically.
- Cross-Domain Knowledge Graph Federation
- Samyama can link different knowledge graphs spanning diverse fields, such as molecular biology and population health. This federation allows users to query across these distinct domains using a unified system.
Terminology
Summary
Samyama is presented as an AI-native database that treats graphs, vectors, and optimization as first-class citizens within a single memory-safe engine The single most informative sentence about the paper's subject and finding is Samyama (Sanskrit for “Integration”) is designed as an AI-native database that treats graphs, vectors, and optimization as first-class citizens within a single memory-safe engine.
Unified System Architecture
Samyama is built on a modern Rust stack for memory safety and zero-cost abstractions Figure 1 illustrates the overall system architecture The system architecture shows the Client Interface, Query Engine, Graph Engine, Vector Engine, Semantic Search, and Optimization components interacting through a cost-based planner.
Core Engineering Contributions
The engineering contributions include several key features designed for performance and utility These contributions are organized into primary research and engineering categories.
-
Late materialization for graphs achieves a
4.0–4.7× traversal speedup
through NodeRef-based lazy property resolution -
In-database metaheuristic optimization allows 22 solvers to be accessible directly via Cypher procedures, eliminating ETL overhead
-
Agentic Enrichment (GAK) enables autonomous graph expansion using LLM tool-calling
-
Billion-edge knowledge graph federation spans 74. p. 1
3M nodes and 1. p. 0Where the paper says it
Agentic Enrichment (GAK): Autonomous graph expansion using LLM tool-calling (§5. Billion-edge knowledge graph federation (v0.
Where the paper says it
It has been run to billion-edge scale: 74. 3M nodes and 1.
Green — the paper says it, and the page is printed. Red — no passage carries it, so treat that sentence as unverified. The same check runs on your own text: check a summary against its source, $5.
Improvements for AI systems
-
Late materialization for graphs achieves 4.0–4.7x traversal speedup by producing
NodeRef-based lazy property resolution,
allowing properties to be resolved on-demand via the ColumnStore at the final ProjectOperator,reducing memory bandwidth by 4–5x.
-
In-database metaheuristic optimization eliminates ETL overhead because
in-database solvers operate directly on the graph store, avoiding this round-trip entirely
for tasks like supply chain optimization. -
Agentic enrichment expands a graph via LLMs through Generation-Augmented Knowledge (GAK), where the system uses
LLM tool-calling agents (WebSearchTool, NLQClient) that discover information and generate Cypher CREATE commands.
-
The system can perform cross-domain knowledge graph federation, demonstrated by building a
6-KG federation spanning molecular biology to population health with 136/140 benchmark queries passing.
-
The AI system gains the ability to convert natural language questions into Cypher via an NLQPipeline that uses LLM providers to generate queries, followed by safety validation using is safe query.
Abstract
Modern data architectures fragment across graph databases, vector stores, analytics engines and optimization solvers, forcing ETL between them. We present Samyama, a graph-vector database in Rust that unifies these workloads in one engine: a RocksDB-backed store with MVCC, a vectorized executor, a cost-based planner, a CSR analytics engine, RDF and SPARQL, 22 metaheuristic solvers callable from the query language, HNSW vector indexing, and agentic enrichment that expands a graph via LLMs. It has been run to billion-edge scale: 74.3M nodes and 1.07B edges from four biomedical sources on one machine for 2.50 of spot compute. This version re-measures the system at release v1.8.0 on rented Linux hosts a reader can boot, replacing earlier figures taken on a Mac Mini that nobody could re-run. On a 16-vCPU cloud instance, ingestion reaches 123K-152K nodes/s and PageRank costs 6.7 ms per iteration at ten thousand nodes and 236 ms at a million. The previously reported 8.2x GPU speedup is withdrawn; in its place we measure the CUDA path, which no earlier version measured at all, on a rented NVIDIA A16: parity with the CPU at ten thousand nodes, 1.62x at a hundred thousand and 2.70x at a million, with 1.1-1.35 s of context initialisation on the first call. The earlier Cypher-throughput figure, its claim of near-constant index-driven scaling, and a vector-search figure are withdrawn as unreproducible. openCypher conformance, once estimated at 90%, is now measured at 99.9% of evaluated TCK scenarios. Against Neo4j 5 and FalkorDB on one host over an identical SF10 extract, 14 of 14 SNB complex reads land within 5x of the best competitor and 7 of 14 are faster.
Related papers
- Beyond Overlap: Hierarchical Graph Abstraction for Out-of-Core Vector Search
- EMA: Approximate Nearest Neighbor Search with General Attribute Filtering and Dynamic Updates
- Open Biomedical Knowledge Graphs at Scale: Construction, Federation, and AI Agent Access with Samyama Graph Database
- GenTUS: Table Union Search via Constrained Generation of Semantic Table Identifiers
- Common-Neighbor-Count-Based Representative Possible World Finding on Uncertain Graphs
- SAGA: Synthetic Agentic Graph Architecture for Temporal Benchmark Generation