Skip to main content

Documentation Index

Fetch the complete documentation index at: https://docs.getmcp.com/llms.txt

Use this file to discover all available pages before exploring further.

GetMCP sits between your AI client and any REST API. It translates MCP protocol messages into HTTP requests — and HTTP responses back into MCP protocol messages — without you having to write a line of protocol code. 
AI Client (Claude, Cursor, Windsurf)
        │
        │  MCP Protocol — JSON-RPC 2.0 over HTTP
        ▼
   WordPress + GetMCP
        │
        │  Configured HTTP request (GET / POST / PUT / etc.)
        ▼
   Your REST API (Stripe, GitHub, your own backend, etc.)

​
The Request Lifecycle

Here is exactly what happens when an AI client calls one of your tools:
1

AI client sends a tools/call request

The AI client (Claude Desktop, Cursor, etc.) sends a JSON-RPC 2.0 POST request to your GetMCP server URL:
POST https://yoursite.com/mcp/my-server
Content-Type: application/json

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "get_customer",
    "arguments": { "customer_id": "cus_123" }
  }
}
2

GetMCP authenticates the request

If your server has inbound authentication enabled, GetMCP checks the Authorization header against the credential you configured. Requests without a valid credential are rejected with HTTP 403 before any API call is made.
3

GetMCP looks up the tool

GetMCP finds the get_customer tool in your server configuration and reads:
  • The endpoint URL (https://api.yourcrm.com/customers/{customer_id})
  • The HTTP method (GET)
  • The input schema (to validate customer_id is present and a string)
  • The parameter mappings (customer_id → path variable)
  • The Custom Headers (your CRM API key)
4

GetMCP validates the arguments

The arguments ({"customer_id": "cus_123"}) are validated against the tool’s JSON Schema. If a required parameter is missing or the wrong type, GetMCP returns an error immediately — no upstream request is made.
5

GetMCP builds and sends the HTTP request

GetMCP constructs the outbound HTTP request, injecting:
  • Path variables into the URL: https://api.yourcrm.com/customers/cus_123
  • Query params, if any, appended to the URL
  • Body params into the JSON body, if a POST/PUT/PATCH
  • Custom Headers (your production API key, never visible to the AI client)
GET https://api.yourcrm.com/customers/cus_123
Authorization: Bearer sk_live_your_crm_key
6

Your API responds

Your API processes the request and returns a response — typically JSON:
{
  "id": "cus_123",
  "name": "Jane Smith",
  "email": "[email protected]",
  "plan": "pro",
  "created_at": "2024-01-15T10:30:00Z"
}
7

GetMCP wraps the response in MCP format

GetMCP converts the API response into a valid MCP tools/call response — a JSON-RPC result containing the API response body as a text content block:
{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "content": [
      {
        "type": "text",
        "text": "{\"id\":\"cus_123\",\"name\":\"Jane Smith\",\"email\":\"[email protected]\",...}"
      }
    ]
  }
}
8

GetMCP logs the call

The call is recorded in the analytics database: timestamp, server, tool name, client type, client IP, HTTP status, response time in milliseconds. Credentials are never logged.
9

The AI client reads the result

Claude (or Cursor, or whichever client) receives the MCP response and uses the data to compose its reply to the user. The user sees a natural-language answer — not raw JSON.

​
What GetMCP Is Responsible For

ResponsibilityGetMCPYou
MCP protocol (JSON-RPC 2.0)Handles automatically—
Streamable HTTP transportHandles automatically—
Session managementHandles automatically—
Tool schema validationHandles automatically—
Inbound authenticationConfigure in Auth tabShare URL with clients
Outbound API credentialsStore in Custom HeadersProvide the keys
HTTP request constructionHandles automaticallyConfigure endpoints + mappings
Response → MCP formatHandles automatically—
Call logging & analyticsHandles automaticallyReview in dashboard
Rate limitingConfigure per server/tool—
Retries on failureConfigure retry count—
Response cachingConfigure cache TTL—

​
Tool Discovery (tools/list)

Before calling any tool, an AI client first calls tools/list to discover what’s available. GetMCP returns the name, description, and input schema for every active tool on the server. 
Claude connects to GetMCP server
  ↓
GET tools/list
  ↓  returns: get_customer, create_order, list_products …
Claude reads descriptions to understand what each tool does
  ↓
User: "Look up customer cus_123"
  ↓
Claude calls tools/call → get_customer
This is why tool descriptions matter so much. The AI’s decision to call a tool — and which arguments to pass — is based entirely on the description you write. See Best Practices for how to write descriptions that work.

​
Resources and Prompts

Beyond tools, GetMCP also serves two other MCP protocol capabilities: Resources — Read-only data the AI can pull on demand. When a client calls resources/read, GetMCP fetches the configured content (static text, external URL, or WordPress query result) and returns it as a content block. The AI can use this as context without triggering an action. Prompts — Reusable instruction templates. When a client calls prompts/get with argument values, GetMCP renders the template (substituting {{argument_name}} placeholders) and returns the complete prompt text.

​
What Runs on WordPress

GetMCP is a WordPress plugin. Everything runs inside your WordPress installation:
  • The MCP endpoint is a WordPress REST route registered at /mcp/{slug}
  • The admin UI lives in wp-admin under the GetMCP menu
  • All config (servers, tools, credentials) is stored in the WordPress database — credentials encrypted with libsodium
  • All outbound HTTP requests are made by WordPress using wp_remote_request()
  • Analytics are stored in custom database tables created on plugin activation
No external service is involved in request handling. Requests go: AI client → your WordPress server → your upstream API. GetMCP never sees your traffic — it runs on your infrastructure.

​
Performance Characteristics

FactorDefaultConfigurable
Request timeout30 secondsYes, per tool
Retry on failure0 retriesYes, 0–5 per tool
Response cacheNoneYes, TTL per tool
Rate limit60 req/minYes, per server and tool
Caching is particularly useful for tools that call read-only endpoints with data that doesn’t change frequently (product catalogs, reference data, documentation). Set a Cache TTL on those tools to reduce upstream API calls and improve response times.