The associative memory layer for AI agents

Memory that
thinks
not retrieves.

Local-first vector memory with a 4-layer associative graph. Your agent remembers why things are connected, when things changed, and which memories matter most.

MEMORY_GRAPH // LIVE
ROOT SEMANTIC CAUSAL TEMPORAL ENTITY MEM_001–084 MEM_085–147 MEM_148–201 MEM_202–247 SEMANTIC CAUSAL TEMPORAL ENTITY 325 184 201 118 nodes · similarity nodes · cause→effect nodes · before→after nodes · co-occurrence TOTAL EDGES 7180 · REM 11 · STATUS ACTIVE _
The Problem
Standard RAG is amnesia with extra steps.
WITHOUT VEKTOR // SESSION AMNESIA
SESSION_001
"User prefers Python. Working on data pipeline."
SESSION_002
✗ MEMORY WIPED — context lost
SESSION_003
✗ MEMORY WIPED — starting over again
SESSION_N
✗ Agent has no idea who you are
WITH VEKTOR // ASSOCIATIVE GRAPH
SESSION_001
"User prefers Python. Working on data pipeline."
→ STORED · AUDN: ADD
SESSION_002
"Recalled: Python preference, pipeline context"
→ GRAPH UPDATED +3 NODES +7 EDGES
SESSION_003
"Full context available. REM compressed 50→3."
→ GRAPH: 247 NODES · 7,180 EDGES
SESSION_N
→ COMPLETE ASSOCIATIVE MEMORY INTACT
Architecture
Raw input → AUDN curation → persistent graph.
01
INPUT_LAYER

Raw Input

Conversation turns, tool outputs, observations. Any unstructured agent context fed in as text.

CONVERSATIONTOOL_OUTPUTOBSERVATION
02
AUDN_LAYER

AUDN Curation

Every memory is evaluated: ADD new info, UPDATE existing, DELETE contradictions, or NO_OP if already known. Zero duplicates.

ADDUPDATEDELETENO_OP
03
MAGMA_LAYER

MAGMA Graph

Persisted across 4 graph types in SQLite. Survives all session resets. REM cycle compresses while idle.

SEMANTICCAUSALTEMPORALENTITY
MAGMA Graph Types
Four layers. One mind.
LAYER_01

Semantic

Similarity between memories. Finds related concepts across your full context history.

LAYER_02

Causal

Cause → Effect relationships. Understands why things happened, not just what.

LAYER_03
before during after

Temporal

Before → After sequences. Tracks how knowledge evolves and decays over time.

LAYER_04

Entity

Named entity co-occurrence. Connects people, projects, and events automatically.

The Core Difference
Two paradigms. One winner.

Most vector stores are passive. They store what you put in and return what you ask for. VEKTOR is an active memory layer — it evolves, curates, and reasons about what your agent should remember.

PASSIVE STORE

The File Cabinet

Standard RAG vector stores

  • Stores vectors. Returns nearest neighbors. That's it.
  • No understanding of relationships between memories
  • Grows forever — no curation, no decay, no prioritization
  • Requires you to engineer retrieval logic from scratch
  • Cloud dependency, monthly billing, data leaves your server
  • Retrieves the past. Cannot reason about the present.
MENTAL MODEL A drawer full of notes. You ask, it searches. Nothing more.
VS
ACTIVE MEMORY LAYER

The State Machine

VEKTOR Memory

  • MAGMA graph maps relationships: semantic, causal, temporal, entity
  • Memories evolve — importance scores decay, conflicts resolve
  • Auto-curates: duplicate collapse, contradiction detection, pruning
  • Retrieval is intelligent — returns what's relevant now, not just similar
  • Local-first SQLite. One-time purchase. Your data, your server.
  • Knows what the agent learned, forgot, and should prioritize next.
MENTAL MODEL A mind that thinks about what it knows — and gets smarter over time.
Skeptical devs ask: "Why not just use a vector store with a wrapper?" Because a vector store wrapper gives your agent a search bar, not a memory.
Core Systems
Built different. By design.
MAGMA · Live Retrieval
Memory recalls in real time
Cosine similarity across your full associative graph. Ranked, scored, ready.
0.97
user prefers TypeScript over JavaScript
2m ago
0.91
meeting with Sarah — Friday 3pm
14m ago
0.88
project: data pipeline · Python
1h ago
0.74
active: 247 archived: 388 edges: 7180
3h ago
0.61
dreams: 11 — REM last run 04:12
1d ago
REM Compression
Gets smarter while idle
7-phase dream cycle. up to 50:1 fragment synthesis. Noise dramatically reduced. Core signal retained.
BEFORE REM 50 RAW FRAGMENTS
↓  REM CYCLE  ·  7 PHASES  ↓
AFTER REM 1 CORE INSIGHT
~98% NOISE REMOVED
CORE SIGNAL RETAINED
50:1
COMPRESSION
RATIO
Embedding Space · 2D
384-dim vectors
SDK · npm install vektor-slipstream
3 core methods. Everything else builds on them.
import { createMemory } from 'vektor-slipstream';
 
const memory = await createMemory({ provider: 'gemini', apiKey, agentId: 'my-agent' });
await memory.remember("User prefers TypeScript over JavaScript");
const results = await memory.recall("coding preferences");
// → [{ id, content, summary, importance, score }]
const graph = await memory.graph("TypeScript", { hops: 2 });
const delta = await memory.delta("project decisions", 7);
const brief = await memory.briefing(); // morning summary
AUDN Loop · Live
Ingest
raw input
Embed
local vectors
AUDN
add/update/delete
Index
HNSW graph
Retrieve
k=5 · cos sim
REM Dream
up to 50:1 fragment synthesis
Reason
LLM context
Targeted Recall · AUDN clean
Zero contradictions
AUDN keeps the graph clean. Every recall is precise.
what are the user's coding preferences?
user prefers TypeScript over JavaScript0.97
project uses Python for data pipelines0.88
meeting with Sarah — Friday 3pm0.31
REM cycle last run 04:12 UTC0.18
Why not SaaS?
You own
your memory.
Your agent's decisions, preferences, strategies — your memory graph lives on your machine. Not ours. SQLite file. You own it. Forever. LLM inference queries are processed by your chosen provider per their privacy policy.
Integrations
Works with every stack.

LangChain

Drop-in memory layer for LangChain agents. recall() returns context, remember() stores every turn. v1 + v2 adapters included.

OpenAI Agents SDK

Wrap your OpenAI agent loop with persistent memory. Inject recalled context directly into system prompt. GPT-4o and o-series models supported.

Claude MCP Server

Full MCP server module — vektor_recall, vektor_store, vektor_graph, vektor_delta tools. Connect Claude Desktop to persistent memory in minutes.

Gemini / Groq / Ollama

Provider-agnostic. Pass gemini, openai, groq, or ollama as provider. Key pooling for Gemini — waterfall rotation across up to 9 API keys, zero rate-limit downtime.

Mistral MCP

vektor_memoire HTTP tool — works with Le Chat and Mistral API agents. Local bridge on localhost:3847. Run mistral-setup.js to activate. French-first sovereign memory.

Integration
Drop into any Node.js agent in minutes.
QUICKSTARTjavascript
// 1. Install
// npm install vektor-slipstream

import { createMemory } from 'vektor-slipstream';

// 2. Initialise
const memory = await createMemory({
  provider: 'gemini',
  apiKey:   process.env.GEMINI_API_KEY,
  agentId:  'my-agent',
  dbPath:   './my-agent.db',
});

// 3. Remember — AUDN decides ADD/UPDATE/DELETE
await memory.remember("User prefers TypeScript");

// 4. Recall
const ctx = await memory.recall("coding preferences");

// 5. Traverse the graph
const g = await memory.graph("TypeScript", { hops: 2 });

// 6. What changed in 7 days?
const d = await memory.delta("architecture", 7);
01

No external services

Pure SQLite. No cloud dependency, no API keys for memory. Your memory graph never leaves your server. LLM providers process queries per their own privacy policies.

02

Model agnostic

Gemini, OpenAI, Groq, Ollama. Switch provider with one config change. Key pooling for Gemini — waterfall rotation across up to 9 keys.

03

AUDN keeps it clean

Automatic curation loop prevents contradictions and duplicates. The graph stays consistent without any manual management.

04

REM Cycle

Background process compresses 50 fragments into 3 core insights. Runs while your agent is idle. node rem.js or trigger via memory.dream().

Built on Research
Implementation original. Concepts peer-reviewed.
READ FULL RESEARCH BREAKDOWN →
// FULL PRODUCT SPECS

Privacy. Pricing.
Everything under the hood.

Zero-knowledge architecture · Sovereign identity · Slipstream · Cloak · Pricing

SEE FULL PRODUCT → PRICING →