How to build a paid MCP server from a real demand signal

The signal: one repo, 22,400 stars, two weeks

A developer named rohitg00 shipped a GitHub repo called agentmemory on June 1, 2026: persistent memory for AI coding agents. By the time it got scanned it had 22,400 stars. As of this month it sits past 25,000. The pitch is simple: your AI agent forgets everything the moment a session ends, and this repo captures what the agent does, compresses it into searchable memory, and injects it back the next time you open a session.

The same week, a Show HN post for a different local-first memory tool pulled 312 points and 146 comments, 458 points of engagement total. Two independent groups of developers, on two different platforms, complaining about the exact same gap.

That is a real demand signal, not a hunch. Browse live demand signals like this one and you will find the pattern repeats across dozens of AI agent categories every week. The specific gap in this one: five memory tools already exist (Mem0, Zep, Letta, LangMem, Cognee), and none of them work across more than one agent runtime without a separate SDK integration for each. A developer running Claude Code and Cursor and a custom agent needs three different setups just to keep one memory store in sync.

Pull the validated spec with two MCP calls

This is the part that used to take a week of manual research: reading every competitor's docs, counting their GitHub stars, figuring out who actually wants the thing. Clawsmith already did that work and scored it. Connect it to your coding agent over MCP and pull the signal directly:

{
  "mcpServers": {
    "clawsmith": {
      "url": "https://www.clwsmth.com/api/mcp"
    }
  }
}

Ask your agent to call get_signal on the slug:

get_signal(slug: "portable-cross-runtime-agent-memory-layer")

The real response back:

{
  "title": "AI agents lose all memory and preferences between sessions with no portable layer that works across runtimes",
  "virality_score": 22858,
  "gap_status": "underserved",
  "gap_assessment": "Mem0, Zep, Letta, LangMem, Cognee exist but none is a universal portable layer that works across agent runtimes without custom integration per tool. agentmemory has 22400 stars showing validated demand.",
  "competitor_count": 6
}

Then pull the full build spec: get_product_brief(idea_slug: "cross-runtime-mcp-memory-server"). That single call returns 8 engineering-level feature prompts (each one specifies the exact tool calls, storage tier, and config format), a competitor table with real funding and star counts, and 158 real leads pulled from the same GitHub and HN threads that generated the signal, people who already said in public they want this fixed. Your agent now has everything it needs to start writing code, before you have written a single line yourself.

This is not a one-off. The same make money build category has dozens of signals scored the same way, every week, across categories from browser extensions to mobile apps. The mechanism below works for any of them, not just this one.

Scaffold the four tools you actually need to ship first

The full brief specs out 8 features (sync, redaction, billing, a vector search tier). Ignore all of that for version one. The core of the product is 4 tool calls:

// server.ts - minimal MCP memory server
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import Database from "better-sqlite3";

const db = new Database("./memory.db");
db.exec(`CREATE TABLE IF NOT EXISTS memory (
  namespace TEXT, key TEXT, content TEXT, created_at INTEGER
)`);

const server = new McpServer({ name: "memory-mcp", version: "0.1.0" });

server.tool("memory_write", { namespace: "string", content: "string" }, async (args) => {
  db.prepare("INSERT INTO memory (namespace, content, created_at) VALUES (?, ?, ?)")
    .run(args.namespace, args.content, Date.now());
  return { content: [{ type: "text", text: "written" }] };
});

server.tool("memory_read", { namespace: "string" }, async (args) => {
  const rows = db.prepare("SELECT content FROM memory WHERE namespace = ? ORDER BY created_at DESC LIMIT 20")
    .all(args.namespace);
  return { content: [{ type: "text", text: JSON.stringify(rows) }] };
});

memory_search and memory_delete follow the same shape. Cap records at 10,000 per namespace and a 90 day retention window on the free local tier, that alone covers a solo developer's real usage for months. Wire it into Claude Code with one hook and Cursor with one config line, that is the entire zero-integration promise the signal is asking for. Skip the vector tier, skip team sync, skip billing, until someone actually pays you and asks for it.

Deploy it for under 10 dollars a month

You do not need a funded infrastructure stack to ship this. Railway's Hobby plan is $5/month and covers a small always-on Node server at idle to moderate traffic. Fly.io starts at $2.02/month for a 256MB shared-cpu-1x machine in a single region. Real production traffic on either platform, once you account for egress and restarts, lands around $10-25/month.

# Railway: deploy the MCP server in three commands
railway init
railway up
railway domain

That domain is your MCP server URL. No Kubernetes, no managed database tier, no DevOps hire. At $9/month for your cheapest paid plan, three paying customers already cover a year of hosting.

Price it against what already sells

Mem0 already proved people pay for this category. It raised $24M in Series A funding in October 2025 (Basis Set Ventures led, Y Combinator and Peak XV Partners followed), on top of $3.9M seed, and sits at 41,000+ GitHub stars. Its pricing: Hobby is free up to 10,000 memories, Pro is $19/month for 100,000 memories plus graph memory and SOC 2 compliance, Enterprise starts at $249/month. Indie MCP servers across the wider market range from $19/month to $149/month depending on scope, and freemium is the dominant model: free core tools with no license key, paid tools that require one.

The gap you are filling is narrower than Mem0's, cross-runtime portability specifically, so price under it:

{
  "plans": [
    { "name": "Solo", "price_month": 9, "limit": "1 user, 5 namespaces, 50000 records, vector search" },
    { "name": "Team", "price_month": 29, "limit": "5 users, unlimited namespaces, 500000 records, sync" },
    { "name": "Pro", "price_month": 99, "limit": "unlimited users, unlimited records, SSO, SLA" }
  ]
}

Local-only tier one stays free forever, same as Mem0's Hobby plan. You are not charging for memory storage, you are charging for the sync layer and the zero-config adapters that save a developer the week of integration work Mem0, Zep, and LangMem each force separately. Check the pricing page for how Clawsmith itself prices the same shape: full dashboard free forever, the closed loop from brief to leads at $25/mo. Same logic applies to your memory server. Free earns trust, the paid tier sells the work a developer would otherwise spend a week doing by hand.

The go and no-go numbers

Clawsmith scores every idea on 6 factors out of 2 points each, 12 max: gap, leads, trend, capital, attention, convergence. This signal scored gap 1, leads 2, trend 1, capital 2, attention 2, convergence 1, a 9 out of 12 total, verdict "premium."

Go if:

• Gap status reads "underserved," not "saturated" (5-6 competitors exist here, none solve the specific angle)
• 100+ real leads are already attached to the signal (158 here, pulled from actual GitHub and HN threads, not guessed)
• The top comparable product has real funding or real revenue proof (Mem0's $24M is the proof here)
• Total score is 7+ out of 12

No-go, or wait, if:

• Gap status reads "saturated" with no differentiated angle
• Lead count is under 20, meaning the demand is one loud post, not a pattern across sources
• The category has zero funded or revenue-proven competitors, meaning nobody has shown people will pay for it yet

Run the same check on any idea before you spend a weekend on it, not just this one. A signal with a 9-out-of-12 score and 158 leads beats a signal with a 4-out-of-12 score and 6 leads every time, even if the second one sounds more exciting to build. The scoring exists so you stop picking ideas by gut feel and start picking them by what real people already said in public.

Charge real money once you cross two thresholds: 10 people have actually installed the free local tier (not starred it, installed and used it), and 3 of them have asked for a feature that only the paid tier solves (sync, team sharing, larger storage). Before that, you are guessing at a price on zero usage data.

Ship the weekend version first

If you have one weekend, build exactly this: the SQLite-only server above, the Claude Code hook adapter, nothing else. No vector tier, no sync daemon, no billing system. That is roughly 300 lines of TypeScript and one railway up command.

# Claude Code hook config (settings.json)
{
  "hooks": {
    "Stop": [{ "hooks": [{ "type": "command", "command": "node ./adapter/claude-code-write.js" }] }]
  }
}

Post it to the same places the signal came from, Show HN and the relevant subreddits, with the real number in the first line: "built a memory server that works across Claude Code and Cursor with one install, no per-tool SDK." The 158 leads attached to this signal already told you, in public, exactly what line will make them click.