The knowledge graph your agents can query in real time.
StromaDB fuses vectors × types × time in one engine: a streaming knowledge graph where an LLM agent runs type-aware hybrid search, reads any stored fact as it was at any past moment, and gets an answer that shows where it came from — while the graph keeps ingesting underneath.
Explore the graph, search by type, inspect a node — live.
The engine ships a GPU-rendered graph explorer, stroma-serve: walk a neighbourhood, run a type-aware vector search, and inspect any node down to its embedding — all against the live graph.
A stream goes in. An agent reads meaning, structure, and time back out.
One engine for the way agents actually read a graph.
Retrieval that is semantic, structural, and temporal at once — not a vector store bolted to a graph db.
Type-aware hybrid search
Vector search filtered by node type, graph structure, and per-user permissions — so an approximate match never returns the semantically-close but wrong node. Types come from a lightweight ontology that says which types each relationship can connect, how many are allowed, and what extra attributes it can carry — no axioms, no reasoner.
Read any moment in the past
Every fact records the span of time it was true. Ask for the value that was in effect at any instant — "who approved this, as things stood at approval time" — not just the latest write.
Real-time under writes
Reads never block, even while a long streaming ingest is running — and every read sees one consistent moment of the graph.
Declared rules → verdicts
Evaluate a rule you declare against the graph, deterministically: what's expected but missing, and what's present but wrong — traced back through the chain of relationships that led there, as it stood at the relevant past moment. No reasoner.
Durable by design
Every write lands safely on disk before it counts, committed in batches. After a crash, cold-start replays everything that was committed and drops any half-written tail using a checksum — nothing committed is lost.
Agent-native (MCP)
Ships a Model Context Protocol server: an LLM discovers the schema and calls the graph as tools — schema, point, expand, search, conformance — over stdio.
Numbers, taken under unfriendly conditions.
Measured at representative scale on hard data.
Hand the deterministic part to the engine.
An LLM is great at orchestration and language, but unreliable at exact graph logic that follows a long chain of relationships and depends on how things stood at a past moment. So the engine evaluates declared rules and returns a deterministic verdict; the agent calls it and acts.
// approver = manager of the assignee's dept, // as of the approval time { "op": "conformance", "rule": { "subject_type": "Issue", "required": { "hops": [ {"predicate":"assigned-to"}, {"predicate":"member-of"}, {"predicate":"manager-of", "as_of":"approved-at"} ] }, "actual": "approved-by" } }
{ "verdicts": [
{ "subject":1001, "verdict":"OK" },
{ "subject":1004, "verdict":"MISMATCH",
"kind":"wrong" },
{ "subject":1005, "verdict":"MISMATCH",
"kind":"stale", // approved by a
"required":{"node":12}, // past manager
"actual":{"node":10}, "as_of":6000 }
] }
Stream facts
Multi-source events fold into a typed graph, each fact tagged with when it was true and where it came from.
→Type × vector × time
The agent pulls context that's relevant by meaning and by structure, as it was at any past moment.
→Rules → verdicts
The engine deterministically flags absent / wrong / stale — no reasoner.
→Agent orchestrates
The LLM interprets verdicts and acts, holding no exact graph logic itself.
Self-host it. Embed it. Query it from any agent.
A single Rust binary — HTTP and an MCP stdio server. Elastic License 2.0: self-host, modify, and embed freely.