Connect from your IDE with MCP

Model Context Protocol (MCP) lets an AI assistant in your integrated development environment (IDE) work with Connector Studio directly. Supported clients include Cursor, VS Code with Copilot, and Claude Desktop.

Every MCP HTTP request must send the X-Installation header with the installation slug from the MCP Setup page. This header has no default value, and the server rejects any request with a missing, empty, or malformed value. Always copy the snippet from MCP Setup. The one-click install already includes the header.

This page describes Connector Studio MCP, which you use to build connectors from your IDE. For MCP support that exposes banking APIs to agents, see MCP support overview on the Backbase Agent Platform tab.

Work in plain text

After you connect, you don’t need to memorize the tool catalogue to make progress. In your IDE chat, describe what you want in plain text. The assistant selects and calls the matching MCP tools. For example:

Create a connector project for organization A against organization B.
Upload this OpenAPI file as the source specification.
Suggest endpoint mappings and show me what still needs approval.
Approve the pending operation mappings I just reviewed.
Generate JOLT for the approved routes, then prepare a pull request.

You can still open Available Tools and Available Prompts on MCP Setup, or the tool list on the Marketplace listing, when you want the full dictionary. This page keeps the same reference so you have a single source of truth for tool names and phases.

Mapping decisions stay with you. The server never approves an endpoint mapping, a route target, or a property mapping on your behalf. On most clients, including Cursor, read the matching data://pending_* resource, review it in chat, then tell the assistant to call the matching decide_* tool. If your client renders Prefab or MCP-UI, you can use the review widgets instead.

What you can do from your IDE

You can build a complete connector without the web interface. From your IDE, discover organizations, upload specifications, match endpoints, and approve mappings. You can scaffold routes, generate JOLT or XSLT transformations, publish a GitHub pull request, and generate the SDK or the connector. The web interface is an optional parallel surface. Connector Studio stores your mappings and transformations on the platform. Through the mapping and transformation phases, the catalogue lives in Connector Studio only. Your IDE usually holds cs-context.json for MCP session rebind unless you or the assistant wrote files locally. Phase 7 (get_connector_scaffold_plan) is when Grand Central-standard connector files appear in your IDE workspace. Publishing a GitHub pull request is a step you take explicitly at the end. Connector Studio doesn’t sync your repository continuously. If you want to generate, scaffold, bootstrap, or migrate a connector, call start_project_generation on the same connection. Then call get_project_generation_status to learn the next action.

Where catalogue state lives

The following table compares what you see in Grand Central with what lives in your IDE workspace at each stage:

Stage	Grand Central / Connector Studio	Your IDE workspace
After `create_project` or `init`	Project, specifications, mapping workflows	`cs-context.json` and MCP chat
After mapping, routes, and transformation tools (phases 2-6)	Same catalogue data	No required connector project tree unless files were written
After `get_connector_scaffold_plan` returns `status="ready"`	Same catalogue plus generated artifacts in Connector Studio	Scaffold files in the workspace per the plan
After `create_connector_pr`	Pull request link in Connector Studio	Clone the GitHub repository

The connector-studio backend git repository is not your connector project. Open the project in Grand Central Connectors, or call get_project_summary for a web link.

Enable Connector Studio MCP

Before you configure your IDE, install Connector Studio MCP from the Marketplace:

Open the Marketplace

Grand Central Marketplace MCP Servers tab with the Connector Studio card

Install Connector Studio MCP

Find Connector Studio and select Cursor or VS Code, depending on your IDE.

Connector Studio MCP server in the Marketplace showing the Available tools tab

The Marketplace install adds the server to your client. You still need the token and the X-Installation header from MCP Setup before you can connect.

Get your connection details

Connector Studio MCP is shared for each runtime, such as Dev or PreProd. The X-Installation header and the path prefix of your Grand Central URL together select your installation.

Never copy an MCP URL or a token from documentation. Always use the values that MCP Setup shows for your own installation.

Open MCP Setup

Sign in to Grand Central, select your installation, then open MCP Connection Setup, for example at /your-installation/mcp-setup.

Wait for the configuration to load

Wait until Client Configuration appears. The page lists the Available Tools and Available Prompts that the server reports.

Check the snippet

Confirm that the snippet includes both an Authorization: Token … header and an X-Installation header.For a standard catalogue connection, confirm that Available Tools includes start_project_generation, continue_project_generation, get_project_generation_status, and decide_operation_mapping.

The MCP Setup page generates an installation-specific client configuration key and includes the matching X-Installation header in the snippet.

Install the server in your client

Prerequisites

Before you install, make sure you have the following:

A Microsoft sign-in to Grand Central.
An MCP client that supports remote HTTP or server-sent events (SSE) transport, not only local stdio servers. The following clients work:
- Cursor, which supports a one-click install link.
- VS Code with MCP support or Copilot Chat.
- Claude Desktop 1.0 or later, which needs manual JSON configuration.

Option A: Install in Cursor with one click

On the MCP Setup page, select the one-click install link. Cursor fills in the server URL, the server name, and the headers, including X-Installation.

Option B: Configure Cursor or Claude Desktop by hand

Add the exact block from MCP Setup to ~/.cursor/mcp.json or to claude_desktop_config.json, then replace YOUR_TOKEN with the token from that page. The block has the following shape. Your own URL, server name, and installation slug come from MCP Setup:

{
  "mcpServers": {
    "connector-studio-example": {
      "url": "https://your-mcp-endpoint.example/mcp",
      "headers": {
        "Authorization": "Token YOUR_TOKEN",
        "X-Installation": "YOUR_INSTALLATION_SLUG"
      }
    }
  }
}

Use one token for one environment. Do not mix tokens between environments, and do not omit the X-Installation header.

Option C: Configure VS Code

Where MCP Setup offers a VS Code install link, select it. Otherwise, paste the server block into your VS Code MCP configuration, as the Microsoft MCP documentation describes.

Verify the connection

Restart your client

Restart Cursor, VS Code, or Claude Desktop, then confirm that the server appears in the MCP server list.

Check your identity

In your IDE chat, ask the assistant to call who_am_i. The response confirms your authentication and user context.

Check the session

Ask the assistant to call get_session_status. The response confirms that no project is bound to the session yet.

If authentication fails, and especially if the X-Installation header is missing, generate a new token on MCP Setup and update your configuration. After you verify the connection, return to Work in plain text. Describe the next outcome you want in chat so the matching MCP tools run.

How MCP sessions work

Bind a session to a project

Most tools need an MCP session that is bound to a connector project. The following table describes the tools that manage this binding:

Tool	What it does
`init`	Binds the session to an existing project, identified by `project_id`, an exact `project_name`, a `git_url`, or a `cs-context.json` file
`create_project`	Creates a project and binds the session to it. Requires the Builder role or higher.
`get_session_status`	Reports whether a project is bound to the session

After create_project or init succeeds, the response includes a cs_context object. Save it as cs-context.json in your repository. The saved cs_context blob is for MCP session rebind (context_id, project_id, project and organization names). It is not an OpenAPI specification, mapping export, or connector code. Connector catalogue state lives in Connector Studio. If you lose cs-context.json, call init with project_id, exact project_name, or git_url. Approved mappings are not lost. To reconnect later, call init with cs-context.json or with the project_id.

How installations and workspaces apply

The X-Installation header is required on every MCP HTTP request. It selects the workspace catalogue for your installation, and MCP has no default.
The init tool also accepts an exact workspace_name. If you send both values, they must resolve to the same installation.
Vendor specifications and projects follow the workspace catalogue. MCP doesn’t create a separate private catalogue for each developer.

Upload a specification

Start the upload

Call start_spec_upload to get an upload target.

Post the file

Send an authenticated multipart POST request, using the same Authorization headers as your MCP configuration.

Wait for the result

Call get_upload_job with the task_id and a wait_seconds value, such as 30.

Never pass the bytes of a specification as an MCP tool argument, and don’t paste a large OpenAPI file into chat. If an upload fails, call start_spec_upload again and repeat the POST request. Do not retry an old task_id.

Review and decide

You approve every mapping yourself, and you can do it entirely on MCP without the web interface. On most clients, including Cursor, read the matching data://pending_* resource, review it in chat, then tell the assistant to call the matching decide_* tool. If your client renders Prefab or MCP-UI, you can use the review widgets instead. The following table lists the resource and tool for each review stage:

Stage	Resource to read	Tool to call	Review widget
Endpoint candidates	`data://pending_operation_mappings`	`decide_operation_mapping`	`open_operation_mapping_review`
Route targets	`data://pending_route_targets`	`decide_route_target`	`open_route_target_review`
Property mappings	`data://pending_property_mappings`	`decide_property_mapping`	`open_property_mapping_review`

To find out which step comes next, call get_mapping_resources. It returns mapping_status.review_guidance, which names the recommended_next_tool, the pending_resource, and the decide_tool. decide_* responses are compact. Read data://pending_* for the full queue.

Choose a workflow

The following table describes which MCP prompt or path to use for your situation:

Your situation	MCP prompt or path
New connector from vendor and Grand Central specifications	`new_connector_guide`
Migrate an existing integration	`convert_existing_connector_guide`
Generate, scaffold, bootstrap, or migrate (ambiguous goal)	`start_project_generation`, then `get_project_generation_status`
Skeleton only from a specification file (no live mapping)	`scaffold_connector_from_spec` or `get_connector_scaffold_plan(mode="scaffold")`
Build a vendor SDK	`build_sdk_guide`

In Cursor, start with the new_connector_guide prompt on MCP Setup under Available Prompts. Optional parameters include source_spec_name and target_organization. Prefer plain-text goals in chat when you’re unsure which prompt to pick. The assistant can call start_project_generation and follow get_project_generation_status.

Tool and phase reference

Use this section when you need exact tool names. The following table summarizes the flow for a new connector. For UI equivalents, see Map endpoints and fields, Transformations and generated code, and Design routes with Route Builder.

Phase	Goal	Key tools
1	The project exists and the source specification is linked	`search_organizations`, `create_project`, `set_source_spec`, `start_spec_upload`
2	Endpoint candidates are generated	`generate_target_candidates`, `get_mapping_resources`
3	You approve the endpoint mappings	`data://pending_operation_mappings`, `decide_operation_mapping`
4	The routes are scaffolded	`scaffold_routes`
4b	You link the routes to their targets	`decide_route_target`, `assign_route_target`
5	You approve the schema mappings	`run_schema_mapping`, `decide_property_mapping`
6	JOLT or XSLT transformations and generation context exist	`generate_route_jolt`, `get_route_generation_context`, `validate_connector`
7	Grand Central-standard connector files exist in your workspace	`get_connector_scaffold_plan`, `prepare_connector_pr`, `create_connector_pr`

Practical constraints:

Don’t proceed past phase 1 until source_specs is non-empty. There is no set_target_spec tool. Target specifications bind in phase 2 through target_spec_ids on generate_target_candidates.
Don’t skip route target linking (phase 4b). Unlinked routes produce empty transforms in phase 6.
Poll get_mapping_resources until endpoint or schema mapping finishes before you open the matching review. Opening review too early shows zero attributes.
Completing phase 6 means the catalogue is ready in Connector Studio. Phase 7 materializes Grand Central-standard files locally through get_connector_scaffold_plan(mode="complete"). Continue only when status="ready" and materializable=true. Call prepare_connector_pr before create_connector_pr.

Generate a connector in one step

To generate, scaffold, bootstrap, or migrate a connector, call start_project_generation on the same connection instead of working through each phase by hand. Then poll get_project_generation_status and use continue_project_generation or provide_generation_input when the status reports a blocker. The server resolves SDK versus connector goals and catalogue versus brownfield strategies. When catalogue data is insufficient, brownfield bootstrap may apply if bounded source files are present. When scope or evidence is missing, the status returns structured action_required instead of guessed files.

Connector Studio overview
Get started with Connector Studio
Map endpoints and fields
Transformations and generated code
Design routes with Route Builder
Connector Studio glossary, which defines the MCP terms used on this page

Overview

Capabilities

Developer guides

Security and reliability

Platform administration

Connector Studio

Reference

Work in plain text

What you can do from your IDE

Where catalogue state lives

Enable Connector Studio MCP

Get your connection details

Install the server in your client

Prerequisites

Option A: Install in Cursor with one click

Option B: Configure Cursor or Claude Desktop by hand

Option C: Configure VS Code

Verify the connection

How MCP sessions work

Bind a session to a project

How installations and workspaces apply

Upload a specification

Review and decide

Choose a workflow

Tool and phase reference

Generate a connector in one step

​Work in plain text

​What you can do from your IDE

​Where catalogue state lives

​Enable Connector Studio MCP

​Get your connection details

​Install the server in your client

​Prerequisites

​Option A: Install in Cursor with one click

​Option B: Configure Cursor or Claude Desktop by hand

​Option C: Configure VS Code

​Verify the connection

​How MCP sessions work

​Bind a session to a project

​How installations and workspaces apply

​Upload a specification

​Review and decide

​Choose a workflow

​Tool and phase reference

​Generate a connector in one step

​Related topics

Work in plain text

What you can do from your IDE

Where catalogue state lives

Enable Connector Studio MCP

Get your connection details

Install the server in your client

Prerequisites

Option A: Install in Cursor with one click

Option B: Configure Cursor or Claude Desktop by hand

Option C: Configure VS Code

Verify the connection

How MCP sessions work

Bind a session to a project

How installations and workspaces apply

Upload a specification

Review and decide

Choose a workflow

Tool and phase reference

Generate a connector in one step

Related topics