SFCC MCP

Your agent sees the whole SFCC project, not just the open file. The extension runs a local Model Context Protocol (MCP) server that scans your cartridges and reads the connected sandbox, then gives your coding agent 218 tools, 49 resources, and 13 prompts to query it. The agent can ask which cartridge owns a file, prove the type behind BasketMgr.getCurrentBasket(), list every implementation of dw.order.calculate, read your custom attributes and site preferences, or map a Log Center error to the exact source line, using the same index that powers VS Code

MCP tools return project facts or perform an operation. Skills and project instructions teach the agent which SFCC patterns and tool workflows to use. Both are managed from the B2C MCP panel

What the server scans

Everything below is indexed from the folders and linked cartridges of the open workspace, or read through the active connection. Each result comes back with evidence, the file, line, or value it was taken from, and suggests the next tools to call

Your code

• Cartridge path. Cartridge order, which cartridge overrides which file, and the cartridge an edit belongs in
• Scripts and modules. The require graph, exports, and every module.superModule chain across cartridges
• Script API types. 486 bundled dw.* typings and 143 SCAPI typings. The agent proves the type behind a real call instead of guessing from a name
• Hooks. 333 system hook names, your hooks.json registrations, and every implementation on the cartridge path
• Routes and endpoints. SFRA server.get, append, prepend, and replace, SiteGenesis, and pipeline routes, each with its override chain
• ISML templates. Includes, decorators, custom tags, URLUtils routes, and the Resource keys a template uses
• Client builds. SFRA webpack entry points, aliases, and which cartridge owns a client module

Your data model

• System objects. Custom attributes from your metadata XML, such as Profile.custom.loyaltyPoints, typed for completions and checks
• Custom objects. Custom object definitions with key, storage scope, and attributes, so CustomObjectMgr calls resolve to real types
• Site preferences. getCustomPreferenceValue('loyaltyEnabled') returns the declared type, not any
• Sites. Site scopes from site.xml in the workspace and the live sites on the sandbox
• Forms and resources. Form fields and validation, and Resource keys with their translations in every bundle
• Jobs, services, and APIs. Job step types, service and config XML checked against 53 bundled XSDs, custom SCAPI APIs with their schema, and pipelines with their dictionary

Your sandbox

• Instance and code versions. Instance URLs, the active code version, and whether the connection is ready
• Remote files. 20 WebDAV tools to browse, read, download, and diff cartridges, IMPEX files, catalogs, and logs
• Log Center. Issues ranked by frequency, timelines, and anomalies, each stack trace mapped back to your source line
• Live debugger. 36 tools for breakpoints, stack frames, variables, and evaluation, in scripts and pipelines
• Deploy and upload. Plans first. Uploads, deploys, and other guarded changes wait for your confirmation in VS Code. An agent deploy goes to the active connection and cannot be cancelled. See Deploys from AI agents
• Secrets stay masked. Connection tools report whether a credential is configured, never its value. See Hidden From AI Agents

See it work

The same server answers very different questions. A developer change, a live error, and a business question each take a handful of tool calls, and every answer cites where it came from

Who it helps

Developers

• Edits land in the right cartridge. The agent resolves the override chain before it writes, so a change goes into the cartridge that actually wins
• Real types, not guesses. Script API calls, custom attributes, and site preferences resolve to their declared types, and language-server diagnostics check the result
• Hooks and routes in full. Every hook implementation and route override on the cartridge path, not just the first match a text search finds
• Debugging from the chat. Breakpoints, stack frames, and variables from a live debug session, and Log Center issues mapped to source

Business users and support

• Ask in plain language. Which sites have a feature turned on, what a shopper sees in the cart, or which job imports the catalog, answered from the project itself
• Faster triage. A production error goes from Log Center to the exact line, with its occurrences and first-seen time, in one conversation
• Safe by default. Questions never change the instance. Uploads, deploys, and other guarded actions need explicit confirmation

Teams and customers

• Works with the agent you already use. Codex, Claude Code, Cursor, GitHub Copilot, Gemini CLI, OpenCode, and the rest of the 15 supported AI apps get a generated setup
• Faster onboarding. New developers and their agents learn a project from its own index: cartridges, routes, hooks, and metadata
• Fewer regressions. Changes are checked against the real cartridge path, types, and diagnostics before they ship
• Runs on your computer. The server is local to the workspace, and credential values never reach the agent

Connect your agent

Codex

Connect the workspace server and generate Codex Agent Skills

Claude Code

Set up MCP, verify requests, and add Claude skills

Cursor

Connect MCP and create project rules with SFCC tool guidance

GitHub Copilot

Use the VS Code MCP configuration and scoped instructions

Other clients, including Gemini and OpenCode, have their own generated setup in Connect AI. Follow the selected client's transport, configuration destination, and verification instructions there

What you can ask

For example:

Use SFCC MCP to explain Product-Show. Confirm the workspace first,
find every indexed implementation, and show the effective cartridge
owner and override chain. Include source locations. Do not edit files.

Once the owner is clear, you can ask for a focused source change and diagnostics. Ask for deployment or other remote changes explicitly when you are ready to perform them

Plan, then execute

Every change runs as two calls. A .plan tool, such as intellijsfcc.deploy.plan, previews the change without making it and returns a planId and a planFingerprint. The matching .execute tool runs only when both come back unchanged, and VS Code still asks you to confirm. A plan is single use, expires after one hour, and does not survive a restart of the MCP server

Errors and suggestions

A failed tool returns isError: true with an errorCode, a summary, and recoverable. When you have to act, for example to open the VS Code window of the workspace, it adds a userAction hint. A declined confirmation returns user-declined, and nothing runs

A lookup that finds nothing returns not-found with the closest indexed names in didYouMean, so the agent retries with the right one instead of guessing

Tools, access, and evidence

Tools & Access shows which tools are available, what they do, and their prerequisites. Access profiles and per-tool overrides determine what the agent can call; installing a skill does not enable additional tools. Remote operations depend on the active connection, and guarded changes require confirmation through the extension

Activity shows recent requests and failures. A generated configuration means setup was copied or created; a successful request demonstrates that the client used the server at that time. Use a fresh verification request when checking a changed configuration

Results that carry text from logs, WebDAV files, or the live debugger are marked security.untrusted: true, because anyone who can write a log line or upload a file controls that text. The server tells the agent to treat it as data and never follow instructions in it

The server runs on your computer. Tool results go to your AI app and may reach its model provider. Use the workspace-scoped configuration from Connect AI, and keep credential values out of committed configuration

Continue with the B2C MCP panel guide for individual controls, or Skills & Guidance for generated formats and project destinations