Skip to content

Configure MCP in the IDE

This guide shows how to load the NEO MCP servers (playwright, jira, azure-devops) in each code editor. Before you start, check Configure the MCPs to see which servers you need and what data goes into each one.

In all the examples, <token> and the other values between < > are your own data. Never push a file that contains real tokens to git.

Editor + assistant File Root key
Claude Code in VS Code .mcp.json (project root) mcpServers
GitHub Copilot in VS Code .vscode/mcp.json servers
GitHub Copilot in JetBrains mcp.json (opened from the chat) servers
GitHub Copilot in Visual Studio .mcp.json / .vs/mcp.json servers
Codex in VS Code ~/.codex/config.toml [mcp_servers.<nombre>]
Cursor .cursor/mcp.json mcpServers

Pay attention to the root key: Claude Code and Cursor use mcpServers, but Copilot uses servers. If you copy the NEO .mcp.json into a Copilot file without changing that key, the server won't appear.


Claude Code in VS Code

This is the simplest case, because NEO already uses the Claude Code format.

  1. In the root of the test repository, create .mcp.json (or copy .mcp.json.template to .mcp.json) with the reference configuration.
  2. Fill in the real values for the servers you use.
  3. Check that .mcp.json is in .gitignore.
  4. Reload VS Code: Ctrl+Shift+P → Developer: Reload Window.
  5. The first time, Claude Code asks you to approve the project's servers. Accept them.

You can also let lippia-neo-bootstrap-stack create and fill in .mcp.json for you (see The fastest way).

Option 2 — From the chat

In the Claude Code panel, type /mcp. From there you can add, remove, enable, and authenticate servers. It uses the same configuration as the CLI (see Claude Code CLI).

Where it can be saved

Scope File When to use it
Project .mcp.json in the repository root The NEO option: the configuration travels with the project (kept out of git if it has tokens)
Local (the default when you add with claude mcp add) ~/.claude.json, tied to the project folder Only for you and only in that project
User ~/.claude.json To have it in all your projects, for example the Playwright one

Don't load the same server in two scopes. If playwright is in both the user and the project scope, it appears twice and may fail (see Incident 2).

Without writing the token in the file

Claude Code accepts environment variables inside .mcp.json, in the form ${VARIABLE} or ${VARIABLE:-valor_por_defecto}:

"env": {
  "JIRA_URL": "https://your-site.atlassian.net/",
  "JIRA_USERNAME": "your.email@company.com",
  "JIRA_API_TOKEN": "${JIRA_API_TOKEN}"
}

This way the token lives in an environment variable on your system and not in the file. That variable has to be defined before you open VS Code.

⚠️ Three things to watch out for if you use this option:

  • ${VARIABLE} is only replaced with an operating system variable, never with another key in the same block. "CONFLUENCE_URL": "${JIRA_URL}wiki" doesn't work if JIRA_URL is only defined in the block.
  • Use it only for tokens. JIRA_URL and AZURE_DEVOPS_ORG_URL must be written out in full, because the NEO skills read them directly from the file to validate links (see Jira and Azure DevOps).
  • The standard NEO approach (and the one lippia-neo-bootstrap-stack uses) is to write the values directly in .mcp.json, which is in .gitignore. This option is an alternative, not a requirement.

Check

Type /mcp in the chat. Each server should show as Connected. Other possible states:

State What it means
Pending approval The project server still needs to be approved
Failed It couldn't start. Check the command, or that Node.js / uv are installed
Needs authentication The server asks you to sign in (doesn't apply to the NEO servers, which use a token)

GitHub Copilot in VS Code

Copilot uses MCP servers in the chat's agent mode.

Option 1 — Workspace file

Create .vscode/mcp.json in the project. The root key is servers, and secrets are requested with inputs, so they aren't written in the file:

{
  "inputs": [
    { "id": "jira-token",  "type": "promptString", "description": "API token de Atlassian", "password": true },
    { "id": "azure-pat",   "type": "promptString", "description": "PAT de Azure DevOps",    "password": true }
  ],
  "servers": {
    "playwright": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@playwright/mcp@latest", "--browser", "chromium"]
    },
    "jira": {
      "type": "stdio",
      "command": "uvx",
      "args": ["mcp-atlassian"],
      "env": {
        "JIRA_URL": "https://your-site.atlassian.net/",
        "JIRA_USERNAME": "your.email@company.com",
        "JIRA_API_TOKEN": "${input:jira-token}",
        "CONFLUENCE_URL": "https://your-site.atlassian.net/wiki",
        "CONFLUENCE_USERNAME": "your.email@company.com",
        "CONFLUENCE_API_TOKEN": "${input:jira-token}",
        "READ_ONLY_MODE": "true"
      }
    },
    "azure-devops": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@tiberriver256/mcp-server-azure-devops"],
      "env": {
        "AZURE_DEVOPS_ORG_URL": "https://dev.azure.com/your-org",
        "AZURE_DEVOPS_AUTH_METHOD": "pat",
        "AZURE_DEVOPS_PAT": "${input:azure-pat}"
      }
    }
  }
}

The first time the server starts, VS Code asks you for the token and stores it securely. With inputs, .vscode/mcp.json has no secrets and can be versioned.

According to the VS Code documentation, it also detects a .mcp.json in the project root (with the mcpServers key), like the one NEO generates. If you already have it, try MCP: List Servers first: you may not need to create .vscode/mcp.json.

Option 2 — From the Command Palette

Ctrl+Shift+P → MCP: Add Server → choose Command (stdio) and fill in the command (npx), the arguments, and the name. You can save it in the workspace or in your user configuration (MCP: Open User Configuration).

Check

  1. Ctrl+Shift+P → MCP: List Servers: each server should be running. From there you can start it, restart it, or view its log.
  2. The first time (and every time the configuration changes), VS Code asks whether you trust the server. Accept.
  3. In the Copilot chat, switch to Agent mode and open Configure Tools (the tools icon): the playwright tools (browser_*) and those of the other servers should appear.

GitHub Copilot in JetBrains (IntelliJ, WebStorm…)

  1. Open the Copilot chat (Copilot icon → Open Chat) and switch to Agent mode.
  2. Click the tools icon (Configure your MCP server) → Add MCP Tools. This opens the mcp.json file.
  3. Paste the servers under the servers root key:
{
  "servers": {
    "playwright": {
      "command": "npx",
      "args": ["-y", "@playwright/mcp@latest", "--browser", "chromium"]
    },
    "jira": {
      "command": "uvx",
      "args": ["mcp-atlassian"],
      "env": {
        "JIRA_URL": "https://your-site.atlassian.net/",
        "JIRA_USERNAME": "your.email@company.com",
        "JIRA_API_TOKEN": "<token>",
        "READ_ONLY_MODE": "true"
      }
    }
  }
}
  1. Save and go back to the chat: the tools appear in the agent mode tool picker.

On Copilot Business or Enterprise accounts, the organization must have the "MCP servers in Copilot" policy enabled. If you don't see the option, ask your organization's GitHub administrator.


GitHub Copilot in Visual Studio

Requires Visual Studio 2022 17.14 or later (or Visual Studio 2026).

  1. Create the file in one of these locations (Visual Studio reads them in this order):
File Scope
%USERPROFILE%\.mcp.json All your solutions
<solution folder>\.vs\mcp.json That solution, only on your machine
<solution folder>\.mcp.json That solution, shareable
<solution folder>\.vscode\mcp.json Compatible with VS Code
  1. Use the servers root key, with the same content as in JetBrains.
  2. You can also do it through the interface: in the Copilot chat, Agent mode → Tools → + → Add custom MCP server.
  3. When you save the file, the agent restarts automatically.
  4. Enable the tools manually: in Visual Studio they're disabled by default. Turn them on from the chat's Tools picker.

Codex in VS Code

The Codex extension shares its configuration with Codex CLI and with the ChatGPT desktop app: everything lives in ~/.codex/config.toml (on Windows, %USERPROFILE%\.codex\config.toml). You can also use .codex/config.toml inside the project, but only in projects marked as trusted.

The format is TOML, not JSON:

[mcp_servers.playwright]
command = "npx"
args = ["-y", "@playwright/mcp@latest", "--browser", "chromium"]

[mcp_servers.jira]
command = "uvx"
args = ["mcp-atlassian"]
env_vars = ["JIRA_API_TOKEN", "CONFLUENCE_API_TOKEN"]   # takes these values from your environment

[mcp_servers.jira.env]
JIRA_URL = "https://your-site.atlassian.net/"
JIRA_USERNAME = "your.email@company.com"
CONFLUENCE_URL = "https://your-site.atlassian.net/wiki"
CONFLUENCE_USERNAME = "your.email@company.com"
READ_ONLY_MODE = "true"

[mcp_servers.azure-devops]
command = "npx"
args = ["-y", "@tiberriver256/mcp-server-azure-devops"]
env_vars = ["AZURE_DEVOPS_PAT"]

[mcp_servers.azure-devops.env]
AZURE_DEVOPS_ORG_URL = "https://dev.azure.com/your-org"
AZURE_DEVOPS_AUTH_METHOD = "pat"

With env_vars, the token isn't written in the file: Codex reads it from your system's environment variables. If you prefer, you can put it directly in the .env section.

You can also add it with a command (see Codex CLI). To check, type /mcp in the Codex chat.


Cursor

  1. Create .cursor/mcp.json in the project (or ~/.cursor/mcp.json for all your projects).
  2. Use the mcpServers root key: it's the same format as the NEO .mcp.json, so you can copy the reference configuration as is.
  3. To avoid writing tokens, Cursor accepts ${env:VARIABLE} inside env, or an envFile pointing to a variables file.
  4. Restart Cursor after editing the file.
  5. To see errors: Output panel → MCP Logs.

Katalon Studio (remote server)

If your framework is Katalon, add the katalon-studio server. Unlike the others, it is remote (HTTP): it has no command or args, only type: http and the url Katalon Studio shows. The full guide, with step-by-step instructions and common problems, is in Set up the Katalon Studio MCP.

Editor + assistant How to load it
Claude Code, Cursor "katalon-studio": { "type": "http", "url": "<URL>", "headers": { "Authorization": "Bearer <token>" } } under mcpServers
GitHub Copilot (VS Code, JetBrains, Visual Studio) The same block under servers (in VS Code, with inputs for the token)
Codex [mcp_servers.katalon-studio] with url = "<URL>" and, if it asks for a token, bearer_token_env_var = "<VARIABLE>"

Katalon Studio must be open with the suite's project, and the first handshake takes ~30 seconds: set MCP_TIMEOUT=60000 before opening the IDE.


Common problems in the IDE

What you see Why it can happen What to do
Copilot doesn't show the server The mcpServers key was used instead of servers Change the root key to servers
The server is there, but the chat doesn't use its tools The chat isn't in agent mode, or the tools are disabled Switch to Agent mode and turn them on in Configure Tools / Tools
On Windows, npx doesn't start from the IDE The IDE can't find npx in the PATH Restart the IDE after installing Node.js. If it still fails, use "command": "cmd" and "args": ["/c", "npx", "-y", "@playwright/mcp@latest"]
Claude Code doesn't pick up changes to .mcp.json Servers are read at startup Developer: Reload Window
Claude Code shows the server as Pending approval Project servers are approved the first time Approve it from /mcp
The token ended up in a versioned file The literal value was written in a file that isn't in .gitignore Remove it from the repository, revoke the token, and use inputs / ${VARIABLE} / env_vars