Configure MCP Adapter

Configure MCP lets MCP-compatible agents use Configure profile context, connected tools, and attributed memories without a direct SDK integration.

Developer MCP requires a developer API key. Personal MCP signs into your own Configure profile and does not require a developer API key.

Use it when the agent already speaks MCP, or when you need to connect Configure to a client you do not control. For products where you own the app UI, auth flow, and model loop, the Configure SDK is the power path for in-process control.

Pick the right path

Use case	Choose	What acts as the agent
You want Codex, Claude, Cursor, or another local MCP client to use your own Configure profile	Personal MCP	The selected client, such as /agents/codex/
You are building an MCP-compatible app or hosted agent for your users	Developer MCP	A developer-owned Configure agent backed by an API key
A hosted client asks for an MCP server URL instead of a local command	Hosted MCP URL	A personal MCP connection established via OAuth
You own the app UI, auth flow, and model loop	Configure SDK	Your server-side Configure agent

Personal MCP

Use personal MCP when you are the end user connecting Configure to your own agent client.

npx configure setup

Choose For myself, then choose Codex, Claude, Cursor, or another client. The wizard delegates to personal MCP and signs you into your own Configure profile.

Direct path:

npx -y @configure-ai/mcp login --personal --client codex

The login flow signs you in to Configure and creates a local MCP profile for that client. Writes from that client stay attributed to its namespace, for example /agents/codex/.

For Codex, setup updates ~/.codex/config.toml, which is shared by the Codex desktop app, IDE extension, and CLI. Restart the app you use so it reloads config. Desktop and extension users should start a new chat after restart; CLI users can run /mcp to confirm Configure is connected.

[mcp_servers.configure-codex]
command = "npx"
args = ["-y", "@configure-ai/mcp", "serve", "--profile", "personal:codex"]
startup_timeout_sec = 20

For Claude Desktop, Cursor, or another MCP client, add the generated command to that client's MCP config. Those clients use a JSON mcpServers block (Cursor: project-scoped .cursor/mcp.json; Cursor also reads a global ~/.cursor/mcp.json; Claude Desktop: its claude_desktop_config.json):

{
  "mcpServers": {
    "configure": {
      "command": "npx",
      "args": ["-y", "@configure-ai/mcp", "serve", "--profile", "personal:cursor"]
    }
  }
}

Swap personal:cursor for the client you chose, then restart the client (or start a new chat) so it reloads the config.

Personal MCP does not require a developer API key.

Developer MCP

Use developer MCP when Configure is acting as an adapter for an MCP-compatible agent that you own.

npx -y @configure-ai/mcp login --developer

dev setup is an alias for the same command. It signs you in as a developer in the browser, returns the agent handle and API key from that session, and saves a local dev:<agent> MCP profile. The generated config uses the API key for the selected agent.

Note that npx configure setup > For my users is the SDK path, not the MCP path. It writes CONFIGURE_API_KEY, CONFIGURE_PUBLISHABLE_KEY, and CONFIGURE_AGENT to .env for an SDK install and does not create an MCP profile.

Example MCP client config:

{
  "mcpServers": {
    "configure-atlas-dev": {
      "command": "npx",
      "args": ["-y", "@configure-ai/mcp", "serve", "--profile", "dev:atlas"]
    }
  }
}

serve --profile dev:<agent> also works without a saved profile if CONFIGURE_API_KEY is set in the environment.

Developer MCP still needs a user subject at runtime:

• Use CONFIGURE_USER_TOKEN for a linked Configure user.
• Use CONFIGURE_USER_ID for a developer-scoped app-local user.

Linked users can read portable profile context subject to their Configure permissions. App-local users are scoped to your developer account.

Hosted MCP URL

Some hosted clients ask for an MCP server URL instead of an npx command. Use:

https://mcp.configure.dev

This URL is the personal MCP endpoint. Remote clients authenticate via OAuth: the client discovers /.well-known/oauth-protected-resource and runs the authorization-code + PKCE flow automatically. If the host discovered the tools without presenting an OAuth window, the configure_connect tool returns a connect_url sign-in link as a fallback. Developer MCP uses the API key from login --developer setup.

How it maps to the SDK

MCP is an adapter over the same Configure profile contract that the TypeScript SDK exposes. The difference is how the model calls a tool: in the SDK you route a call through profile.executeTool() in your own loop; over MCP the configure_* tools are surfaced to the model natively and it calls them by name. Code that shows configure.call("configure_profile_read") is docs shorthand for the shape of a tool call, not a real SDK method. The runnable SDK form is profile.executeTool({ name, arguments }), or the typed profile.read, search, remember, and forget methods. An MCP client never writes any of that; it just invokes the native tool.

SDK concept	MCP equivalent
configure.profile({ token })	Linked user token in the MCP profile
configure.profile({ externalId })	Developer-scoped CONFIGURE_USER_ID
profile.tools()	MCP tools/list
profile.executeTool({ name: "configure_profile_read", arguments: args })	The model calls the native configure_profile_read tool
profile.commit()	configure_profile_commit tool

The SDK is better when your server owns the model loop, auth flow, and commit timing. MCP is better when the client already expects tools through the MCP protocol.

Tools

Configure MCP exposes the six configure_profile_* tools, the same set the Configure MCP page documents:

• configure_profile_read
• configure_profile_search
• configure_profile_remember
• configure_profile_commit
• configure_profile_forget
• configure_profile_import (bulk saves; available on the backend MCP surface, which includes personal MCP; not exposed by the local developer SDK-based server or as an SDK tool)

configure_connect mints sign-in links before sign-in and connect-an-app or import links afterward; it is listed on the hosted API-key /mcp endpoint and pre-auth on the OAuth surface. The local dev:<agent> stdio server does not expose it. A fail-closed connector call also returns a connect_url in its own result.

For linked users, connector tools can expose approved Gmail, Calendar, Drive, and Notion access. Action tools can send email or create calendar events when enabled for the MCP profile.

Connector and action tools are hidden for developer-scoped app-local users because those users are not linked to portable Configure accounts.

Boundaries

• Secret keys stay server-side. Do not paste sk_ keys into a browser or client-side app.
• API keys define the acting developer agent for writes.
• Personal MCP ignores developer environment variables.
• User input never chooses a storage namespace.
• MCP setup is separate from SDK installation; use the SDK when you are building Configure directly into your app.