Persistent memory API for AI agents. Store and recall across runs.
One POST to remember. One GET to recall. Persistent semantic memory for every agent — no vector DB setup required.
const res = await fetch('https://api.memstore.dev /v1/memory/remember', { method: 'POST', headers: { 'Authorization': `Bearer ${apiKey}`, 'Content-Type': 'application/json' }, body: JSON.stringify({ content: 'User prefers dark mode, uses React, timezone UTC-5', session: 'user_8821', ttl: 2592000 // 30 days }) });
// GET /v1/memory/recall?q=user+preferences // Response: { "memories": [{ "id": "mem_k9x2...", "content": "User prefers dark mode, uses React...", "score": 0.97, "session": "user_8821", "age": "2 hours ago" }], "tokens_used": 142 }
Copy your key and run these in your terminal.
Try it in 60 seconds
Ready for production? Upgrade to Starter →
Every session starts from zero. Your agent has no idea what the user said last week, what decisions were made, or what it already tried. That's not intelligence — that's amnesia.
Agents ask users the same things over and over. Every run re-discovers what should have been remembered.
Dumping entire conversation history into every prompt is expensive, slow, and hits context limits fast.
Without real memory, agents make up plausible-sounding facts about past interactions. Users notice.
No API key needed. Select a memory, store it, then recall it semantically.
Every run starts with full context. No re-explaining. No hallucinating past decisions.
Persistent memory for AI agents is the ability to store facts, decisions, and context outside the agent runtime and retrieve them semantically on future runs. Unlike context window stuffing, persistent memory scales across sessions, reduces token costs, and gives agents long-term recall without manual state management.
POST any text — facts, decisions, user preferences, tool outputs. Memstore embeds it automatically and indexes it for semantic search.
GET with a natural language query. Returns the most relevant memories ranked by semantic similarity — not just keyword matches.
Every agent run starts with full context. No loops, no repeated work, no hallucinating past decisions. Your agent gets smarter over time.
Not a vector DB tutorial. A production-grade memory layer with agent-native primitives.
pgvector cosine similarity search returns the right memories even when the query wording differs. Agents don't need exact matches to remember.
Tag memories by user, task, or run. Recall across sessions or within a single scope. No cross-contamination between different agent contexts.
Set time-to-live on any memory. Short-lived task context expires automatically. Long-term user facts persist forever. You control the lifecycle.
Every error response includes a machine-readable code, human-readable message, and a suggested fix. Agents retry correctly without human intervention.
Pro tier automatically compresses aging memories into dense summaries. Slash token costs by 40–50% without losing long-term context.
Fire webhooks when memories are created, updated, or expire. Sync agent state across services or trigger downstream actions when context changes.
From customer-facing bots to internal automation pipelines.
Remember each customer's history, past tickets, and preferences. Resolve issues faster without making customers repeat themselves every time.
Track every prospect interaction, objection, and follow-up. Agents remember deal context across weeks of back-and-forth.
Build assistants that genuinely know the user — their preferences, projects, habits, and goals — getting more useful with every interaction.
Share state across agent handoffs. One agent stores a decision; another recalls it 10 steps later — no message-passing spaghetti.
Free tier · No credit card · First key in 30 seconds
No SDK required. Any language that can make an HTTP request works with Memstore.
Rolling your own agent memory sounds like a weekend project. It isn't.
Every alternative requires weeks of setup, ongoing maintenance, and specialized knowledge.
| Feature | Self-hosted pgvector | Pinecone / Weaviate | Memstore |
|---|---|---|---|
| Setup time | 2–4 hours | ~1 hour | Under 5 minutes |
| Embedding logic | Manual | Manual | Automatic |
| Maintenance | High | Medium | None |
| API style | SQL + drivers | Heavy SDK | Simple REST |
| Cost to start | $25+/mo | Usage + fees | Free |
Five endpoints. Bearer auth. JSON in, JSON out. Structured errors your agent can actually act on. No SDK required — though we have one.
-- memories table (Supabase pgvector) CREATE TABLE memories ( id uuid PRIMARY KEY, agent_id uuid REFERENCES agents, session text, content text NOT NULL, embedding vector(1536), metadata jsonb, ttl timestamptz, created_at timestamptz DEFAULT now() ); -- cosine similarity index CREATE INDEX ON memories USING ivfflat (embedding vector_cosine_ops) WITH (lists = 100);
Pay for what your agents use. Free tier generous enough to build your first production agent.
1 operation = 1 store or recall call. Most agent runs use 20–100 ops.
Need more? Upgrade to Starter →
Use the same email as your API key signup
Use the same email as your API key signup
Agent memory contains sensitive data. Memstore is built with privacy as a default.
All memories are encrypted at rest and transmitted over TLS. Your data never moves over unencrypted channels.
Every API key operates in a fully isolated namespace. Your agent's memories are never mixed with other accounts or used to train any models.
We never use your stored memories or queries to train models. Export or delete your data at any time via the API.
Rotate or revoke API keys at any time. Each key is scoped to a single agent namespace with no cross-account access.
Free tier. No credit card. First API key in 30 seconds.
Get your free API key →