Aller au contenu principal
VelesDB Core v3.12.0

Local memory
your agents can explain

Store, connect, and retrieve context in one embedded engine — without a mandatory cloud service, LLM call, or API key.

Install VelesDBGitHub
pip install velesdb
450µs
Search Latency
P50 end-to-end, 10K/384D, WAL on, recall ≥96%
0
Cloud calls
No AI calls and no API keys
~9 MB
Binary Size
Single local-first binary

An engine already shipping in a real product

WPLink embeds VelesDB for local semantic analysis.

WPLink GitHub Rust · Python · Node · WASM

Three databases → one binary

Agent memory should not be an integration project

A conventional agent stack spreads memory across specialized systems. VelesDB keeps semantic, relational, and structured context in one embedded engine.

The conventional 3-database stack

Semantic memory

pgvector

Relationships and episodes

Neo4j

Facts and metadata

PostgreSQL

One VelesDB binary

Semantic memory

Native vector search

Relationships and episodes

Native knowledge graph

Facts and metadata

Column and metadata store

One query language One persistence layer No cross-database consistency work Runs offline
It shows its work

Ask why() — get the evidence trail

Retrieval should be inspectable. VelesDB returns the recalled fact and the typed-link subgraph it can reach, including each node’s hop depth.

  • Trace a response back to stored evidence and relationships.
  • Debug memory quality without reverse-engineering an opaque cloud pipeline.
  • Keep the audit trail beside the memory, on infrastructure you control.
memory.py
memory = MemoryService("./agent.db")

evidence = memory.remember("The signed approval is in PR #42")
memory.remember(
    "Alice approved the launch",
    links=[(evidence, "supported_by")],
)

answer = memory.recall("Who approved launch?")
trail = memory.why("Why was the launch approved?")

# Evidence nodes and typed links
print(trail["nodes"], trail["edges"])

Three foundations for reliable agent memory

An agent-oriented API, one query surface, and an engine that runs close to your data.

Agent Memory SDK

Store and recall semantic, episodic, and procedural memory through agent-oriented APIs, including links and explainability.

VelesQL: SQL + NEAR + MATCH

Filter structured data, search embeddings, and traverse relationships in one readable query language.

Run where the agent runs

Embed in Rust, Python, TypeScript, Tauri, mobile, or WASM deployments with no mandatory cloud service.

Three outcomes, one engine

Build memory where your agent works

From a local prototype to a governed deployment, keep the same explainable memory layer.

Agents that remember and explain

Connect facts, episodes, and constraints, then inspect the evidence trail behind every recall.

  • Semantic, episodic, and procedural memory
  • Hybrid recall with typed links
  • why() evidence trails

AI applications that stay local

Embed the same retrieval layer in desktop, mobile, server, or browser applications.

  • No mandatory cloud service
  • Rust, Python, Node.js, Tauri, and WASM
  • Approximately 9 MB Core binary

Governed memory in production

Keep control of the data and add Premium operations when the deployment requires them.

  • Self-hosted or air-gapped deployment
  • Tenant isolation and audit operations
  • Forensic replay and erasure
Explore every use case

Context Token Compiler + agent skill

Reduce context without losing what matters

After retrieving the right memory, VelesDB compiles logs, documents, and conversations into a deterministic token budget. No LLM or cloud call is used, and every transformation remains auditable and reversible.

82.5%

Measured input-token savings

Real cl100k token count on the committed 12-turn agent-session benchmark.

<1 ms

Stateless compile

0.5 ms mean and 0.7 ms maximum in the published local benchmark.

4

Rust, Python, Node.js, and MCP

The same deterministic compiler across all four documented environments.

A skill guides the agent without blind truncation

The bundled velesdb-context-optimizer skill tells the agent when to compile, preserve, or externalize context.

  • Preserves code, URLs, numbers, and negative constraints verbatim.
  • Externalizes overflow to recoverable ctx://source handles.
  • Checks risk and explains each preserve, collapse, or externalize decision.
  • Explicitly avoids compression for small, legal, security, or exact-format contexts.
Read the context optimizer skill →
const out = await mem.compileContext({
  query: "state of the canary deploy",
  token_budget: 4000,
  fragments: [
    { content: ciLogs, kind: "log" },
    { content: safetyRule, metadata: { verbatim: true } },
  ],
});

out.content;           // context within budget
out.decisions;         // rule, reason, risk per fragment
out.retrievalHandles;  // recoverable ctx://source/...

82.5% is a project-published measurement on a committed 12-turn fixture, not a universal or billed-token guarantee. Stateless latency is hardware-specific; persisted compilation includes local storage and is slower.

One engine versus a split memory stack

This comparison covers architecture directly evidenced by the VelesDB repositories, without making unverifiable claims about third-party products.

Memory propertyVelesDB3-DB stack
PersistenceOne local engineSeparate vector, graph, and SQL stores
Query surfaceVelesQL + memory APIsMultiple APIs and query languages
Explainable recallwhy() evidence trailApplication integration required
Vector + graph + columnsOne binaryThree specialized systems
Offline operationNo mandatory cloud serviceDepends on each selected system
+7.2 pts

HotpotQA

Project benchmark improvement with VelesDB memory.

+9.7 pts

TimeQA

Project benchmark improvement on temporal questions.

+29 pts

Multi-engine

Best reported gain in the reproducible benchmark suite.

Benchmark claims are project-published results; workloads, models, hardware, and methodology matter. Reproduction instructions and raw results are linked from the VelesDB repository.

Install VelesDB in 60 seconds

Choose your runtime and start a first local memory. No cloud account required.

Rust (crates.io)
cargo add velesdb-core

Quick Example

1. Start the server
velesdb-server --data-dir ./my_data
2. Create a collection
curl -X POST localhost:8080/collections \
  -H 'Content-Type: application/json' \
  -d '{"name":"agent_memory","dimension":768,"metric":"cosine"}'
3. Search with VelesQL
curl -X POST localhost:8080/query \
  -H 'Content-Type: application/json' \
  -d '{"query":"SELECT * FROM agent_memory WHERE vector NEAR $v LIMIT 10","params":{"v":[0.1,0.2]}}'
Read the DocumentationView Examples on GitHub

VelesDB Premium v0.7.0

Enterprise Agent Memory Platform

Add governed memory operations, forensic reconstruction, erasure controls, and resilient self-hosted deployment to the VelesDB core.

Compare editions

Governed memory

Policies, audit trails, tenancy, and controls for regulated agent systems.

Forensic replay

Reconstruct the memory state and evidence available at decision time.

Right to erasure

Forget or admin-purge memory content while retaining an auditable skeleton.

VelesDB FAQ

Direct answers about local agent memory, explainability, deployment, and licensing.

What is VelesDB?

VelesDB is an explainable, local-first memory engine for AI agents. It unifies vector search, a knowledge graph, structured columns, text retrieval, and agent-oriented memory APIs in one embedded Rust engine.

How is VelesDB different from Mem0 or Zep?

VelesDB is designed to run inside your infrastructure without mandatory model calls, API keys, or a hosted memory service. Its why() API exposes the evidence trail behind recalled memories. Mem0 and Zep address agent memory with different hosted and orchestration models.

Does VelesDB work offline?

Yes. VelesDB Core can run locally in server, desktop, mobile, and browser or WASM environments. Memory data and retrieval can stay on the device or inside an air-gapped network.

Does VelesDB call an AI model when writing a memory?

No AI call is required by the storage engine. Applications may choose to generate embeddings or enrich memories with their own models, including local models, but VelesDB itself does not require a cloud model or API key per write.

What does why() return?

why() returns the best-matching memory plus the reachable typed-link subgraph: memory nodes with hop depths and the edges connecting them.

Can VelesDB help with EU AI Act traceability?

VelesDB provides evidence trails, audit data, and Premium forensic replay capabilities that can support technical logging and traceability controls. Using VelesDB alone does not make a complete system compliant; governance, risk management, and operating procedures still matter.

What is included in VelesDB Premium?

VelesDB Premium adds enterprise governance, forensic replay, two-level erasure workflows, high availability, and self-hosted or air-gapped operational capabilities. Pricing is provided on request.

How is VelesDB licensed?

VelesDB Core is source-available under the VelesDB Core License 1.0 and can be used at no license cost within its terms. VelesDB Premium is commercially licensed.

Ready to build agentic memory?

Give your agent a memory it can explain

Start with the local-first Core engine today, then add enterprise governance when your deployment requires it.

Install VelesDBView on GitHub
Local installationSource-available CoreZero mandatory cloud calls