Open Source β€” MIT Licensed

Memory That Thinks

A graph + vector hybrid memory system for AI agents. Memories decay like human recall, form semantic relationships, and get smarter over time β€” not just bigger.

PostgreSQL
+
Apache AGE
+
pgvector
+
FastAPI

AI Memory Is Broken

Current approaches force a choice between simplicity and intelligence. Vex Memory gives you both.

Flat Files Don't Scale

JSON dumps and markdown logs grow linearly. No relationships, no decay, no way to find what matters when you have 10,000+ memories.

Vector Search Alone Misses Context

Embedding similarity finds related text, but can't traverse relationships. "What caused this decision?" requires graph traversal, not cosine distance.

Everything Stays Forever

Human memory forgets unimportant things. Most AI systems don't. Without temporal decay, noise drowns out signal as context windows fill.

Built on Proven Infrastructure

One PostgreSQL instance. Three powerful extensions. No external dependencies.

Your AI AgentOpenClaw / LangChainor any REST clientRESTFastAPI :8000Store & QueryContext EndpointsEntity ExtractionConsolidationGraph TraversalSQLPostgreSQL 16pgvector384-dim embeddingsApache AGEProperty graphmemories Β· entities Β· relationships Β· feedbackTemporal DecayEbbinghaus curvesConsolidationSleep-cycle mergingOllama (all-minilm)Local embeddings β€” optional

Everything Your Agent Needs to Remember

Not just storage β€” a cognitive memory layer that models how humans actually recall information.

πŸ•ΈοΈ

Graph Relationships

Apache AGE property graph connects memories with typed edges β€” CAUSED_BY, SUPPORTS, CONTRADICTS. Traverse 2+ hops to find context vector search misses.

πŸ”

Semantic Vector Search

pgvector embeddings (384-dim) enable similarity search across your entire memory store. Find relevant context even when exact words don't match.

⏳

Temporal Memory Decay

Ebbinghaus-inspired forgetting curves with 30-day half-life. Frequently accessed memories resist decay. Importance adjusts automatically.

πŸ€–

Auto Entity Extraction

NLP pipeline (spaCy NER + pattern matching) extracts decisions, events, facts, and learnings from raw text β€” no LLM call needed.

😴

Sleep-Cycle Consolidation

Clusters semantically similar memories, creates summaries, and lowers importance of originals. Like your brain during sleep.

⚑

REST API (FastAPI)

Full CRUD, semantic query, context endpoints for agent integration, graph traversal, timeline queries, and feedback loops β€” all over HTTP.

🐳

Docker One-Command Deploy

git clone, docker compose up, done. PostgreSQL, AGE, pgvector, and the API all configured. Production-ready in 60 seconds.

πŸ“Š

Built-in Dashboard

Real-time web UI showing memory stats, types, emotions, entity graphs, and recent activity. No extra setup needed.

How It Works

Three steps from raw text to intelligent recall.

01

Store

Memories go in with context

Send raw text or structured data to the API. Vex automatically generates embeddings, extracts entities (people, decisions, events), tags emotions, and assigns importance scores.

POST /memories
{
"content": "We decided to use
PostgreSQL for the backend",
"type": "decision"
}
02

Connect

Entities form a knowledge graph

Extracted entities are linked in Apache AGE. "PostgreSQL" connects to "backend" via PART_OF. Similar memories auto-link above cosine 0.7. You can traverse relationships to find causal chains.

PostgreSQL
PART_OF
Backend
CAUSED_BY
Decision
03

Recall

Intelligent retrieval when you need it

Query with natural language. Vex combines vector similarity, graph traversal, temporal relevance, and importance weighting to return exactly the context your agent needs β€” not just similar text.

POST /context
{
"message": "What did we decide
about the database?"
}
β†’ Returns decision + graph context

Running in 60 Seconds

Three commands. That's it.

terminal
# Clone the repo
$ git clone https://github.com/0x000NULL/vex-memory.git
$ cd vex-memory
# Start everything
$ cp .env.example .env
$ docker compose up -d
βœ“ PostgreSQL 16 + AGE + pgvector ... ready
βœ“ FastAPI server .................. ready
βœ“ Dashboard ....................... ready
# Store your first memory
$ curl -X POST http://localhost:8000/memories \
-H "Content-Type: application/json" \
-d '{"content": "Vex Memory is running!", "type": "event"}'
{"id": "a1b2c3...", "status": "created", "entities_extracted": 1}
# Query it back
$ curl -X POST http://localhost:8000/query \
-d '{"query": "What just happened?"}'
β†’ Vex Memory is running! (score: 0.94)

Dashboard available at localhost:8000/dashboard β€’ API docs at localhost:8000/docs

Built for Performance

Real numbers from a real system. Currently running with 191 memories and 1,250+ indexed entities.

<15ms
Semantic Query Latency
pgvector HNSW index on 384-dim embeddings
100K+
Memory Capacity
PostgreSQL scales with your hardware
3.2Γ—
Better Recall vs Flat Files
Graph + vector hybrid retrieval
60s
Time to Deploy
docker compose up and you're live
🧠

Open Source. MIT Licensed. Forever.

Vex Memory is free to use, modify, and distribute. Built in public, maintained by developers who believe AI memory should be a shared primitive β€” not a proprietary lock-in.

GitHub starsMIT LicensePRs Welcome