Managed MCP Memory Server

Claude Forgets. Stompy Doesn't.

An AI memory system that actually remembers your projects, preferences, and that thing you explained three weeks ago.

Works with your favorite MCP-compatible tools

Claude Desktop

Claude Code

Cursor

N8N

Cline

Any tool that supports the Model Context Protocol

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.

Claude 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.

lock_context

Storing what matters.

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

Claude Code 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_switch

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.

Project Isolation

> project_switch("articles")
✓ Switched to articles
✓ Loaded 8 contexts from last session
✓ Ready to continue where you left off

Each project gets isolated memory. 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.
Session handover — When you switch back, Stompy loads where you left off automatically.
Cross-project search — When you need it, search across everything. When you don't, stay focused.

ingest_document

Files remember too.

That architecture diagram you made? The PDF spec from the client? The screenshot of the whiteboard session?

Document Ingestion

> ingest_document("system-architecture.png", tags="architecture,diagram")
✓ AI analyzed image content
✓ Generated description: "System architecture showing three
   microservices connected via message queue..."
✓ Created multimodal embeddings
✓ Stored in S3, indexed for search

Stompy doesn't just store files — it understands them.

Under the hood

Text extraction — PDFs, DOCX, code files, spreadsheets. Content becomes searchable.
AI vision analysis — Images get analyzed by Qwen 2.5 VL. Stompy generates detailed descriptions.
Multimodal embeddings — VoyageAI creates embeddings that capture both visual and semantic content.

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 Config Line, Get Persistent Memory

Stompy is an MCP server. Add it to Claude Desktop's config, and Claude gains access to 25+ memory tools automatically.

Add to Claude Desktop Config

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

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

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_switch loads your project with previous handover
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 switch to your project and check what context we have.
→ project_switch("my-saas")
→ context_search("authentication")

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..."

Simple, Transparent Pricing

One plan. Everything included.

No surprises. No feature gates.

$4.99/month

when we launch. No enterprise pricing tiers. No "contact sales."

Unlimited projects
Unlimited contexts
Semantic search
Document ingestion
Conflict detection
Team sharing

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

What developers are saying

Context that sticks

Early users who stopped re-explaining their projects.

“I used to spend the first 10 minutes of every Claude session re-explaining my project. Now I just... start working. It's weird how normal that feels now.”

Alex Chen

Senior Developer · Indie Dev

“The conflict detection saved me from a nasty bug. I'd forgotten I'd documented a constraint weeks ago, and Stompy caught me before I broke everything.”

Sarah Mitchell

Full-Stack Engineer · Startup Land

“Finally, my AI remembers that I hate semicolons. It's the little things, honestly.”

Jordan Park

Frontend Developer · Remote

Join our early users—real testimonials coming soon!

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 25+ MCP tools that Claude can call directly—lock_context to store knowledge, context_search to find it semantically, ingest_document to process files, detect_conflicts to find contradictions. You add one config line, Claude gets persistent memory.

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"]}}}

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-3 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).

ingest_document handles PDFs, Word docs (.docx), Excel (.xlsx), images (PNG, JPG, WebP), and all text/code files. PDFs get text extraction. Images are analyzed by OpenRouter Vision (qwen2.5-vl) to generate descriptions, then embedded with VoyageAI's multimodal model. Search by describing what's in an image.

Each project gets its own PostgreSQL schema—completely isolated database tables. project_switch('client-a') loads that project's contexts, sessions, and documents. 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.

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_execute handles writes with dry-run mode and confirmation required. Full SQL power with guardrails.

export_project creates a complete backup: all contexts (with versions), sessions, documents, embeddings. Compressed JSON format. import_project restores anywhere. Your knowledge is portable—we don't lock you in.

Maya never re-explains her projects anymore.

Neither will you.

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