> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.mitu.ai/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.mitu.ai/_mcp/server.

# MCP

Your application already serves customers through interfaces such as your website, mobile application or API. MCP gives you another channel by allowing compatible AI clients to discover and use selected capabilities from the API you already run.

You do not need to rebuild your product around AI agents or maintain a separate agent-facing backend. Choose the operations you want agents to use, describe those operations clearly and define the request and response schemas they already understand. Your API remains responsible for your data, business logic, customer accounts and fulfilment.

## What Mitu provides

Mitu provides the MCP layer between compatible AI clients and your existing API. It publishes the tools you make available, provides the descriptions and schemas agents use to understand them, handles supported customer authentication and forwards requests to the corresponding operations on your backend.

Paid operations can also participate in Mitu's agent payment flow. You configure which operations are paid and how they are priced, while Mitu handles the payment interaction with the agent before the paid request reaches your API.

Your backend does not need to implement MCP transport or separate payment protocols simply to make an existing operation available to agents.

## From API operation to tool

An operation becomes available to an AI agent when you register it as an MCP endpoint. The endpoint connects an operation on your API with the information an AI model needs to decide when and how to call it.

For example, an ordering API might make the following operations available:

| Tool                  | API operation      | Purpose                                                       |
| --------------------- | ------------------ | ------------------------------------------------------------- |
| `get_menu`            | `GET /menu`        | Retrieve the current menu and available items.                |
| `check_delivery_zone` | `GET /zones`       | Check whether an address can be served.                       |
| `create_order`        | `POST /orders`     | Create an order after the customer has confirmed the details. |
| `get_order`           | `GET /orders/{id}` | Retrieve the current state of an existing order.              |

The agent sees the tool name, description, usage guidance and schemas you configure. It does not need to understand the internal structure of your application or every route your backend serves.

Only make operations available when they are meaningful for an AI agent. Connecting your API does not automatically publish every endpoint.

## Keep your API authoritative

MCP changes how a client reaches your product, not where your business rules live. Your existing API should remain authoritative for prices, stock, availability, account permissions, order state and other information that can change over time.

Avoid placing volatile business information directly in tool descriptions. Instead, give the agent a tool that retrieves the current value from your API. This keeps the information an agent acts on aligned with the same source your other clients already use.

## Customer access

Tools can be public or require an identified customer. Where customer authentication is required, customers can connect using a customer key or through your existing OAuth sign-in flow.

OAuth lets the customer continue using the account they already have with your product. Their access token can be forwarded with requests so your backend continues applying its existing authentication, authorisation and entitlement rules.

Customer authentication identifies **who the agent is acting for**. It is separate from [Request verification](/platform/security/request-verification), which confirms that the request itself came through Mitu.

See [MCP authentication](/platform/mcp/authentication) for both authentication methods.

## Paid operations

An MCP tool can be free or paid. For paid operations, configure the pricing model that determines what the agent needs to pay before your API fulfils the request.

Mitu handles the payment flow with the agent and forwards the request to your API once the required payment has been completed. Your backend then verifies that the request came through Mitu and processes it using the same business logic it already uses.

See [Pricing](/platform/payments/pricing) and [Agent payments](/platform/payments/agent-payments) for the payment model.

## MCP endpoint

Compatible AI clients connect to your MCP endpoint using Streamable HTTP. You can use a Mitu-hosted endpoint or configure your own MCP domain.

```text
https://mcp.mitu.ai/mcp

https://mcp.yourdomain.com/mcp
```

See [Domains](/platform/mcp/domains) for configuring a custom MCP hostname.

## Instructions

You can provide instructions that apply to the MCP experience as a whole. Use them for guidance that is broader than a single tool, such as important product rules, sequencing expectations or behaviour that should apply across several capabilities.

Keep operation-specific guidance in the endpoint's `description` and `when_to_use` fields. Global instructions should not become a replacement for clear individual tool definitions.

## Related

#### [Endpoints](/platform/mcp/endpoints)

Configure the API operations you want AI agents to use.

#### [Tool schemas](/platform/mcp/tool-schemas)

Describe the request and response shapes your tools use.

#### [Authentication](/platform/mcp/authentication)

Identify customers using customer keys or OAuth.

#### [OpenAPI import](/platform/mcp/open-api-import)

Create endpoint definitions from an OpenAPI document.

#### [Domains](/platform/mcp/domains)

Configure the MCP URL customers connect to.

#### [Bring your product to AI agents](/guides/use-cases/agent-channels)

Follow the end-to-end guide for making your product available through MCP.