> ## Documentation Index
> Fetch the complete documentation index at: https://agenticbanking.backbase.io/llms.txt
> Use this file to discover all available pages before exploring further.
# Connect from your IDE with MCP
> Use Model Context Protocol (MCP) to build connectors from Cursor, VS Code, or Claude Desktop.
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](/agentic-ai/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:
Sign in to Grand Central, select your installation, then open **Development** > **Marketplace** > **MCP Servers**.
Find **Connector Studio** and select **Cursor** or **VS Code**, depending on your IDE.
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.
Sign in to Grand Central, select your installation, then open **MCP Connection Setup**, for example at `/your-installation/mcp-setup`.
Wait until **Client Configuration** appears. The page lists the **Available Tools** and **Available Prompts** that the server reports.
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**:
```json theme={"system"}
{
"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 Cursor, VS Code, or Claude Desktop, then confirm that the server appears in the MCP server list.
In your IDE chat, ask the assistant to call `who_am_i`. The response confirms your authentication and user context.
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](#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
Call `start_spec_upload` to get an upload target.
Send an authenticated multipart POST request, using the same `Authorization` headers as your MCP configuration.
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](/connector-studio/mapping-workflows), [Transformations and generated code](/connector-studio/transformations), and [Design routes with Route Builder](/connector-studio/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.
## Related topics
* [Connector Studio overview](/connector-studio/overview)
* [Get started with Connector Studio](/connector-studio/get-started)
* [Map endpoints and fields](/connector-studio/mapping-workflows)
* [Transformations and generated code](/connector-studio/transformations)
* [Design routes with Route Builder](/connector-studio/route-builder)
* [Connector Studio glossary](/connector-studio/reference/glossary), which defines the MCP terms used on this page
