mcpField
S
Synapse — Geo Growth Layer

Synapse — Geo Growth Layer

Remote
runsynapse.devAI & Agents0Updated 24w ago

About Synapse — Geo Growth Layer

Synapse is a CLI, linter, and MCP server for checking how easily new products can be found and recommended by AI coding agents. Its tools support audits, fixes, tracking setup, status checks, prompt discovery, and corpus queries.

Key features

  1. 01Run 24-rule GEO lint checks
  2. 02Score discoverability from 0–100
  3. 03Apply one-command auto-fixes
  4. 04Initialize tracking
  5. 05Check status and query corpus
  6. 06Expose tools, resources, and prompts

Use cases

  1. 01Audit a project before launch
  2. 02Fix GEO lint failures
  3. 03Check discoverability during a build session

MCP support

The MCP server exposes six tools, three resources, and three prompts over stdio and streamable HTTP. MCP clients can run checks, apply fixes, initialize tracking, inspect status, and query the corpus.

Configuration

Remote servers need no local install. Pick your client, then copy the config or install in one click.

Endpointhttps://runsynapse.dev/api/mcp
Copy install command
Claude CodeTerminal
Cursor.cursor/mcp.json
VS Code.vscode/mcp.json
Claude Desktopclaude_desktop_config.json
Windsurf~/.codeium/windsurf/mcp_config.json

Run commands in a terminal; paste JSON into the client’s MCP config and restart. Servers that need sign-in will prompt on first connect.

Packages
npm@calvin8miles/mcp-server0.1.2

Tools

Details

From the project README

Synapse — GEO Growth Layer

The GEO check every vibe coder runs before they launch.

npx synapse check

Synapse is a CLI + MCP server + linter that makes a new product discoverable and recommendable by AI coding agents (Cursor, Claude Code, Windsurf, v0, Bolt, Lovable). Run synapse check against a project path or URL and get a 0–100 Growth Score plus a list of failing rules and one-command auto-fixes.

Packages

PackageDescription
@synapse/geo-lint24-rule GEO linter. Programmatic API: lint(target) → LintReport.
@synapse/cliCLI with init, check, fix, deploy, status. Installs as synapse.
synapseThin meta-wrapper for the npx synapse UX.
@synapse/mcp-serverMCP server exposing 6 tools, 3 resources, 3 prompts. Stdio + streamable HTTP.

Quick start

# In a fresh project:
npx @synapse/cli init           # scaffolds synapse.config.json + tracker stub
npx @synapse/cli check          # 24-rule lint, prints scored report
npx @synapse/cli fix            # apply auto-fixes (llms.txt, robots.txt, agent-answer)

# With an account:
export SYNAPSE_API_KEY=…
npx @synapse/cli deploy         # register the site, get a /s/<slug> dashboard
npx @synapse/cli status         # live agent-mention stats

MCP install

Synapse runs as an MCP server so any agent can call geo_check, geo_fix, geo_track_init, geo_prompts, geo_status, and geo_corpus_query directly during a build session.

Cursor — .cursor/mcp.json
{
  "mcpServers": {
    "synapse-geo": {
      "command": "npx",
      "args": ["-y", "@synapse/mcp-server"],
      "env": { "SYNAPSE_API_KEY": "" }
    }
  }
}
Claude Code
claude mcp add synapse-geo -- npx -y @synapse/mcp-server
Windsurf — ~/.codeium/windsurf/mcp_config.json
{
  "mcpServers": {
    "synapse-geo": { "command": "npx", "args": ["-y", "@synapse/mcp-server"] }
  }
}
Cline — VS Code settings

Add to cline.mcpServers:

"synapse-geo": { "command": "npx", "args": ["-y", "@synapse/mcp-server"] }
Continue — config.json
{
  "mcpServers": [
    { "name": "synapse-geo", "command": "npx", "args": ["-y", "@synapse/mcp-server"] }
  ]
}
Zed — ~/.config/zed/settings.json
{
  "context_servers": {
    "synapse-geo": {
      "command": { "path": "npx", "args": ["-y", "@synapse/mcp-server"] }
    }
  }
}

Monorepo development

pnpm install
pnpm build                      # builds all packages
pnpm test                       # runs vitest in packages/geo-lint
node packages/cli/dist/index.js check https://example.com
node packages/mcp-server/dist/index.js   # stdio MCP server
PORT=8787 node packages/mcp-server/dist/http.js   # streamable HTTP

Authentication model

SurfaceRead-only toolsWrite / account tools
CLIinit, check, fix work with no accountdeploy, status need SYNAPSE_API_KEY
MCPgeo_check, geo_prompts, geo_status, geo_corpus_query work with no authgeo_fix, geo_track_init require SYNAPSE_API_KEY

Web app + backend (apps/web)

Lives in this same repo. Next.js 14 (App Router) + Supabase. Free during the Founding 1000 — no Stripe, no paywalls.

Pages: /, /install, /guide, /methodology, /leaderboard, /discover, /corpus, /s/[slug] (with dynamic OG + default badge SVG).

Public assets: /llms.txt, /llms-full.txt, /sitemap.xml, /robots.txt, /.well-known/agent-answer.json, /discover.json, /s.js (tracker beacon).

API routes against Supabase:

RoutePurpose
POST /api/sitesRegister a new site (used by synapse deploy).
POST /api/eventsTracker beacon endpoint, CORS-enabled.
GET /api/sites/[slug]/statusLive dashboard data.
GET /api/corpusPublic corpus snapshot.
GET/POST /api/recommend?intent=…Agent-facing recommendation endpoint.
POST /api/cli-telemetryAnonymous CLI usage events.

Dogfood result: Synapse scores 98/100 (grade A) against its own linter.

Deploy
  1. Supabase: create a project, then run apps/web/supabase/migrations/0001_init.sql (paste into the SQL editor, or psql $SUPABASE_DB_URL -f …). RLS is configured for public reads of visible sites; all writes go through the service role from the API routes.
  2. Env: copy apps/web/.env.example to .env.local and fill in NEXT_PUBLIC_SUPABASE_URL, NEXT_PUBLIC_SUPABASE_ANON_KEY, SUPABASE_SERVICE_ROLE_KEY, NEXT_PUBLIC_SITE_URL.
  3. Vercel: link apps/web to a Vercel project and ship.
    vercel link --cwd apps/web
    vercel env add NEXT_PUBLIC_SUPABASE_URL
    vercel env add NEXT_PUBLIC_SUPABASE_ANON_KEY
    vercel env add SUPABASE_SERVICE_ROLE_KEY
    vercel env add NEXT_PUBLIC_SITE_URL
    vercel --prod --cwd apps/web --yes
    

Each surface fails closed with a clear error if Supabase isn't configured — the homepage and /install still render statically without it.

License

MIT

Comments

Markdown supported

New to MCP?

From what the protocol is to installing your first server, these answers cover most first questions.

An open protocol that defines how AI applications connect to external tools and data in a uniform way. Clients talk to the model; MCP servers provide tools, resources and prompt templates. They exchange standard messages, so one server can be reused by many clients.