AI Memory PlatformBeta: Free Access

Claude forgets. Gemini forgets. Codex forgets. Stompy doesn't.

Persistent memory for Claude, Gemini, Codex, Cursor — and whatever you switch to next.

🎉 Free during beta — limited spots available

Works with every major AI coding tool

Claude Desktop

Claude Code

Gemini CLI

Codex CLI

Cursor

N8N

Cline

MCP, CLI, or REST API — if your AI can talk, Stompy can remember

Monday morning

You open Claude. Fresh context window. Blank slate.

You start typing:

"So, I'm building an API for a task management system called TaskFlow. It uses Hono on Cloudflare Workers, with Neon PostgreSQL, and we're doing OAuth via Scalekit. The auth flow is..."

You've explained this fourteen times this month.

And that's just Claude. You explained it to Gemini yesterday. To Cursor the day before. Three tools, three blank slates, same project.

Every one of them nods politely. Processes your words. Pretends this is all new information.

It isn't.

Every new conversation, you're back to zero.

That architectural decision from two weeks ago? Gone.

The API naming convention you settled on? Forgotten.

Your preference for tabs over spaces? (We don't judge.)

You spend the first ten minutes of every session rebuilding context that should already exist.

Claude is brilliant. But Claude has the long-term memory of a caffeinated goldfish.

What if it actually remembered?

Meet Stompy. An elephant. (We're not being subtle about the metaphor.)

Stompy is an AI memory system — an MCP server that gives Claude persistent, searchable, organized knowledge that survives the reset.

Not a chat history dump.Not a context window hack.

Actual memory. Structured. Versioned. Yours.

See It In Action

60 seconds to understand Stompy

Watch how developers use Stompy to give Claude persistent memory across sessions.

Demo video coming soon

We're putting together a quick walkthrough. In the meantime, join the waitlist to be first to see it.

60s

Quick overview

Key features

Line setup

lock_context

Storing what matters.

You decide what's worth remembering. API specs, architecture decisions, rules that must never be broken.

AI Session

> lock_context(
    topic="taskflow-api-architecture",
    content="TaskFlow uses Hono on Cloudflare Workers...",
    priority="important",
    tags="api,architecture,taskflow"
  )
✓ Locked as v1.0 (important priority)

Stompy stores it as an immutable versioned snapshot. Change something later? That's a new version. The original stays intact.

Under the hood

Delta evaluation — Before saving anything new, Stompy compares it against everything you've already stored. If 90% of your content already exists in your knowledge base, Stompy flags it as redundant instead of cluttering your memory with near-duplicates.
Embedding generation — Every context gets converted to a dense vector representation for semantic search.
Priority classification — Mark contexts as always_check (critical), important, or reference.

context_search

Finding it again.

Two months later, you need that architecture decision. You don't remember what you called it.

Semantic Search

> context_search("taskflow database setup")
Found 3 contexts (semantic match):
  • taskflow-api-architecture (94% match)
  • database-connection-pool (87% match)
  • neon-postgres-setup (82% match)

Stompy searches semantically. Even though you stored it as "api-architecture," searching for "database setup" finds it — because the content mentions PostgreSQL.

Under the hood

Hybrid search — Tries semantic similarity first (cosine distance on embeddings), falls back to keyword matching.
Priority-aware results — always_check contexts surface first. Critical rules don't get buried.
Violation detection — Check if your query might violate stored MUST/NEVER rules.

Stompy searching through notes and memories

project_create

One brain, many projects.

You're not just working on TaskFlow. There's that article publishing system. The Stompy brand work. That side project you swear you'll finish. Claude stores context in the morning. Gemini recalls it after lunch. Same project, same memory.

Project Isolation

> project_create("articles")
✓ Created project "articles"

> lock_context(content="...", topic="style-guide", project="articles")
✓ Locked in articles project

> context_search("auth", project="taskflow")
✓ Searching taskflow — articles data untouched

Each project gets isolated memory. Every tool accepts a `project` parameter — no switching needed. TaskFlow's API conventions don't leak into your personal blog.

Under the hood

Schema isolation — Each project is a separate PostgreSQL schema. Hard walls, not fuzzy boundaries.
Direct project param — Every tool accepts project="name". Claude auto-routes to the right schema.
Cross-project search — When you need it, search across everything. When you don't, stay focused.

ticket

Track everything.

Feature requests, bug reports, architecture decisions — create tickets right from your conversation. View the board. Search across tasks. No context switching to external tools.

Project Tracking

> ticket(action="create", title="Migrate to JWT RS256", priority="high")
✓ Created TKT-42: Migrate to JWT RS256

> ticket_board(view="summary")
┌─────────┬────────────┬──────┐
│ Backlog │ In Progress│ Done │
├─────────┼────────────┼──────┤
│ TKT-42  │ TKT-38     │ TKT-35│
│ TKT-41  │            │ TKT-34│
└─────────┴────────────┴──────┘

Your tickets live alongside your memory. Claude sees both your knowledge base and your task board.

Under the hood

Full lifecycle — Create, update, close, search tickets. Track status, priority, and assignments.
Kanban views — Summary and detailed board views grouped by status. See what's in progress at a glance.
Linked to memory — Tickets reference contexts. Claude connects tasks to the knowledge behind them.

detect_conflicts

Catching contradictions.

You stored "API responses must use camelCase" last month. Today you stored "All JSON fields should be snake_case."

Conflict Detection

> detect_conflicts(scope="recent")
⚠️ Conflict detected:
  Context A: "api-response-format" says camelCase
  Context B: "json-standards" says snake_case

  Confidence: 94% contradiction

Use resolve_conflict() to choose which to keep

Stompy notices.

Under the hood

Natural Language Inference — Uses NLI models to detect semantic contradictions, not just keyword collisions.
Resolution workflow — Review contradictions, choose which to keep, merge if appropriate.
Prevents knowledge rot — Over time, knowledge bases accumulate inconsistencies. Stompy catches them.

recall_context

Instant recall.

You know exactly what you need. Just ask for it by name.

Direct Recall

> recall_context("auth-decisions")
📌 auth-decisions v2.1
"JWT with refresh tokens. 15min access, 7d refresh.
MUST use httpOnly cookies. NEVER expose in localStorage."

No digging through old chats. No re-making decisions you already made. It's all there.

Under the hood

Version history — Every context tracks its versions. Roll back to v1.0 if the latest doesn't work.
Preview mode — Get a quick summary without loading full content. Saves tokens on large contexts.

How It Works

Add One Line. Get Persistent Memory.

Stompy is an AI memory platform. The fastest path: add one config line to any MCP client. Also available via CLI and REST API.

Add to Claude Desktop Config

Open your Claude Desktop config file and add Stompy as an MCP server. That's it—your AI now has access to all 28 memory tools.

Location: ~/Library/Application Support/Claude/claude_desktop_config.json

Using Gemini CLI, Codex, or another tool? Same API key, different path. See all integration paths →

claude_desktop_config.json

{
  "mcpServers": {
    "stompy": {
      "command": "npx",
      "args": ["stompy-mcp"],
      "env": {
        "STOMPY_API_KEY": "your-api-key"
      }
    }
  }
}

Claude Recalls Your Context

When you start a conversation, Claude automatically searches your stored contexts. It finds relevant architecture decisions, rules, and specifications without you having to re-explain.

project param scopes any tool to a specific project
context_search finds relevant stored knowledge
recall_context retrieves specific topics

Example Conversation

You: "Let's work on the auth system for my SaaS app"

Claude: I'll check your project context.
→ context_search("authentication", project="my-saas")

Found 3 relevant contexts:
• auth_architecture (v1.2) - JWT-based auth with refresh tokens
• security_rules (v1.0) - MUST hash passwords with bcrypt
• api_endpoints (v1.1) - POST /auth/login, POST /auth/refresh

Based on your existing architecture, I'll implement the login
endpoint using JWT with the 15-minute expiry you specified...

Store New Decisions

As you make decisions during your conversation, Claude can lock them as versioned contexts. Delta evaluation ensures only genuinely new information gets stored.

lock_context creates immutable, versioned snapshots
Priority levels always_check, important, reference
Tags for organization and filtering

Storing Context

You: "Store our new rate limiting rules"

Claude: I'll lock this as a versioned context.
→ lock_context(
    content="Rate limit: 100 req/min for free tier,
             1000 req/min for pro. Use Redis sliding window.",
    topic="rate_limiting_rules",
    priority="important",
    tags="api,security,infrastructure"
  )

✓ Stored as rate_limiting_rules v1.0
  Priority: important
  Delta: 100% novel content

Search by Meaning

Weeks later, search your knowledge base semantically. VoyageAI embeddings find relevant content even when you don't remember exact wording.

Semantic search via VoyageAI embeddings
Keyword fallback for exact matches
Similarity scores show match quality

Semantic Search

You: "What did we decide about error handling?"

Claude: Let me search your knowledge base.
→ context_search("error handling", use_semantic=True)

Found 2 matches:
1. error_handling_patterns (92% match)
   "Use Result<T, E> pattern. Never throw in async code.
    Log errors with correlation IDs..."

2. api_error_responses (78% match)
   "Return RFC 7807 Problem Details format.
    Include request_id in all error responses..."

Beta: Free for Early Users

Simple, Transparent Pricing

Choose the plan that fits your usage. All plans include core Stompy features.

MonthlyAnnualSave 33%

Free

For casual users & evaluation

$0.00/mo

Usage Limits

10 hrs/month active time
512MB storage

Unlimited projects
Semantic search
Document ingestion
Community support

Pro

For regular users & hobbyists

$4.99/mo

Billed annually ($60/year)

Usage Limits

75 hrs/month (~2.5 hrs/day)
10GB storage

Everything in Free
Priority support
Advanced analytics
API access

Power

For heavy users & developers

$19.99/mo

Billed annually ($240/year)

Usage Limits

300 hrs/month (~10 hrs/day)
50GB storage

Everything in Pro
Extended usage hours
Bulk operations
Priority queue

Enterprise

For teams & organizations

Custom

Usage Limits

Unlimited active time
Dedicated compute

Everything in Power
Team collaboration
SSO & SAML
Dedicated support

All plans include

PostgreSQL databaseS3 document storageVoyageAI embeddingsOpenRouter Vision

We'll email you when it's ready. We won't email you about anything else.

FAQ

Frequently Asked Questions

Everything you need to know about Stompy

Getting Started

MCP (Model Context Protocol) is Anthropic's open standard for connecting AI to external tools. Stompy exposes 28 MCP tools that Claude can call directly—lock_context to store knowledge, context_search to find it semantically, ticket to track tasks, detect_conflicts to find contradictions. You add one config line, Claude gets persistent memory. Not using MCP? Stompy also works via CLI commands and REST API.

No. That's the point. Stompy is fully hosted: PostgreSQL databases, S3 document storage, VoyageAI embeddings, OpenRouter Vision, NLI models—all managed. Add one line to claude_desktop_config.json: {"mcpServers": {"stompy": {"command": "npx", "args": ["stompy-mcp"]}}}

Yes. Stompy connects via MCP, CLI, or REST API. Context stored by Claude is immediately available to Gemini, Codex, or any other tool. Same API key, same projects.

No. One Stompy account, one API key. Each tool connects through whichever path it supports — MCP for native integration, CLI for terminal access, REST API for everything else.

Local means you manage PostgreSQL, configure VoyageAI API keys, set up S3, handle NLI models, run Ollama. Stompy is instant: one npm command, zero infrastructure. Automatic backups, managed scaling, no DevOps. Focus on building, not maintaining memory servers.

Features & Capabilities

When you call context_search, Stompy uses VoyageAI's voyage-4 embeddings to convert your query into a vector, then finds contexts with similar meaning—not just keyword matches. Ask 'how do we handle auth?' and it finds your JWT documentation even if it never mentions 'auth'. Similarity scores show match quality (92% match, 78% match).

Stompy stores content as contexts via lock_context. You can store text, code snippets, specifications, and rules as versioned, searchable snapshots. File uploads are available through the web dashboard with async processing. All content gets VoyageAI embeddings for semantic search.

Each project gets its own PostgreSQL schema—completely isolated database tables. Every tool accepts a project parameter, so you just say context_search('auth', project='client-a') and it searches only that project. Zero bleed between projects. Automatic handover loading resumes where your last session left off.

detect_conflicts uses Natural Language Inference (NLI) to find contradictions. If you stored 'always use bcrypt' last month and 'use argon2 for passwords' today, NLI catches the contradiction. resolve_conflict lets you pick the winner: keep_a, keep_b, merge, or dismiss.

Your memory stays. Stompy is the constant. Switch from Claude to Gemini tomorrow — your architecture decisions, rules, and project context are all still there.

Technical Details

Before storing content with lock_context, Stompy analyzes novelty against existing contexts. Content with <10% new information is rejected (mostly redundant). 10-30% novelty triggers a warning. This keeps your knowledge base clean without duplicates. Use force_store=True to bypass if needed.

Yes! db_query runs read-only SELECT statements against your project's PostgreSQL schema. Auto-adds LIMIT 100 for safety. db_schema lets you inspect table structures. Full SQL power with guardrails.

You have full control. Use context_explore to see all stored contexts, db_query to inspect raw data, project_delete to remove a project entirely. The web dashboard provides a visual interface for browsing projects, contexts, and sessions.

Stop re-explaining your projects.

Give your AIs the memory they deserve.

"No memories yet. Which is fine. Totally fine. Stompy's just here. Waiting."