---
title: "Claude Code: one mcpServers block, 11 tools"
summary: "A shipped integration: Claude Code reads MCP servers from a JSON object with an `mcpServers` key, so the block below — a URL and a token presented unchanged on every request, in an Authorization header — is the whole configuration. The eleven tools then appear in the session, and a resolve from the terminal is the same resolve as an HTTP call: the same price, the same rate-limit bucket, the same tenancy."
canonical_url: https://entitybind.com/integrations/claude-code
last_updated: 2026-10-12
copy: full
---

# Claude Code: one mcpServers block, 11 tools

> A shipped integration: Claude Code reads MCP servers from a JSON object with an `mcpServers` key, so the block below — a URL and a token presented unchanged on every request, in an Authorization header — is the whole configuration. The eleven tools then appear in the session, and a resolve from the terminal is the same resolve as an HTTP call: the same price, the same rate-limit bucket, the same tenancy.

Canonical page: https://entitybind.com/integrations/claude-code
Last updated: 2026-10-12

## Entity Bind and Claude Code

Shipped integration

A shipped integration: Claude Code reads MCP servers from a JSON object with an `mcpServers` key, so the block below — a URL and a token presented unchanged on every request, in an Authorization header — is the whole configuration. The eleven tools then appear in the session, and a resolve from the terminal is the same resolve as an HTTP call: the same price, the same rate-limit bucket, the same tenancy.

- What this is: A shipped integration
- Steps to working: 4 below
- Limits: 4 below
- Written back to your systems: Nothing
- To install: A JSON object

Before you build any of it: The answers land on your own rows before any code does, and looking costs no integration work. [Start free →](https://app.entitybind.com/app?signup=1)

By [James Rooney](https://entitybind.com/about), founder of Entity Bind · Last revised 12 October 2026

## How you get a key

Create your workspace online and verify your email, then create your own read or resolve API keys, each shown once and revocable. Free includes 300 credits and needs no card. Paid subscriptions are purchased through Stripe in Billing, with applicable VAT and no automatic usage or overage charges.

`host.example.com` is a placeholder everywhere below, and a client configured against it will not connect. The hosted base URL is https://app.entitybind.com. Replace the placeholder with that origin; registry checks follow your activated plan.

The full-pipeline evaluation is arranged separately and is not activated by signup. Request it for your workspace; we confirm availability, sources and the start date before activation. It starts with a conversation about your file.

Create your workspace online, verify your email and create your own API key. Free includes 300 credits and shallow matching with no card; choose a paid subscription in Billing when you need registry checks. [Start free →](https://app.entitybind.com/app?signup=1)

## Getting Claude Code answering

Every block below is the shipped server's own configuration. The identifiers a running process actually reads — module paths, environment variable names, header names — are exact; the values beside them are placeholders, and the key under mcpServers is a display name that nothing on either side of the wire reads.

### 01 Prove the endpoint answers

Run both of these before you touch a config file, because the two commonest failures present identically as a broken client. A 421 means the deployment's public base URL does not name the hostname your client puts in the Host header; that check runs before authentication, before routing and before any tool body, so no amount of editing the client will move it. The health probes sit outside the check, which is why a green /healthz does not on its own show that tool calls are being admitted. The tools/list call shows that.

```
curl -s https://host.example.com/healthz

curl -s https://host.example.com/mcp \
  -H "Authorization: Bearer $ENTITYBIND_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'
```

### 02 Add the server

Project scope puts this in a JSON file at the root of the repository; user scope puts the same object in your own Claude Code configuration. The key under mcpServers is the name the client displays and nothing on either side of the wire reads it. The path is /mcp, the header is Authorization and the scheme is Bearer on every remote shape.

```
{
  "mcpServers": {
    "entitybind": {
      "type": "http",
      "url": "https://host.example.com/mcp",
      "headers": {
        "Authorization": "Bearer rk_YOUR_KEY_HERE"
      }
    }
  }
}
```

### 03 Keep the key out of the repository

A project-scoped config file is a file somebody commits. The rk_ key you create in your Entity Bind workspace is the whole credential — there is nothing further to mint, register or exchange, and no separate MCP credential exists — so a committed config is a committed credential. Use the user-scoped file, or your client's own environment expansion where it has one. If a key does reach a repository, revoke it in your workspace and create a new one.

### 04 Tell the agent what an abstention is

Put two things in the agent's own instructions before it calls anything. An abstention is a successful answer rather than an error: the tool returns a ranked shortlist, a typed reason, the column that would have decided, and a review id, and it costs nothing. And a confidence number is read against the recorded evidence behind that particular decision, not as a universal score. Confidence bounds depend on the recorded evidence population; there is no universal score for every match. Read match_confidence_basis and the evidence. A 0.99 filter can return some v8 adjudicated matches while excluding valid identifier matches, so validate its coverage cost on your own inputs.

If a step above fails against your own deployment, send us what the client reported rather than working around it. [Talk to us →](https://entitybind.com/contact)

## What this route gets you

Every surface runs the same pipeline: the same cascade, the same confidence floor, the same evidence and the same credit rule. These are the things this route adds on top of it.

- Eleven tools in the session: resolve_company, match_records, get_entity, get_crosswalk, get_enrichment_fields, search_entities, get_decision, get_usage, and the three review-queue tools.
- The same pipeline the HTTP API runs, delegating to the same application services, so a resolve over MCP is the same resolve at the same price against the same rate-limit bucket.
- Free, unmetered reads. get_entity, get_crosswalk, get_enrichment_fields, search_entities, get_decision and get_usage cost nothing, so an agent can look before it decides to spend.
- A decision id on every resolve that reopens the whole evidence trail at a URL, which is what makes an agent's answer auditable after the session has closed.

## What it will not do

4 properties to build around, rather than to meet later in a client's logs. Each one changes what an agent or a repository can safely do on this surface.

01. The rate limits are per tenant, not per key and not per surface. A tenant's per-minute limit is what they hold, not what they hold twice for using MCP and HTTP together.
02. A call dropped for being over the limit comes back as a rate-limited tool error with the retry window written into the message text, because a tool call has no response headers for an agent to read it from.
03. There are no sessions. Every request carries its own bearer token and nothing is held between them, so there is no session id to lose and none that could act as a second credential.
04. The tool catalogue is readable without a credential: anyone who can reach the port can read tool names, argument schemas and descriptions. No customer data is reachable that way, but the port should not be public without a reason.

Check these integration limits before building. Create your Free workspace to inspect your own rows and keys; contact us if you need help choosing a supported integration shape. [Start free →](https://app.entitybind.com/app?signup=1)

## The other ways in

3 of the 6 are shipped integrations and 3 are patterns over the HTTP API. Every card says which kind it is, so you know what you are scoping before you open it.

- [Claude Desktop](https://entitybind.com/integrations/claude-desktop) (Shipped): 4 steps · 4 named limits
- [Cursor](https://entitybind.com/integrations/cursor) (Shipped): 4 steps · 3 named limits
- [Snowflake](https://entitybind.com/integrations/snowflake) (Pattern): 4 steps · 5 named limits
- [Salesforce](https://entitybind.com/integrations/salesforce) (Pattern): 4 steps · 5 named limits
- [Python](https://entitybind.com/integrations/python) (Pattern): 4 steps · 5 named limits

Claude Code sits with Claude Desktop and Cursor on the same shelf: configure and call. If you are weighing a shipped integration against a pattern, [the line between the two shelves](https://entitybind.com/integrations#the-line) is drawn on the hub.

Whichever surface you land on, the cheapest first move is the same: a few hundred of your own rows. [Start free →](https://app.entitybind.com/app?signup=1)

## What to read next

The work this surface is installed to do, the method behind the answers it returns, and the terms those answers use. Each card names its own shelf.

- [AI agents](https://entitybind.com/use-cases/ai-agents) (Use case): A counterparty check before the agent acts, and a receipt for what it acted on.
- [Entity resolution for AI agents](https://entitybind.com/guides/entity-resolution-for-ai-agents) (Guide): An agent about to pay or contract a counterparty needs a decision with a receipt, not a similarity score. Why abstention is the safe default for an autonomous caller, and what the MCP surface exposes.
- [MCP (Model Context Protocol)](https://entitybind.com/glossary/mcp) (Definition): The Model Context Protocol is an open standard for connecting AI assistants to external tools and data, so that a model can call a system's real operations instead of being told about them in a prompt.
- [Tool call](https://entitybind.com/glossary/tool-call) (Definition): A tool call is a single invocation of an exposed operation by a model or agent, with structured arguments and a structured result — the unit that is authenticated, metered and audited.
- [Abstention](https://entitybind.com/glossary/abstention) (Definition): An abstention is a first-class 'we do not know' returned instead of a match: the record comes back unresolved, with a ranked shortlist, a typed reason and the column that would have decided it.
- [Crosswalk](https://entitybind.com/glossary/crosswalk) (Definition): A crosswalk is a mapping between the identifier schemes that name the same company in different systems — LEI to company number to CIK to ticker — so that data joined on one key can be joined to data keyed on another.

## Start with a file, not an integration.

Create your workspace, verify your email and run your first company file. The Free plan needs no card. Create API keys in your workspace when you need an integration.

[Start free](https://app.entitybind.com/app?signup=1) · [Read the MCP docs](https://entitybind.com/mcp)

300 credits. No card.

For a guided review of your file, explore [the Merge Safety Sprint](https://entitybind.com/audit-pack).

## Questions about Claude Code

### Is the MCP server the same product as the API?

The same product and the same code path. The MCP surface delegates to the same application services the versioned HTTP routes do, so a resolve over MCP is the same resolve: the same cascade — the stages a record walks through, settling at the cheap deterministic checks where the identifiers allow it and reaching model work only where they do not — the same confidence floor, the same evidence, the same credit rule and the same rate-limit bucket. What differs is who is on the other end. The credential's plan caps depth before the cascade runs, so a key pinned to the probabilistic stage cannot reach agentic research by choosing this surface. It abstains instead.

### What does an agent do with an abstention?

Treat it as an answer, because it is one: a ranked shortlist, a typed reason, the column that would have settled the record, and a review id, at no cost. What the agent must not do is present a shortlist row as a match. How often the right company turns up somewhere in the list says nothing about which row is right — on the gated acquisition fixture, the true company was first for 74% (151/205) and inside the top three for 100% (205/205), and 74% sits far below the 0.90 acceptance floor. The stub-adjudicated run behind the pairwise gate, not the 317-company live recording behind the tier table. It is an acceptance contract, not calibration evidence: it says what we refuse to return, not how often an accepted match is right. Read it with the coverage it costs.

---

Internal fixtures only. The historical 2026-08-29 per-tier recording covers 317 GB companies with identifier-rich arrivals seeding the catalogue first; the context tier includes country and registered-town prose. Its legacy replay has no full-prompt-verified calls and cannot certify current calibration. The September 5 CI reports cover 1,176 labelled pairs and 705 records over 250 companies using offline stubs. These are not independent customer holdouts or live production validation; the 99% minimum-input product target remains unmet. Scope is company and organisation identity only — not people, vessels, bank-account ownership, sanctions or emissions. Results may not be used for eligibility decisions about individuals, including employment, credit and tenancy.

Entity Bind resolves companies and organisations only. It does not resolve people, vessels, bank-account ownership, sanctions exposure, emissions or geolocation, and its results may not be used for eligibility decisions about individuals, including employment, credit and tenancy.

This is the Markdown copy of https://entitybind.com/integrations/claude-code, assembled from the same data the page renders and carrying every sentence, table row, figure and question the page's main content carries. The HTML page is canonical; it adds the layout, the navigation and the interactive parts (the ask panel, the forms), which a copy can name but not run. Every page on the site, with a line on each: https://entitybind.com/llms.txt.
