> For the complete documentation index, see [llms.txt](https://docs.datasentinel.io/manual/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.datasentinel.io/manual/ai-connector/connect-an-ide/configure-vscode.md). # Configure Visual Studio Code Connect Visual Studio Code to your Datasentinel MCP server through GitHub Copilot agent mode, sign in, install the Datasentinel Skill, and verify the setup. This page shows how to wire [Visual Studio Code](https://code.visualstudio.com/) to your Datasentinel platform: add the **MCP server**, **sign in** once, install the **Skill** that tells the assistant how to use it, and check that everything is connected. Unlike the terminal assistants, VS Code consumes MCP servers through **GitHub Copilot agent mode**, configured from the UI and a JSON file rather than a command-line tool. {% hint style="info" %} The steps below follow Microsoft's documentation, last checked on 6 October 2026. Microsoft changes VS Code often. {% endhint %} ## Before you start * **VS Code 1.102 or later** is installed (MCP support is generally available from this version). * **GitHub Copilot** is set up and you are signed in. Any plan works, including the free tier. Open the Chat view and select **Agent** mode, which is what runs MCP tools. * Your Datasentinel MCP server is reachable over HTTPS at `https:///mcp`. See [MCP Server Setup](/manual/ai-connector/server-setup/mcp-server-setup.md) if it is not yet running. {% hint style="warning" %} **Name MCP servers with a `datasentinel-` prefix.** Every Datasentinel MCP server you register must be named starting with `datasentinel-`, for example `datasentinel-production` or `datasentinel-staging`. The Skill discovers Datasentinel servers by this prefix, so a server named otherwise will not be picked up. Use a distinct suffix per platform when you operate more than one (`datasentinel-prod`, `datasentinel-eu`, and so on). {% endhint %} ## Set it up {% hint style="info" %} Recent VS Code versions add an **Agents window** (Preview): select **Open in Agents** from the title bar to open it. It brings agent customizations together, so you can add and manage your **MCP servers** and **Skills** in one place from its **Agent Customizations** editor (also reachable with **`Chat: Open Customizations`** in the Command Palette). The steps below use the standard commands, which work in every supported version. {% endhint %} {% stepper %} {% step %} #### Add the Datasentinel MCP server For the full reference, see VS Code's [Add and manage MCP servers](https://code.visualstudio.com/docs/agent-customization/mcp-servers) guide. The guided flow is the quickest way. Open the Command Palette (`Ctrl+Shift+P`) and run **`MCP: Add Server`**, then: 1. Choose **HTTP (HTTP or Server-Sent Events)** as the type. 2. Enter the URL `https:///mcp`. 3. Name the server `datasentinel-production`. 4. Choose where to save it: **Global** (available in every workspace) or **Workspace** (this project only). 5. When VS Code asks, confirm that you **trust** the server before it starts. You can also edit the configuration file directly. A workspace server lives in `.vscode/mcp.json` (run **`MCP: Open Workspace Folder Configuration`** to open or create it); for a global server, run **`MCP: Open User Configuration`** to open your user `mcp.json`. Servers go under a top-level `servers` object, with `"type": "http"` for a remote streamable-HTTP endpoint (VS Code tries the HTTP stream transport first and falls back to SSE automatically). The full field list is in VS Code's [MCP configuration reference](https://code.visualstudio.com/docs/agents/reference/mcp-configuration). ```json { "servers": { "datasentinel-production": { "type": "http", "url": "https:///mcp" } } } ``` {% hint style="info" %} **Sign in on first use.** The Datasentinel MCP server is protected by OAuth 2.1. Nothing else goes in the configuration: no token, no `headers` entry, and no `oauth` block either, since VS Code registers itself with the server on its own (the `oauth` block is for servers that require a pre-registered client id). The sign-in is the next step. See [How authentication works](/manual/ai-connector/server-setup/how-authentication-works.md). {% endhint %} A third option registers the server in your user profile from the command line, which is handy for scripted setups: ```bash code --add-mcp '{"name":"datasentinel-production","type":"http","url":"https:///mcp"}' ``` After you add a server or change its configuration, VS Code has to (re)start it to discover its tools. Use the inline **Start** action in `mcp.json`, or **`MCP: List Servers`** and pick the server; the experimental `chat.mcp.autostart` setting restarts servers automatically when the configuration changes. The trust prompt appears the first time a server starts; if you need to review it again later, run **`MCP: Reset Trust`**. **Self-signed or invalid certificate** If your platform serves the `/mcp` endpoint with a self-signed or otherwise invalid TLS certificate, VS Code rejects the connection by default. {% hint style="info" %} Using a valid TLS certificate is **highly recommended**. Provisioning a certificate trusted by your host (from a public authority, or from an internal CA installed in the system trust store) keeps validation on and avoids the workaround below entirely. {% endhint %} VS Code does not expose a setting that is specific to MCP for this. The reliable, secure path is to make the certificate trusted at the host level: * Install your internal CA into the **operating system trust store**. VS Code reads it through the `http.systemCertificates` setting, which is enabled by default. * Alternatively, point the underlying runtime at your CA file by setting `NODE_EXTRA_CA_CERTS` to a PEM bundle in the environment **before** launching VS Code: ```bash export NODE_EXTRA_CA_CERTS=/path/to/internal-ca.pem code ``` {% hint style="warning" %} As a last resort, the general networking setting `http.proxyStrictSSL: false` disables certificate validation. This is **not** scoped to MCP and weakens TLS for VS Code's other network traffic, so prefer a trusted certificate. These TLS options are general VS Code behaviour and are not documented specifically for the MCP client, so verify them in your environment. {% endhint %} The sign-in below opens the login page in your browser, so the browser must trust the certificate too. {% endstep %} {% step %} #### Sign in to the platform **With a browser** The sign-in starts the first time the server starts, right after the trust prompt (or later, from **`MCP: List Servers`**, **Start**). VS Code asks you to allow the server's authentication request, then opens the Datasentinel login page in your browser: sign in with your **platform login and password**, the same ones as the Datasentinel web interface. The page names the assistant that is asking; after the sign-in the browser hands the session back to VS Code, and the server starts with its tools. You sign in once. VS Code renews the session by itself and asks again only after ten days without using the server, or when an administrator ends the session. Your password goes to the login page only; VS Code never sees it and never asks for a token. The session appears in the **Accounts** menu (the account icon in the Activity Bar), where you can sign out of it; **`Authentication: Remove Dynamic Authentication Providers`** in the Command Palette forgets the registration entirely, so the next start signs in from scratch. VS Code's support of the MCP authorization standard is described in its [MCP developer guide](https://code.visualstudio.com/api/extension-guides/ai/mcp#authorization). **Without a browser** VS Code is a desktop application, so the machine running its window always has a browser, and the sign-in returns to VS Code on that machine (its own callback address is `http://127.0.0.1:33418`). This holds when the workspace is on a remote host through Remote - SSH, WSL or a Dev Container: the window, the browser and the callback are on your laptop, so no tunnel is needed. Keep in mind where the server runs, though: a server in your user profile runs locally, one in the workspace or remote settings runs on the remote host, which must then reach the platform URL. See VS Code's [MCP servers](https://code.visualstudio.com/docs/agent-customization/mcp-servers) guide. **For a script or a scheduled run** Where nobody can sign in, register the server with a user token as an authorization header instead. The token is the platform's 24-hour [user token](https://app.gitbook.com/o/DaDQkGCM7r2TghFSBFLQ/s/yE16Xb3IemPxJWydtPOj/implementation/platform-usage/api-reference/access-token). Header values accept `${env:VARIABLE}` references, so the token stays out of the file; `${input:id}` with a masked prompt is the alternative for a value typed at start-up (see the [MCP configuration reference](https://code.visualstudio.com/docs/agents/reference/mcp-configuration)): ```json { "servers": { "datasentinel-production": { "type": "http", "url": "https:///mcp", "headers": { "Authorization": "Bearer ${env:DS_TOKEN}" } } } } ``` A server registered this way never opens the login page; when the token expires, the calls fail until a fresh one is set. See [Refresh the user token automatically](/manual/ai-connector/developers/refresh-user-token.md) to keep it current. {% endstep %} {% step %} #### Install the Datasentinel Skill The Datasentinel Skill is made of several files (a `SKILL.md` entrypoint plus supporting files) and ships as a single archive, `datasentinel-skill.zip`. Download it from . VS Code supports the **Agent Skills** standard: a Skill is a folder containing a `SKILL.md`, discovered automatically. For the full reference, see VS Code's [Use Agent Skills in VS Code](https://code.visualstudio.com/docs/agent-customization/agent-skills) guide. Unzip the archive into a Skills directory so it produces a `datasentinel/` folder: {% tabs %} {% tab title="Personal (all your projects)" %} ```bash mkdir -p ~/.copilot/skills/ unzip datasentinel-skill.zip -d ~/.copilot/skills/ ``` {% endtab %} {% tab title="Workspace (shared via Git)" %} ```bash mkdir -p .github/skills/ unzip datasentinel-skill.zip -d .github/skills/ ``` {% endtab %} {% endtabs %} You should end up with `~/.copilot/skills/datasentinel/SKILL.md` (or `.github/skills/datasentinel/SKILL.md`) alongside the Skill's supporting files. Keep the `datasentinel/` folder name as the archive produces it: VS Code requires the `name` in the frontmatter to match the parent directory name, and a mismatch makes the Skill silently fail to load. Its frontmatter carries the `description` the assistant uses to decide when to apply the Skill: ```markdown --- name: datasentinel description: How to query Datasentinel metrics through the datasentinel-* MCP servers. --- ``` **Cross-agent locations: `.claude/skills` and `.agents/skills`.** VS Code also discovers Skills from the locations other assistants use: `~/.claude/skills` and `~/.agents/skills` for personal Skills, `.claude/skills` and `.agents/skills` in the workspace for project Skills. So a `datasentinel/` folder you already installed for Claude Code or Codex is picked up by VS Code without a second copy. The `~/.copilot/skills` and `.github/skills` paths above are Copilot's own locations; all of them work, and you can add more through the `chat.agentSkillsLocations` setting. {% endstep %} {% step %} #### Check your configuration Run **`MCP: List Servers`** from the Command Palette, or open the **MCP SERVERS - INSTALLED** section of the Extensions view. From there you can start, stop, and restart a server, enable or disable it, view its output with **Show Output**, and see the tools it exposes. The **Agent Customizations** editor (**`Chat: Open Customizations`**) lists the same servers and lets you toggle their enabled state. In the Chat view (in **Agent** mode), type `#` to list the available tools, or select **Configure Tools** in the chat input to open the tools picker and make sure the Datasentinel tools are enabled. A server that shows as needing authentication has not completed the sign-in: go back to the previous step. **Approve the Datasentinel tools** The first time the assistant calls a Datasentinel tool, VS Code prompts you to allow it. You can approve the single use, or grant the approval for the session, for the workspace, or for all future invocations. To approve every tool of the server at once, run **`Chat: Manage Tool Approval`**: tools are grouped by MCP server, and the top-level checkbox of `datasentinel-production` trusts them all. The Datasentinel tools only read monitoring data, so trusting the whole server is safe. **`Chat: Reset Tool Confirmations`** clears every saved approval. The `chat.tools.global.autoApprove` setting removes the prompts for every tool in every workspace, including terminal commands and file edits; use it with care. See VS Code's [Manage approvals and permissions](https://code.visualstudio.com/docs/agents/run/approvals) guide. To confirm the Skill is discovered, type `/skills` in the chat input (or select **Configure Chat**, the gear icon in the Chat view, then **Skills**) to open the Configure Skills dialog: `datasentinel` should be listed. The **Skills** tab of the **Agent Customizations** editor (**`Chat: Open Customizations`**) shows the same list. {% endstep %} {% endstepper %} Once the server is connected and the Skill is in place, run through the checks below to confirm the end-to-end flow. ## How the Skill loads The Datasentinel Skill loads on demand. Copilot reads every Skill's name and `description` up front, and applies the full instructions automatically when your prompt relates to Datasentinel: asking about PostgreSQL performance, instances, sessions, or the platform itself is enough. One Skill serves every platform, because it discovers all the `datasentinel-*` MCP servers you registered, so adding a second platform needs no Skill change. If Copilot answers generically instead (no Datasentinel tool calls in the response), load the Skill manually: * Type `/datasentinel` in the chat input, followed by your request: Skills are available as slash commands, and `/` alone lists every Skill VS Code discovered. * Or name it in the prompt: `Use the datasentinel skill to check the platform status.` If `datasentinel` is missing from the `/` list, re-check the unzip location from the setup step: the folder must be named `datasentinel` and sit directly under one of the discovery locations. The discovery folders can be extended through the `chat.agentSkillsLocations` setting, and in a monorepo the `chat.useCustomizationsInParentRepositories` setting lets VS Code also read Skills from the parent repository root. See VS Code's [Use Agent Skills in VS Code](https://code.visualstudio.com/docs/agent-customization/agent-skills) reference for the full discovery rules. ## Test the MCP server and Skill Open the Chat view and select **Agent** mode. You exercise the Skill by asking in plain language and letting it drive the MCP tools (see [How the Skill loads](#how-the-skill-loads) above). The Datasentinel Skill recognises four built-in checks. Run them in order: | Ask Copilot for… | What it does | | ------------------------ | ------------------------------------------------------------------------------------- | | `datasentinel help` | Displays the Skill's help, listing the available commands. | | `datasentinel platforms` | Lists every MCP server (platform) the Skill discovered by its `datasentinel-` prefix. | | `datasentinel status` | Checks the platform status, confirming the MCP server answers. | | `datasentinel whoami` | Shows who you are signed in as, your privilege and the session expiry. | These four are the setup checks. The full command list, with what each one needs, is in the [Skill commands reference](/manual/ai-connector/use-the-assistant/skill-commands.md). Start with `datasentinel help` to confirm the Skill responds. Then run `datasentinel platforms` to verify your server is discovered: each `datasentinel-*` MCP server you registered should appear in the list. Then run `datasentinel status` to confirm the platform is reachable and the MCP tools return live data. Finally, `datasentinel whoami` confirms the session belongs to your platform user, with the privilege you expect. {% hint style="success" %} If `datasentinel status` reports a healthy platform, the MCP server and the Skill are wired together correctly. You can now ask Copilot questions about your instances in plain language. {% endhint %} {% hint style="info" %} **Server not discovered? Ask the assistant to find the root cause.** If `datasentinel platforms` lists nothing, or your server is missing from it, ask Copilot in **Agent** mode to debug the setup rather than hunting by hand. It can read the workspace `.vscode/mcp.json` (or your user `mcp.json`), list the tools it actually sees, and probe the endpoint from the terminal, so it usually pinpoints the cause in one pass. Ask it something like: ``` The datasentinel-production MCP server is not discovered. Investigate and find the root cause: check my mcp.json configuration, the connection status of the server and its output log, and whether the /mcp endpoint answers. ``` Typical causes it surfaces: a server name that misses the `datasentinel-` prefix, a typo in the URL, a stopped or disabled server that needs a restart, a server whose trust prompt was declined or whose sign-in was not completed, tools that are switched off in the tools picker, an untrusted TLS certificate, or a platform that is down. {% endhint %} --- # Agent Instructions This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com. ## Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation by asking a question. Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters: ``` GET https://docs.datasentinel.io/manual/ai-connector/connect-an-ide/configure-vscode.md?ask=&goal= ``` `ask` is the immediate question: it should be specific, self-contained, and written in natural language. `goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.