MCP CRM server: connect your CRM to Claude

What is MCP?

The Model Context Protocol is an open standard for connecting AI models to external tools and data. Instead of every integration inventing its own glue, MCP defines one wire format: a server advertises a set of tools (each with a typed input schema), and a client - Claude Desktop, Claude Code, or any MCP-aware agent - discovers those tools and calls them on the model's behalf. It is, roughly, what USB did for peripherals: one connector, many devices.

Relm's server speaks MCP over Streamable HTTP at https://api.relmcrm.com/mcp, using a request/response transport. Authentication has two doors: OAuth 2.1 (the sign-in flow end-user clients like Claude and ChatGPT use - PKCE, dynamic client registration, no key handling) or the same relm_live_ bearer key you would use for the REST API. That symmetry matters: whatever a developer can script against REST, an agent can do through MCP, against the exact same data, with the exact same permissions. There is no second CRM to keep in sync and no separate integration surface to secure.

Why a CRM as an MCP server matters

A CRM is state. It is where an agent remembers who it talked to, what they wanted, and where each opportunity stands. Without durable state, an LLM starts every conversation from zero. The usual workaround is to wrap a UI-first CRM's REST API in a pile of custom function definitions - a brittle, per-project translation layer that you maintain forever.

An MCP CRM server removes that layer. The tools, their input schemas, and their descriptions are published by the server itself. Point Claude at Relm and it instantly knows how to create a contact, move a deal, or log a call. Nothing to hand-write, nothing to keep in sync. This is the difference between a CRM built for LLMs and one that merely has an API.

Add Relm's MCP server to Claude

Mint a key in the dashboard first - use a relm_test_ key while you experiment, since test mode is free, unmetered, and never touches live data. Then add the server to your MCP config. In Claude Desktop and Claude Code this lives in an mcp.json-style block:

{
  "mcpServers": {
    "relm": {
      "type": "http",
      "url": "https://api.relmcrm.com/mcp",
      "headers": { "Authorization": "Bearer relm_live_..." }
    }
  }
}

Restart the client. Relm's tools appear in the tool list, and you can now talk to your CRM in plain language. Swap the key prefix to relm_test_ for a sandbox, or relm_live_ when you are ready for real records.

What tools it exposes

Every CRM operation is a typed MCP tool. The naming is predictable, so the model can reason about what is available without reading a manual:

Tool	What it does
relm_describe_schema	Return the live object, field and enum registry. The agent calls this first.
relm_create / relm_update	Write a contact, company, deal or activity. Object is a typed argument.
relm_list / relm_get	Read records with cursor pagination, or fetch one by prefixed ID.
relm_batch	Run many create/update operations in a single call.
relm_create_field / relm_create_enum_value	Extend the schema at runtime when a needed value does not exist yet.
pipeline & automation tools	Create pipelines and stages, move deals, and define event-triggered automations and drip sequences.

That is a slice of a set of 41 tools covering the whole CRM - contacts, companies, deals, activities, pipelines, custom fields, automations, webhooks and transactional email. The full contract is in the docs.

Two conventions make the tools safe for an agent to call unattended. Reads use cursor pagination, so a list tool returns a stable page plus a next_cursor the model follows to walk large result sets without missing or double-counting rows under concurrent writes. Writes are guarded: relm_update takes an if_match version so a concurrent edit fails loud instead of silently overwriting, and creating a contact whose email already exists returns a 409 that carries the existing record - so a retried or replayed call converges instead of forking data. Together they mean an agent can loop over data and retry freely without corrupting your CRM. (Over REST, writes also accept an Idempotency-Key header.)

Batching: many calls, one request

Chatty tool use is slow. Relm's MCP transport lets the model send an array of tool calls in a single POST, and the relm_batch tool wraps many writes into one operation. When Claude decides to import a list of leads, it does not fire twenty sequential calls - it sends one batch and gets one response.

relm_batch({
  "operations": [
    { "method": "create", "object": "contact", "data": { "email": "[email protected]", "first_name": "Ada" } },
    { "method": "create", "object": "contact", "data": { "email": "[email protected]", "first_name": "Bo" } },
    { "method": "create", "object": "deal",    "data": { "title": "Acme expansion", "value_cents": 1200000 } }
  ]
})

Batching saves round-trips, not quota - each operation is metered individually against your monthly request allowance. See the batch pattern in the give your AI agent a CRM walkthrough.

Self-correcting errors

The single most important property of an MCP CRM is what happens when the model gets it wrong. In most integrations a bad value produces an opaque failure, the model guesses a fix, and it loops. Relm answers with an RFC-9457 problem+JSON error that carries the correction:

{
  "type": "https://relmcrm.com/errors/unknown_value",
  "title": "Unknown Value",
  "detail": "'negotiating' is not a valid stage.",
  "code": "unknown_value",
  "valid_options": ["lead", "qualified", "proposal", "won", "lost"]
}

The model reads valid_options (plus a suggestion when the typo is close to a real value), retries with a valid stage, and continues. This is the "never confused" contract: the error is written for a model, not for a log file. Combined with a live schema the agent can query up front, it means an agent rarely fails twice for the same reason.

Example prompts

Once the server is connected, you drive the CRM conversationally. A few that just work:

• "Add Ada Lovelace at [email protected] as a lead, link her to the Analytical Engine company, and open a $20k deal in the sales pipeline at the qualified stage."
• "Here are 30 leads from our webinar CSV. Create a contact for each and log a 'webinar attendee' activity dated yesterday."
• "Move every deal that has had no activity in 14 days to the at-risk stage and draft a follow-up email for each owner."

Behind each of these, Claude calls relm_describe_schema, resolves the pipeline and stage keys, and batches the writes - self-correcting from any valid_options error along the way. To go deeper on the concept, read what a CRM for LLMs is, and check pricing when you are ready to move off test mode.

FAQ

What is an MCP CRM server?

An MCP CRM server exposes your CRM as a set of typed tools over the Model Context Protocol, so an AI client like Claude can create contacts, companies, deals and activities by calling tools directly. Relm runs a native MCP server at https://api.relmcrm.com/mcp over Streamable HTTP, authenticated via OAuth 2.1 sign-in or a relm_live_ bearer key.

How do I connect Relm's CRM to Claude?

Add an entry to your MCP config pointing at https://api.relmcrm.com/mcp with type http and an Authorization header carrying your relm_live_ key. Once the client restarts it discovers the Relm tools and you can drive the CRM in plain language.

Can Claude create many CRM records in one MCP call?

Yes. Relm's MCP transport accepts an array of tool calls in a single POST, and the relm_batch tool wraps many create or update operations into one request. Batching saves round-trips; each operation is still metered individually.

What happens when the agent sends a wrong value over MCP?

The tool returns an RFC-9457 problem+JSON error with valid_options and suggestion. The model reads the correction and retries with a valid value instead of failing blind. This is Relm's never confused contract.