VelesDB

Three engines. One language. A memory your agents can explain.

One ~9 MB binary fuses vector + graph + columnar under VelesQL — persistent agent memory with an evidence trail (why()) and a deterministic context optimizer that cuts your real, billed token spend.
Zero cloud, zero LLM, zero API key in the memory path. Every number on this page links to a committed, reproducible harness. Measured, not vibes.

_{The name nods to Veles, a deity of old Slavic myth — a keeper of hidden knowledge and boundaries.}

Quick Start • Proof • Premium • Architecture • Roadmap • velesdb.com • DeepWiki

Why VelesDB exists

Every AI agent today has the same two problems:

1. It forgets. Session ends, context gone. Teams bolt on three databases to fix it — vectors for "what feels similar", a graph for "what is connected", SQL for "what I know for sure" — three deployments, three query languages, and a pile of glue code.
2. It overpays. Most of the budget goes to re-reading redundant context, and "memory" products fix it by putting another paid model call inside every memory write — generative, non-reproducible, unexplainable by construction.

VelesDB answers both with two layers that ship as one project:

The database stands on its own. The memory model is why agents pick it.

The differentiator no one else combines

The leading agent-memory products (Mem0, Zep, Letta — detailed comparison, as of mid-2026) put an AI model in the memory write path: every save runs model calls — by default paid, cloud, keyed. VelesDB is built on the opposite bet:

Get started in 60 seconds

Fastest path — Python, under 5 seconds median, measured:

pip install velesdb
curl -O https://raw.githubusercontent.com/cyberlife-coder/VelesDB/main/examples/python/hello_velesdb.py
python hello_velesdb.py

Expected output (byte-for-byte — read the 25-line script):

Query: "tech"
  score=1.000  Rust 1.89 release notes
  score=0.600  AI-generated jazz: the new wave
  score=0.000  Best ramen in Tokyo

Query: "tech + music"
  score=0.990  AI-generated jazz: the new wave
  score=0.707  Rust 1.89 release notes
  score=0.707  Miles Davis discography

Give your agent a memory (3 commands)

# 1. The MCP memory server (or grab a prebuilt .mcpb bundle from the latest release)
cargo install velesdb-memory

# 2. Point your agentic CLI at it (Claude Code shown; any MCP client works)
claude mcp add velesdb-memory -- ~/.cargo/bin/velesdb-memory

# 3. Teach the agent the workflow — both skills, no repo clone needed
curl -L https://github.com/cyberlife-coder/VelesDB/releases/latest/download/velesdb-skills.tar.gz \
  | tar -xz -C ~/.claude/skills/

Want the memory used continuously, not just available? integrations/agent-hooks/ wires SessionStart/Stop/PreCompact hooks that resume and save the working context automatically — one global install covers every project. No Rust toolchain? npm i @wiscale/velesdb-memory-node.

Want Claude Code, Claude Desktop, Windsurf, and Devin CLI sharing the same memory instead of one client at a time? scripts/install-memory-daemon.sh runs velesdb-memory as a single local daemon — HTTPS by default, with a natively generated local CA — and wires every client to it.

cargo install velesdb-server velesdb-cli

docker run -d -p 8080:8080 -v velesdb_data:/data --name velesdb \
  ghcr.io/cyberlife-coder/velesdb:latest
curl http://localhost:8080/health

The numbers — every one from a committed harness

No figure below is an estimate from a slide. Each links to the log or script, in this repo, that produced it — rerun them yourself.

The 2.5 % billed saving of the no-screenshots variant is published as prominently as the 21.9 % — the delta is the measured value of the media mechanisms. Honest reading, limitations, and full protocol. Every claim above is CI-guarded by a promise contract that pins the README to its committed sources.

1 · The tri-engine agentic database — VelesQL

One SQL-like statement crosses all three — similarity, relations, and typed filters, no glue code:

MATCH (doc:Document)-[:AUTHORED_BY]->(author:Person)
WHERE similarity(doc.embedding, $question) > 0.8
  AND author.department = 'Engineering'
RETURN author.name, doc.title
ORDER BY similarity() DESC LIMIT 5

[1] Reproduce: python benchmarks/velesdb_benchmark.py --recall (10K/384D, WAL fsync on, i9-14900KF reference machine; Apple-Silicon cross-check in docs/BENCHMARKS.md). [2] Reproduce: cargo bench -p velesdb-core --bench column_filter_benchmark — at 100K rows on the i9-14900KF reference machine: ColumnStore 29.5 us vs JSON scan 3.84 ms. The ratio is hardware-dependent: on Apple Silicon (M5 Pro, 2026-07-20) the JSON scan itself runs ~2.8× faster, so the same bench measures ~50–105x — the ColumnStore's absolute time holds (~27 µs). Full spec: VelesQL · Architecture

2 · The agent memory model — MCP server + Python/Node bindings

Built on the database below it, the memory model is what your agent actually talks to: a local MCP server (velesdb-memory) for any agentic CLI, and the same semantics as Python (pip install velesdb) and Node (@wiscale/velesdb-memory-node) bindings. Two capabilities define it:

why() — the recall that shows its evidence

Most "agent memory" is vector recall: it finds text that looks like your query. VelesDB's MemoryService connects memories with typed links, so it can answer why something happened by walking the graph to context that shares no words with your question — across process restarts, offline, no API key:

from velesdb import MemoryService            # pip install velesdb

mem = MemoryService("./agent_memory")        # a real on-disk store; survives restarts
reason = mem.remember("Robert is recovering from knee surgery")
mem.remember("Booked the aisle seat on Robert's flight", links=[(reason, "because")])

# A *new* process, weeks later, reopens the same store and asks why:
mem.why("why the aisle seat on Robert's flight?")   # walks booking → reason — recall() can't

Memories are permanent by default; forget(id) deletes one, ttl_seconds gives a fact a durable expiry. Every remember auto-stamps the day it was stored (_veles_date, a YYYYMMDD integer — never overwritten if you set it yourself), so dated, recency-weighted recall (recall_fused) works with zero setup. Same wedge in Python, Node (@wiscale/velesdb-memory-node), as a local MCP server, and in-memory in the TypeScript SDK (browser, no server).

The context token optimizer — why() for your token bill

Agents burn most of their budget re-reading redundant context. The memory layer ships a deterministic context compiler (compile_context / compile_transcript over MCP, ContextCompiler in Rust): no LLM, no cloud — duplicates drop, repeated log lines collapse with counts, code / URLs / numbers / negative constraints survive verbatim, and over-budget content becomes a recoverable ctx://source/ handle instead of a silent loss. Every decision carries a stable rule id, a reason, and a risk level. The same request always compiles to the same bytes.

Measured against real provider billing — the same session sent raw vs compiled, graded by a deterministic fact checklist (no LLM judge), raw logs committed verbatim:

* Two turns' grading key was later found defective (both arms scored full marks there; the parity conclusion stands) — disclosure. On the committed 12-turn corpus: 82.5 % real (cl100k) input-token savings, sub-millisecond stateless compiles; over a 36-turn session compiled context grows 1.7× slower, so one session lasts far longer before hitting the window.

Not a transparent proxy, and no automatic indexing — the compiler only compresses what your agent explicitly hands it, never the harness's system prompt; nothing enters recallable memory without an explicit remember. Nothing leaves the machine. The velesdb-context-optimizer skill teaches the workflow — including when not to compress.

Engine details, if you're evaluating seriously

End-to-end search latency (canonical)

Provenance: Intel Core i9-14900KF (x86_64, AVX2), full production path (VelesQL → HNSW → WAL ON → payload hydration). Per-machine figures vary; Apple-Silicon cross-checks and the full methodology live in docs/BENCHMARKS.md.

Quick comparison

Sweet spot: vector + graph + structured filtering in one engine, local-first, lightweight, auditable. Not the best fit (yet): a managed cloud service with a multi-node distributed cluster. Competitor figures are typical public ranges — run your own.

VelesDB Premium — the enterprise control plane

The core engine is source-available and stays that way. VelesDB Premium builds the company-grade layer on top of the same binary, for organizations running agent fleets on sensitive data:

Pricing on quote — contact@wiscale.fr · velesdb.com. Built by Wiscale (France; GDPR and data-sovereignty native).

Ecosystem & surfaces

Use cases in production shape: agent memory that survives restarts · RAG with typed metadata filtering · vector + graph + filters in one query (e-commerce, recommendation) · desktop & mobile AI with zero backend. Worked examples · Demos.

Known limitations — honest boundaries

VelesDB is honest about its scope: the items below are deliberate trade-offs or Enterprise-tracked features, not correctness gaps — the Community Edition is production-ready for single-node, local-first deployments.

Quality bar

• cargo test --workspace — 9k+ tests across Rust, TypeScript, and Python run in CI on every merge; the exact commands live in QUALITY_BAR.md.
• Every marketing number is pinned to its committed source by a CI-enforced promise contract.
• Limitations are published next to the strengths — see above — including the ones we haven't fixed yet.

The story: VelesDB was born in France out of a simple observation — EU data sovereignty is an architectural problem, not a legal one. Hosting on a US provider's EU region is a latency decision, not a sovereignty decision; VelesDB removes the US provider from the chain entirely: one local binary, no API key, no data processor, your jurisdiction. Full story on dev.to · Roadmap · Changelog

Contributing & contact

Contributions welcome — start with CONTRIBUTING.md and the good first issues. Security reports: see SECURITY.md.

License: VelesDB Core License 1.0 (source-available). Premium: commercial license. Contact: contact@wiscale.fr · velesdb.com