Kilevel as an MCP server

Use Kilevel from Claude, ChatGPT, IDEs and any other MCP client — list flows, read call history and trigger calls with the same API key.

Kilevel is itself a Model Context Protocol server. Point an MCP-capable assistant or IDE at it, and it can work with your Kilevel workspace in conversation: "place a call to this lead with the sales flow", "summarise yesterday's failed calls".

Connecting

The server lives at:

https://api.kilevel.com/api/mcp

It authenticates with a normal API key, sent as X-API-Key or as a bearer token:

X-API-Key: $KILEVEL_API_KEY
Authorization: Bearer $KILEVEL_API_KEY

A token from an OAuth2 client works the same way, as Authorization: Bearer, and is the better choice for an assistant you do not control: it expires, and revoking the client cuts access without rotating anything else. The client's permissions decide which tools work, because every tool call is executed against the public API with the credential you connected with.

A typical client configuration looks like this — the exact format depends on the client:

{
  "mcpServers": {
    "kilevel": {
      "url": "https://api.kilevel.com/api/mcp",
      "headers": { "X-API-Key": "your-key-here" }
    }
  }
}

The server acts on the workspace the key belongs to, and only on that workspace.

Tools

Area	Tools
Calls and chats	`trigger_outbound_call`, `trigger_outbound_chat`, `get_call_history`, `get_chat_history`, `get_chat_messages`
Call jobs	`list_call_jobs`, `get_call_job`, `get_call_job_rows`
Flows and agents	`list_flows`, `get_flow`, `create_flow`, `list_agents`
Knowledge	`get_agent_knowledge_base`, `create_agent_knowledge_base_item`
Tools and outputs	`list_tools`, `get_tool`, `create_tool`, `list_structured_outputs`, `create_structured_output`
Data	`list_applications`, `list_data_stores`, `get_data_store_schema`, `get_data_store_records`
Account	`list_phone_numbers`, `get_balance`

Smart-MCP

The Smart-MCP endpoint is the same server, but a client sees only the tools that fit what it is connected for, instead of all of them:

https://api.kilevel.com/api/mcp/smart?context=analyze

context is a preset or a sentence:

Context	Tools the client starts with
`build`	Flows, tools, structured outputs and agent knowledge
`operate`	Triggering calls and chats, phone numbers and call jobs
`analyze`	Call and chat history, and call job results
`data`	Applications and data stores

Combine presets with commas, for example build,data. Anything else, such as "summarise yesterday's failed sales calls", is routed by Jev, Kilevel's System One model, when the client connects. Without a context, the client starts with a small set for finding its way around. A client that cannot change the URL can send the context in an X-MCP-Context header instead.

Two tools are always listed:

discover_tools: the client describes a task, the matching tools are added to its list, and the server notifies the client that its tool list changed. The result also includes each tool's input schema.
run_tool: runs any Kilevel tool by name, for clients that do not refresh their tool list.

The context only narrows what the client is shown. What it may do is still decided by the API key: tools switched off for the key stay off, exactly as on the standard endpoint.

Limiting what a client can do

Individual tools can be switched off per API key, so a key handed to an assistant can, for example, read history without being able to place calls. Combine that with a key limited to custom permissions.

Warning

An assistant with trigger_outbound_call can place real, billed calls. Give it a key scoped to what you actually want it to do.

Delegating to a published agent

A separate endpoint exposes one published agent as an MCP server:

https://api.kilevel.com/api/mcp/agents/{agentId}

Any Kilevel user can connect to it with their own API key and hand the agent work. The work is billed to the caller, and the agent's owner is paid for it.