v4.0 — 160,000+ vectors indexed live

Your AI forgets everything.
Memory Spine fixes that.

Persistent vector memory for AI agents and developers. Store context, search semantically in under 25ms, and hand off knowledge between agents — all through 32 MCP tools on an open protocol.

Why do AI agents forget context between sessions? Because most systems lack persistent memory for AI agents. Memory Spine is the AI agent memory solution that solves this: a vector memory system for LLM agents that stores, indexes, and retrieves cross-session context in milliseconds. Whether you need multi-agent shared memory, semantic search for AI agents, or MCP memory tools to reduce LLM API costs with memory reuse — Memory Spine delivers. Purpose-built as a vector database for chatbot memory and memory augmented AI agents in 2026, it gives your AI the recall it needs to be truly useful.

Start Free — No Card Required Quickstart Guide →
0
0
0
Free
160,627
Memory Vectors
<25ms
Search Latency
32
MCP Tools
FTS5
Search Engine
Online
Service Status

Try Memory Spine Live — Semantic Search 160K+ Vectors

Type any query and watch Memory Spine return semantic search results in real-time from our production index.

Try:
160,627 memories indexed
~22ms avg search
32 MCP tools

Add Persistent Memory to Your AI Agent in 3 Lines of Code

Python, MCP config, or curl — integrate in minutes with copy-paste examples.

Python
from memory_spine import MemoryClient

memory = MemoryClient("https://your-instance.memoryspine.com")

# Store a memory
memory.store(
    content="User prefers dark mode and Python",
    tags=["preference", "user-profile"]
)

# Search semantically
results = memory.search("user preferences", limit=5)
for r in results:
    print(f"[{r.score:.2f}] {r.text}")
JSON
{
  "mcpServers": {
    "memory-spine": {
      "command": "npx",
      "args": ["-y", "memory-spine-mcp"],
      "env": {
        "MEMORY_SPINE_URL": "https://your-instance.memoryspine.com"
      }
    }
  }
}
Bash
# Store a memory
curl -X POST https://your-instance.memoryspine.com/ingest \
  -H "Content-Type: application/json" \
  -d '{"content": "User prefers dark mode", "tags": ["preference"]}'

# Search memories
curl -X POST https://your-instance.memoryspine.com/search \
  -H "Content-Type: application/json" \
  -d '{"query": "user preferences", "limit": 5}'

Full Quickstart Guide →

Persistent Memory for AI Agents — 32 MCP Tools

Everything your AI needs to remember context across sessions, conversations, and agent handoffs.

Semantic Search Under 25ms

Hybrid search combining SQLite FTS5 keyword matching with vector similarity. Find relevant memories from 160K+ vectors in under 25 milliseconds.

Knowledge Graph Construction

Automatically build relationship graphs between memories. Query connections, find clusters, and traverse knowledge paths for deeper AI understanding.

Memory Pinning & Priority

Pin critical context that must never be forgotten. Priority-ranked memories ensure your AI always has the most important context available first.

Agent Handoff Protocol

Transfer context seamlessly between AI agents. When one agent finishes, the next picks up exactly where it left off with full history.

Timeline & Conversation Tracking

Query memories by time range, track conversation turns, and replay interaction history. Built-in temporal intelligence for context-aware responses.

32 MCP Protocol Tools

Store, search, recall, pin, tag, consolidate, batch, cluster, timeline, handoff, and more. Every memory operation your AI agent needs, one protocol call away.

How to Give Your AI Persistent Memory

Three steps. No infrastructure to manage. Works with any MCP-compatible model.

Connect via MCP

Add Memory Spine as an MCP server in your AI agent configuration. Compatible with Claude, GPT, Gemini, and any MCP-enabled framework.

Store & Tag Memories

Your AI stores context as tagged memory vectors. Each memory gets semantic embeddings for similarity search and FTS5 indexing for keyword matching.

Search & Recall

When your AI needs context, it searches by semantic similarity, keyword, tag, or time range. Results return in under 25ms with relevance scoring.

Real MCP Tool Calls

Memory Spine uses the open Model Context Protocol — the same standard used by Claude, Cursor, and Windsurf. No proprietary SDK. No vendor lock-in.

Your AI agent calls MCP tools directly. Here are real examples from production:

  • memory_store — persist any context with tags
  • memory_search — semantic + keyword hybrid search
  • memory_pin — pin critical context by key
  • memory_timeline — query memories by time range
  • knowledge_graph_build — construct relationship graphs
  • agent_handoff — transfer context between agents
See All 32 Tools →
  MCP Tool Calls
// Store a memory with tags
memory_store({
  "content": "User prefers dark theme and TypeScript",
  "tags": ["preferences", "user-context"]
})
// → {id: "mem-2847", vector_count: 160628}

// Search memories semantically
memory_search({
  "query": "what does the user prefer",
  "limit": 5
})
// → Results in ~22ms, ranked by relevance

// Pin critical context by key
memory_pin({
  "key": "system-config",
  "content": "Project uses TypeScript and React"
})

// Hand off context to another agent
agent_handoff({
  "target_agent": "code-reviewer",
  "include_recent": 20
})

Why Choose Memory Spine for AI Agent Memory?

Persistent Memory for AI Agents That Lasts

Most AI agents lose all context when a session ends. Memory Spine gives AI agents persistent memory that survives across sessions, conversations, and even agent handoffs. Your AI remembers what matters.

Reduce LLM API Costs with Intelligent Memory

Stop re-sending the same context to LLMs every call. Memory Spine’s semantic search retrieves only the relevant memories your agent needs, cutting token usage and reducing LLM API costs dramatically.

Multi-Agent Shared Memory Made Simple

Building multi-agent systems? Memory Spine enables multi-agent shared memory with built-in agent handoff protocols, knowledge graphs, and cross-session AI agent context that every agent in your system can access.

32 MCP Tools — No Custom Integration Needed

Memory Spine implements 32 native MCP memory tools that any compatible AI model can call directly. No SDK wrappers, no custom code — just configure and go. Works with Claude, GPT, Gemini, and open-source models.

Learn How to Add Memory to Your AI Agent →

Built for Every AI Memory Use Case

From chatbots to autonomous agents, any AI that needs to remember.

Autonomous AI Agents

Agents that work across sessions need persistent memory to avoid repeating work, remember decisions, and build on prior knowledge.

Chatbots & Assistants

Give your chatbot long-term memory of user preferences, past conversations, and resolved issues. No more “I don’t have context for that.”

Code Copilots

Remember codebase patterns, user coding style, project architecture, and debugging history. Your copilot gets smarter with every session.

RAG-Augmented Systems

Combine retrieval-augmented generation with persistent memory. Your RAG system remembers what worked, what didn’t, and adapts over time.

Multi-Agent Orchestration

When multiple agents collaborate, Memory Spine provides shared context. Agent handoff protocol ensures seamless knowledge transfer between specialists.

Research & Analysis

Long-running research tasks need to accumulate findings. Memory Spine stores, tags, and clusters results for progressive synthesis.

Memory Spine vs Vector Databases: Built for AI Agents

Memory Spine isn’t another vector DB. It’s purpose-built for AI agent memory with MCP protocol support.

FeatureMemory SpinePineconeChromaDBpgvector
PurposeAI Agent MemoryVector DBEmbedding DBPG Extension
MCP Protocol✓ 32 tools✗✗✗
Agent Handoff✓ Built-in✗✗✗
Memory Pinning✓✗✗✗
Knowledge Graphs✓✗✗✗
Conversation Tracking✓✗✗✗
Memory Consolidation✓✗✗✗
Search Speed<25ms~50ms~100msvaries
Free Tier✓ 5K vectors✓✓✓
Self-Hosted✓✗✓✓
vs Pinecone vs ChromaDB vs Weaviate vs Qdrant vs pgvector

See Detailed Comparisons →

AI Memory Pricing — Included with ChaozCode

Pick the vector limit you need. All plans include full MCP tool access and semantic search.

Free
$0/mo
  • 5K memory vectors
  • Core MCP tools
  • FTS5 search
  • Pin & recall
  • No credit card
Get Started Free
Indie
$19/mo
  • 25K memory vectors
  • All 32 MCP tools
  • Knowledge graphs
  • Analytics dashboard
  • Priority support
Choose Indie
Developer
$49/mo
  • 100K memory vectors
  • Batch operations
  • Memory consolidation
  • 5 parallel agents
  • Advanced clustering
Choose Developer
Master
$99/mo
  • 250K memory vectors
  • Everything in Dev
  • Custom integrations
  • SLA guarantee
  • Dedicated support
Choose Master

14-day money-back guarantee on all paid plans. Compare all ChaozCode plans →

Running in Production, Not a Proof of Concept

Memory Spine runs 24/7 as the persistent context layer of the ChaozCode platform — powering 276 specialized AI agents, task routing, and multi-agent orchestration in production.

160,627
Vectors Stored
v4.0
Production Version
276
Connected Agents
99.9%
Uptime

Frequently Asked Questions About AI Agent Memory

Everything developers ask about persistent AI memory and Memory Spine.

Memory Spine is a persistent vector memory system for AI agents and developers. It lets AI agents store, search, and recall context across sessions using 32 MCP (Model Context Protocol) tools with sub-25ms semantic search latency. It runs as part of the ChaozCode platform. Get started with the quickstart guide →

Memory Spine stores memories as vectors with full-text search indexing (FTS5). When an AI agent needs context, it searches by semantic similarity or keyword match and retrieves relevant memories in under 25ms. Memories persist across sessions, conversations, and agent handoffs — your AI never forgets. Try it live in the playground above →

MCP is an open protocol that lets AI models interact with external tools and data sources. Created by Anthropic, it is supported by Claude, Cursor, Windsurf, and a growing ecosystem. Memory Spine implements 32 MCP tools for memory operations including store, search, recall, pin, tag, consolidate, timeline, and agent handoff. See MCP setup instructions →

Yes. The free tier includes 5,000 memory vectors and core MCP tools at no cost, no credit card required. Paid plans start at $19/month for 25K vectors with the full 32-tool suite including knowledge graphs, analytics, and priority support. See all pricing tiers →

Sub-25ms on 160,000+ vectors. Memory Spine uses a hybrid approach: SQLite FTS5 for keyword matching combined with vector similarity search. Both full-text and semantic queries return results in under 25 milliseconds in production. Try a live search in the playground →

Yes. Memory Spine uses the open MCP protocol, making it compatible with any AI model that supports MCP tools — including Claude, GPT, Gemini, LLaMA, and open-source models. It also works with agent frameworks like LangChain, AutoGPT, CrewAI, and custom agent systems.

Memory Spine is purpose-built for AI agent memory, not general vector storage. It includes agent-specific features: memory pinning, knowledge graph construction, conversation tracking, agent handoff context, memory consolidation, and timeline queries. It also combines FTS5 keyword search with vector similarity in a single system — no separate infrastructure needed. See the full comparison →

Stop Losing Context Between AI Sessions

Memory Spine is free to start. Give your AI agents the persistent memory they have been missing.

Start Free Today Quickstart Guide →