Skip to main content
MCP Protocol@solidnumber/mcp v1.1.0

Connect your AI editor to a
real business in 30 seconds

the full verb surface across 36 categories (native verbs + ADA bridge — every business operation). One config file. Claude Code, Cursor, or Windsurf connects directly to CRM, payments, calendar, KB, and AI agents — no API to learn.

MCP is for operators of YOUR Solid# tenant — install it in your AI editor and authenticate with your own per-tenant API key. Building a buyer-agent that needs to discover and shop across Solid# tenants? You want UCP instead — signed wire format, marketplace-aware, AP2 payments.
Want the agent to act inside the browser instead? Every Solid# page also registers its verbs via navigator.modelContext (W3C WebMCP). 408 verbs across 5 surfaces — same JSON-LD vocabulary as stdio MCP, no API key needed for read-only public surfaces. See WebMCP docs.
169
Agent-Attraction Verbs
12
Verb Shapes
4
Sibling Transports
214
Total Tools
Free
Developer Access
v1.1.0 architectureReceipt-backed ACID for AI agents

The verb-shape architecture

Most agent frameworks orchestrate (chain LLM calls). Solid# is the layer underneath — the safe-action substrate agents write to. Every one of the agent-attraction verbs across every business function has a SHAPE that matches how AI agents actually reason: observe → explain → preview → commit → receipt → revert. Every write emits an audit row. Whitelisted writes are revertible. Multi-tenant RLS enforces isolation at the database. That's ACID for AI agents — the missing infrastructure layer the labs are looking for.

Aggregate

Collapse 5-8 sub-queries into one tenant-scoped read

  • customer.full_context
  • payment.full_history
  • order.complete_fulfillment_state
  • contact.relationship_map
Explain

Causal chain that produced the current state

  • deal.explain_stage_change
  • crm.explain_contact_state
  • inventory.explain_stockout
  • audit.explain_balance_change
Preview

Dry-run a write before commit — no side effects

  • payments.preview_refund_impact
  • subscription.preview_tier_change
  • pricing.preview_margin_impact
  • inventory.preview_allocation
Suggest

Ranked next-actions with confidence + reason + sample_size

  • deal.suggest_next_action
  • customer.suggest_upsell
  • inventory.suggest_reorder
  • lead.suggest_assignment
Transaction

ACID grouping over multi-step writes — rollback as a unit

  • transaction.start
  • transaction.append
  • transaction.commit
  • transaction.abort
Receipt

Cryptographic attestations on side-effecting writes

  • ucp.receipts.issue
  • voice.call_outbound
  • voice.send_sms
Revert

Single-action undo against whitelisted audit rows

  • audit.revert (NEW shape — v2.12)
Subscribe

Cursor-polling observe streams over the audit log

  • event.subscribe
  • event.poll
  • event.unsubscribe
  • event.list
Discovery

Introspection — agent learns its own surface

  • agent.manifest
  • voice.translate_status
  • ucp.recommendations
Trail

Agent reconstructs the chain of actions that led here

  • agent.trails.lookup
  • agent.trails.chain
Reputation

Per-verb reliability + agent track-record

  • agent.reliability.scoreboard
  • agent.reputation.verb
  • agent.reliability.needs_attention
Macro / Telemetry

Saved verb-chains + agent self-monitoring

  • agent.macros.execute
  • agent.macros.register
  • agent.telemetry.status

The reasoning loop these shapes support

observe explain preview commit (transaction / receipt) revert if needed

An agent invoking a write verb gets back an audit_id. Pass that id to audit.revert and the action is undone (whitelisted handlers in the backend; unsupported types return a structured refusal with a machine-readable reason). Same architecture across every registered verb. This is what the labs (Anthropic / OpenAI / Cursor / Cognition) are looking for: a safe-action substrate where every write is auditable and (where applicable) reversible.

One registry. Four sibling transports.

All verbs are declared once in services/agent_verb_manifest.py and auto-projected to four sibling transports. A backend CI test (test_sibling_transport_parity.py) enforces it: a verb visible on one is visible on all four unless the verb explicitly omits a surface. Different AI runtimes hit different transports; the shape contract stays the same.

CLI

solid verbs invoke

For AI agents in shells: Claude Code, Codex, Cursor terminal. npm i -g @solidnumber/cli

MCP stdio

@solidnumber/mcp

For AI editors: Claude Desktop, Cursor, Cline, Windsurf, Codex. claude mcp add solidnumber

WebMCP

navigator.modelContext

For in-browser AI agents: Claude.ai web, Chrome agent mode. Per-tenant scoped on every Solid# subdomain. /docs/webmcp

UCP

/.well-known/ucp

For AI buyer-agents: Gemini AI Mode, ChatGPT shopping. RFC 9421 ES256 signed. /docs/ucp

Add a verb once → all four transports light up within 5 minutes of the backend manifest update (the MCP server caches the manifest, then refreshes). No npm republish required for new verbs. This is the "Phase 5 unifier" architecture — declare-once, bridge-everywhere.

1

Get your API key

Sign up for free developer access. You get an API key, a sandbox company, and full access to all the full verb surface (native verbs + ADA bridge — every business operation across 36 categories).

Or use the CLI
npx @solidnumber/cli auth login
2

Connect your editor

Add one config file. The server boots via npx @solidnumber/mcp — no install step, always the latest version, stdio transport. The SOLID_API_KEYenv var is your Bearer token; every request is tenant-scoped to the company that key belongs to.

Claude Code / Claude Desktop
{
  "mcpServers": {
    "solidnumber": {
      "command": "npx",
      "args": ["-y", "@solidnumber/mcp"],
      "env": {
        "SOLID_API_KEY": "sk_solid_your_key_here",
        "SOLID_API_URL": "https://api.solidnumber.com"
      }
    }
  }
}
Cursor / Windsurf
{
  "mcpServers": {
    "solidnumber": {
      "command": "npx",
      "args": ["-y", "@solidnumber/mcp"],
      "env": {
        "SOLID_API_KEY": "sk_solid_your_key_here",
        "SOLID_API_URL": "https://api.solidnumber.com"
      }
    }
  }
}
Local development (clone the repo)
{
  "mcpServers": {
    "solidnumber": {
      "command": "node",
      "args": ["/path/to/solid-mcp-server/src/comprehensive-index.js"],
      "env": {
        "SOLID_API_KEY": "sk_solid_your_key_here",
        "SOLID_API_URL": "https://api.solidnumber.com"
      }
    }
  }
}
Production HTTP transport

A hosted HTTP endpoint (api.solidnumber.com/mcp) is on the roadmap for multi-tenant managed MCP. For now, use stdio via npx — it runs in your editor's process, keeps your key local, and has identical tool coverage.

3

Start building

Just talk to your editor. The AI already understands every tool.

"Show me all contacts who booked this week"

solid_calendar_listReturns merged Google + local calendar events

"Add a premium detailing service for $299"

solid_vibe → vibe_analyze → vibe_applyCreates service, updates KB, trains agents

"Connect this company to their Stripe account"

solid_integration_connectConnects Stripe with test/live key management

"What does the onboarding flow look like?"

docs_search_owners_manualSearches 1,222 docs, returns relevant architecture docs

"Generate a 5-page website for a plumber"

vibe_generate_websiteBuilds pages from industry KB template

608 Tools, 6 Categories

Business Customization

solid_schemaDiscover database entities and fields
solid_capabilitiesList what you can customize
solid_field_addAdd custom fields to contacts, orders, etc.
solid_workflow_createBuild automation workflows
solid_template_updateUpdate email/SMS/PDF templates
solid_integration_connectConnect Stripe, QuickBooks, Google, Zapier

How It Works

Your Editor

Claude Code, Cursor, or Windsurf. You type natural language. The AI picks the right MCP tool automatically.

MCP Server

the full verb surface (native verbs + ADA bridge — every business operation across 36 categories), 1,944 REST endpoints. Bearer-token auth, tenant-scoped by API key, stdio transport.

Business Data

550 tables (446 with RLS), 14 trained AI agents + 116 background workers, CRM, payments, calendar, KB. Every tool operates on real data with full tenant isolation.

Three Transports, One Vocabulary

Solid# exposes the same JSON-LD verb registry over three transports. Pick the one that matches your runtime — the metadata and IRIs are identical.

stdio MCP

608 tools

This page. Run npx @solidnumber/mcp from your AI editor. Bearer token auth, tenant-scoped, full operator surface.

For operator AI editors

WebMCP

408 verbs

Every Solid# page registers its verbs via navigator.modelContext. 5 surfaces (public / dashboard / tenant-site / writes). W3C draft. docs.

For in-browser AI agents

UCP

capabilities

Signed wire format for buyer-agents to discover and transact across Solid# tenants. RFC 9421 + AP2 payments. docs.

For external buyer agents

Source of truth: services/webmcp/tool_registry.py — one registry, three transports, identical IRIs at https://api.solidnumber.com/webmcp/tools/{name}.

Who Uses This

Freelance Developers

Build client businesses from your editor. Pull data, push changes, manage AI agents — all without leaving VS Code.

Free developer access

Agencies

Manage 50 client businesses from one MCP connection. Switch companies, deploy changes, monitor health — all from your terminal.

Multi-company support built in

AI Agent Builders

Build custom AI agents that use MCP tools to execute real business operations. Not a wrapper — closed-loop execution.

AI agents as reference implementations

Configuration

The server resolves config from three sources, in order: environment variables (set in your editor's MCP config), a local .env file (for cloned-repo dev), then sensible defaults. Env vars always win — safest for keeping secrets out of disk.

VariablePurposeDefault
SOLID_API_KEYBearer token (scope-limited API key)required
SOLID_API_URLBackend base URLhttps://api.solidnumber.com
BACKEND_URLAlias for SOLID_API_URL (legacy)
API_KEYAlias for SOLID_API_KEY (legacy)
Get your API key via the CLI

The fastest way to get a scoped key without leaving the terminal — reuse it in your MCP config:

# install via brew (mac), scoop (windows), or npm (any)
brew install solidnumber/tap/cli
solid auth login
solid auth token create -n "MCP" -s kb:read,pages:write,agents:converse
# Paste the sk_solid_... value into SOLID_API_KEY in your MCP config

Troubleshooting

\u203AEditor says "MCP server failed to start"
Check that Node 18+ is installed (node -v). The npx command downloads on first run — first launch can take ~20s. Check your editor's MCP logs for the real error.
\u203ATools list is empty
Your SOLID_API_KEY is probably missing or malformed. The server still boots and advertises all the full verb surface — CLI, MCP, WebMCP, and UCP, but every call returns 401. Verify with: echo $SOLID_API_KEY — should start with sk_solid_.
\u203AAll tools return 403 "Forbidden"
Your token has scopes that don't cover this operation. Create a broader key: solid auth token create -s kb:read,kb:write,pages:write,agents:converse,vibe:execute. See the CLI docs for the full 26-scope list.
\u203ACalls to api.solidnumber.com time out
Bump the HTTP timeout by setting SOLID_TIMEOUT_MS=60000 in your MCP config env block. Run solid doctor from the terminal to confirm the backend is reachable from your machine.
\u203AWant to point at a local backend
Set SOLID_API_URL=http://localhost:8090 in your MCP config. Handy for contributing to solid-mcp-server or testing against a sandbox.
\u203AFirst-run npx is slow
After the first launch, npx caches the package. Subsequent boots are <200ms. To pin a version: "args": ["-y", "@solidnumber/mcp@1.1.0"].

Discovery Surface

Solid# ships every machine-readable manifest an AI agent expects, per-tenant. Every `@id IRI is stable across the public site, the tenant CLI payload, MCP tool outputs, and on-disk `.claude/solid-context.jsonld. One graph, one identifier space.

/.well-known/agent.json

Agent2Agent (A2A) protocol manifest — capabilities, skills, auth schemes.

/.well-known/ai-plugin.json

OpenAI plugin manifest (+ anthropic-ai-plugin.json variant).

/.well-known/mcp.json

Full 608-tool MCP catalogue (~12 KB).

/.well-known/openapi.json

1,944-endpoint OpenAPI spec.

/llms.txt + /llms-full.txt

Hand-curated platform summary for LLM crawlers. Per-tenant on every tenant host.

/ai.txt

AI-crawler policy + endpoint directory (supported bots, rate limits, contact).

GET /api/v1/cli/context?format=jsonld

Schema.org + solid:* typed graph of the tenant — walkable via solid graph.

/sitemap.xml + robots.txt

497 URLs; explicit allow rules for GPTBot / Google-Extended / Claude-Web / Perplexity / Applebot.

Schema.org reuse where it fits (Organization, Service, Product, Article, WebPage, Offer). Solid#-specific types under solid:* (Agent, Chain, KnowledgeBaseEntry, Tier, Industry, Shelf, MCPTool). Contract-stable IRIs.

Security

Tenant Isolation

Every API call scoped to your company_id. RLS on 446 of 550 tables (100% of tenant-scoped tables). You can never see another company's data.

Scoped API Keys

26 granular scopes. Give a key only kb:read access, or full write. Keys are SHA-256 hashed at rest.

Vibe Safety

Every vibe action is reversible. No deletions, always rollback. Preview before apply.

Audit Trail

Every MCP tool call logged with who, what, when, and which company. Full accountability.

Your AI editor already speaks MCP

One config file. the full verb surface (native verbs + ADA bridge — every business operation across 36 categories). Free developer access. Start managing real businesses from your terminal.

SolidNumber — AI That Answers Calls, Books Jobs & Runs Your Business