Skip to content

MCP

MCP (Model Context Protocol) is a standard by which a program offers tools to a model. An MCP server offers tools; an MCP client connects to it and calls them. So MCP is not a kind of tool but a way to connect tools.

Core uses MCP in two directions. They solve different problems and you set them up in different places.

flowchart LR
    ext["MCP server of yours or a vendor's<br/>for example a ticket system"]
    core["Core"]
    client["MCP client<br/>coding assistant or your own agent"]
    core -->|"1. Core uses the server's tools"| ext
    client -->|"2. The client uses Core as a server"| core

Direction 1: Core uses an MCP server

You register an MCP server in your organisation. Core reads the server's tool list, and you choose which tools you allow. Those tools then sit among your organisation's other tools as mcp__<server>__<tool>, and an agent or a request offers them to the model. Every registered server is also a toolset of its own tools.

When: a system your agent has to use already has an MCP server, yours or a vendor's. When it only has an HTTP API, an API connector is the shorter route.

You store the credential for the server with the registration. The server can also require each person to sign in themselves; the tools then act on behalf of the person the turn is for. Some of the Artific Connect bundles work this way, for example GitHub.

Read on: MCP servers in the console and MCP servers in the API.

Direction 2: Core is an MCP server

An MCP client outside Core, such as a coding assistant or an agent you run yourself, connects to Core and uses Core as tools. There are three endpoints:

Endpoint What the client gets Sign in with
POST /api/v1/mcp every API operation of Core as a tool, as far as the key may perform it: create_skill, search_index, create_response an API key
POST /api/v1/mcp/toolsets/{name} one of your own toolsets as a server: your API connectors, MCP servers, search tools and the rest, run by Core an API key
POST /api/v1/management/mcp the management operations for the organisations you administer signing in as an administrator

When the first: you want to operate Core from an assistant: store a prompt, search an index, update an agent, without writing HTTP calls yourself.

When the second: you have put together a set of tools in Core, with credentials, policy and metering, and want to use it in an agent that does not run in Core as well. The client gets the tools; the credentials stay in Core.

When the third: an administrator wants to manage organisations, keys and usage from an assistant, with the same rights as in the console.

Core applies the same checks and the same recording to every tool call as to an HTTP call. On the two key endpoints the client sees only the tools the key can really use. The management endpoint lists every management tool; a tool you may not use refuses when you call it.

Read on: Use Core from an MCP client.

Core operations in a turn

The same operations from direction 2 can also be given to a turn inside Core, without an MCP client. They are then called core__<tool>, for example core__create_skill, and you offer them like any other tool. That is how an agent in Core can store a skill or search an index itself. A core__ tool runs as the turn's key and reaches what that key reaches (Give an agent the platform).

The two directions side by side

Core uses an MCP server Core is an MCP server
Who runs the tool the external server Core
Who calls a model in a turn of Core a client outside Core
Where you set it up the organisation's MCP servers section in your MCP client, with Core's address
Capability tooling what the operation requires; tooling for a toolset

How it fits together

  • A registered MCP server is one of the sources of tools, beside API connectors, built-in tools and search tools.
  • The key's policy decides about an MCP tool as about any other tool.
  • A toolset is the unit in both directions: a registered server becomes a toolset, and a toolset can be offered as a server.
  • An MCP server can go into a publication, and an installer can choose a server of their own in its place.

Read on

Tutorial: Connect an external capability through MCP.