Connect Agents

Connect Agent sets up an AI agent to use the B2C MCP server of this project. Each agent connects over HTTP under its client ID, with a client key of its own, and the IDE keeps what that agent may see and reach

Open it

• On the Server tab, pick the agent in the Agent selector and click Connect Agent… under it
• Connect Agent… in the B2C MCP title bar, then pick the agent
• Tools › Salesforce B2C Commerce › B2C MCP › Connect Agent…

The Agent selector shows the picked agent and its status. Open it to see every agent: its name, its client ID when it is not the agent's own, its status, and under them where its config goes and its open sessions. Hover the selector, or an agent in the open list, and its card shows at once: its status, why it has it, its client ID, its sessions and where its config goes. Under the selector, Add SFCC Skills… for the picked agent, Revoke Client Key, Renew All Client Keys… and How client keys work, see Client keys. Each name sits above its field at any width. The buttons sit two to a row in even columns from the left, or one under another in a narrow tool window, so nothing is cut

Agent status

The status at the end of each row says how far that agent is set up. Hover the row to see why and what to do next

The agents come in the same order as in VS Code: Codex, Claude Code, OpenCode, Cursor, Junie and AI Assistant, GitHub Copilot, Gemini CLI, then Windsurf and any other MCP client. The first one is picked when the tab opens, and Connect Agent… in the title bar opens for it. The IDE never picks an agent for you. It reads only whether the client key in a config is current and never shows the client key

The dialog has two panes. On the left, what this agent gets. On the right, how it connects. Drag the line between them to give either more room

The first time the dialog opens, four tips point at the agent, its tools, instances and skills, the four ways to connect and Test Connection, see Guide

The agent

Under Client ID, a line says the status of this client ID and what to do next. The open Agent: list shows each agent's status in grey

Tools, instances and skills

Under the agent, three numbered steps: 1 Tools, 2 Instances and 3 SFCC Skills, each with how many this agent gets after its title. Click a step, or use the arrow keys, to open it. What you pick in Tools and Instances applies at once to this client ID, also to an agent that is already connected. Nothing in the agent's own config can widen it

Tools

Pick how many tools this agent lists:

The tree under the choice shows every tool by toolset, with the ones this agent sees ticked. Tick or untick a tool to make the choice Custom. Type in the tree to find a tool. Short descriptions and schemas lists your custom tools with the shorter text of Compact

Every choice can only narrow what the Tools tab gives every agent

A greyed tool reads off for every agent: the preset or the Tools tab keeps it from all agents, see Tools & Presets. The line under the tree counts the tools this agent sees and warns when an agent with a limit gets more, such as GitHub Copilot takes up to 128

Instances

Every instance, also ones added later lets the agent reach every B2C instance of the project. Untick it and tick the instances the agent may reach. The instances sit in groups by kind, Production first, then Staging, Development, Sandbox and unknown kinds. Each group shows its kind in its colour and how many of its instances the agent reaches, such as 1 of 2, and its tick picks the whole group. Each instance shows its connection's name and hostname, with its cloud in colour while the agent reaches it. Type in Filter instances to find one by name, hostname or kind

A call that names another instance is refused before it reaches it, and the agent is told to ask you. See Instances for what agents may do on each one

SFCC Skills

Skills teach the agent how SFCC works: the platform's rules and limits, and frameworks such as SFRA, cartridges, ISML, hooks, jobs, SCAPI and Page Designer. Each skill also names the Intellij SFCC tools to call at each step, so the agent works from your project's code, metadata and instances

The step says whether the project has this agent's skills: Not added, Added or To update, with the folder the agent reads them from. A short animation shows the agent reading the skills, then calling the SFCC tools of this IDE

Add SFCC Skills… opens the skills dialog for this agent's format, see Skills. When you close the dialog after connecting an agent whose skills the project does not have yet, it asks once whether to add them

Connect it

At the top of the right pane, Config for picks where the config goes:

The address names this project, so an entry for All projects always reaches it, whichever folder the agent runs in. Config for shows for agents that have both, see Agents, and keeps your pick for next time

Under it, four ways to connect the agent. Pick one:

All four are made from the config in Config File, so an edit there reaches the values, the command and the prompt. After each copy, the line under the buttons says what was copied and where it goes

Config File

The config the agent reads, in a full IDE editor:

• Highlighting, line numbers, folding and undo, as in any file of that type
• For JSON configs, completion and checks for mcpServers, servers, OpenCode's mcp, the URL fields and the headers the server reads. Hover a field for what it does
• The client key shows as dots. The copies, Write Config, Test Connection and Run Command put the real client key where the dots are
• Explain fields in the editor header puts a few words at the end of each line of our entry, such as This project on this computer beside the URL. They follow your edits. Turn it off to see the config alone
• Reset Config in the editor header brings back the config the dialog made

Edit it as you like, such as adding a field your agent reads. The dialog refuses a config that would send the client key off this computer: the client key may only sit in the Authorization header of an entry whose address is 127.0.0.1, localhost or [::1]

What Write Config changes

Write Config changes only the entries for this project and keeps the rest of the file as you wrote it:

• Comments, trailing commas, order, indent and line ends stay
• Changes you haven't saved yet in an open editor count
• Older entries for this project go, such as one under an earlier MCP name. Our entry takes the place of the first one
• For OpenCode, the server goes right under mcp, or into mcp.servers when the file already keeps its servers there, as OpenCode 2 does
• The write is one step that Undo takes back

The dialog leaves the file as it is and tells you why, with the line, when:

• The file isn't JSON (comments allowed) or TOML the dialog can read
• Its servers are set in a form it can't change safely, such as Codex's mcp_servers.solo.url = … or an inline table
• The file changed after the diff opened. Click Write Config again to see the new diff

Fix the file, or copy the config into it by hand

After Write Config

A file in the project holds the agent's client key, so Write Config adds it to .git/info/exclude. When Git already tracks the file, the dialog says so and shows the git rm --cached command that stops tracking it

A file in your home folder needs no such step. Claude Code makes ~/.claude.json the first time it starts, so until then the dialog says so and Command adds the server instead

When the file is already right, the dialog says so, such as .mcp.json is already up to date

Either way, the dialog then tests the connection by itself, see Test Connection

URL and Headers

For a client that asks for the server's values one by one in its settings. Each row has the value, its own Copy and what it means:

Command

Claude Code and Gemini CLI have a command of their own that adds the server:

• The command shows one part a line, highlighted as in a terminal, with the client key as dots
• Run Command runs it right in the dialog, in a console under the buttons. It runs without a shell, so your shell profile doesn't run first and your shell history never holds the client key. The console shows what the command prints, with the client key as dots, and the dialog then tests the connection by itself
• Copy Command copies it on one line with the client key. Run it in a terminal in the project folder
• Running it again replaces the earlier entry
• When the dialog can't find claude or gemini on your PATH, it says so. Install the agent, or copy the command into a terminal where it runs

For the other agents, Command says the agent has no such command and points you to Config File, URL and Headers or Setup Prompt

Setup Prompt

Copy Setup Prompt copies a request with the config, the command where the agent has one, and the client key. Paste it into a chat with the agent. The agent:

• Adds the server to its file in the project, to its own file in your home folder for All projects, or to its MCP settings
• Keeps a file in the project out of Git, and the client key secret
• Removes older entries for this project
• Calls intellijsfcc_project_context to check the connection

Agents

Every agent starts with Global. GitHub Copilot takes up to 128 tools and Junie up to 100, so pick Default or Compact for them when the Tools tab gives more

No call takes longer than 45 s. Longer work returns a handle the agent polls, so the agents' own timeouts never cut it off

With every choice of tools the agent opens with intellijsfcc_project_context. When a task needs a tool the agent can't see, it tells you which one, and you decide

Any MCP client

Pick Any MCP client for a client the list doesn't name. It works with any client that speaks Streamable HTTP, the transport of current MCP clients. Its config:

{
  "mcpServers": {
    "acme": {
      "type": "http",
      "url": "http://127.0.0.1:64780/mcp/p/3f9a1c7e",
      "headers": {
        "Authorization": "Bearer <the client key of this agent>",
        "X-Intellij-SFCC-MCP-Client": "other",
        "X-Intellij-SFCC-MCP-Agent-Family": "other"
      }
    }
  }
}

When your client takes values in a form rather than a file, use URL and Headers

Test Connection

Test Connection under the four ways sends what the config sends and shows the answer. Close closes the dialog

Above it, a line shows the way the agent's calls take: the agent and its client ID, the B2C MCP server with its address, and the project with the tools and instances this agent reaches. The line to the server is dashed while the server is stopped, and Start Server shows beside Test Connection

During a test, the agent's client key travels along the line. It lands on the project when the call gets through, or stops at the part that failed with the reason under it. The same happens when the agent opens a session while the dialog is open. Write Config runs the test by itself after it writes the file

Test results

Client keys

Every agent calls under a client ID, its own name by default, and gets a client key for that client ID the first time you write, copy or run its config. The client key is the secret in its config: the agent sends it with every call, so the server knows which client ID calls and gives it only the tools and instances you picked for it. A web page or another program on your computer has no client key, so the server refuses its calls before any tool runs. The IDE's own token never goes into an agent config

How client keys work, under the Agent selector on the Server tab and under Client ID in the dialog, plays this as a short animation with a scene for each case. Click a scene to see it, or click the animation to pause it

After either, connect the agent again by its config, command or setup prompt to give it its new client key

Related