> 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-a-desktop-app/configure-claude-desktop-windows.md).

# Configure the Claude desktop app for Windows

Connect the Claude desktop app on Windows to your Datasentinel MCP server, sign in, install the Datasentinel Skill, and verify the configuration.

This page shows how to wire the **Claude desktop app on Windows** 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.

This is the desktop application, not Claude Code (the CLI). For the terminal version, see [Configure Claude Code](/manual/ai-connector/connect-a-cli-assistant/configure-claude-code.md).

{% hint style="info" %}
The steps below follow Anthropic's documentation, last checked on 6 October 2026. Anthropic changes the Claude desktop app often.
{% endhint %}

## Before you start

* The Claude desktop app is installed and you are signed in.
* Your Datasentinel MCP server is reachable at `https://<public-host>/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.
{% endhint %}

## Add the Datasentinel MCP server

The desktop app offers two ways to reach an MCP server, and the right one depends on where your platform is hosted. With both, the Datasentinel MCP server is protected by OAuth 2.1: you sign in once with your platform login and password, and nothing goes in the configuration, no token, no key. What differs is who runs the sign-in: Claude's own connector, or the bridge on your machine. See [How authentication works](/manual/ai-connector/server-setup/how-authentication-works.md).

{% hint style="info" %}
**Which method should you use?**

* **Custom connector** if your platform is reachable from the public internet with a **valid (publicly-trusted) TLS certificate**. Claude connects to it from Anthropic's cloud, so a host behind a VPN, a corporate firewall, or a self-signed certificate will **not** work this way.
* **Local bridge** if your platform is on a private network or uses a **self-signed certificate**. The bridge runs on your machine, so it reaches whatever your machine can reach. It requires Node.js.
  {% endhint %}

{% tabs %}
{% tab title="Custom connector (public host)" %}
The custom connector is built in and needs no extra software. For the full reference, see Anthropic's [Get started with custom connectors using remote MCP](https://support.claude.com/en/articles/11175166-get-started-with-custom-connectors-using-remote-mcp) guide.

{% stepper %}
{% step %}

#### Add the connector

Go to **Customize > Connectors**, click **+**, then **Add custom connector**. Enter the server URL `https://<public-host>/mcp`, then click **Add**. Leave the OAuth client id and secret under **Advanced settings** empty: Claude registers itself with the Datasentinel server on its own.

On a Team or Enterprise plan, an owner adds the connector once under **Organization settings > Connectors**, and each member then connects to it from **Customize > Connectors**.
{% endstep %}

{% step %}

#### Sign in to the platform

Next to the new connector, click **Connect**. Claude 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 Claude, and the connector shows as connected.

You sign in once. Claude renews the session by itself and asks again (the connector then offers **Reconnect**) only after ten days without using the server, or when an administrator ends the session. Your password goes to the login page only; Claude never sees it. In an organisation, every member signs in with their own Datasentinel account, so the platform applies each person's privilege and instance visibility. There is no need for a script variant here: the connector is used by people in conversations, and Claude's servers keep the session.
{% endstep %}

{% step %}

#### Enable it in a conversation

In a chat, click the **+** button at the lower-left, choose **Connectors**, and toggle the Datasentinel connector on.
{% endstep %}
{% endstepper %}

{% hint style="warning" %}
Because Claude connects from Anthropic's cloud, the server must be reachable from the public internet and must present a valid TLS certificate, and so must its sign-in endpoints on the same host; the login page is opened in your own browser, which must trust the certificate too. For a private host or a self-signed certificate, use the **Local bridge** tab instead.
{% endhint %}
{% endtab %}

{% tab title="Local bridge (private host or self-signed cert)" %}
This method runs a small bridge (`mcp-remote`) on your machine that connects to the remote server and exposes it to Claude over the local transport the config file supports. The bridge is also the OAuth client: it runs the sign-in, keeps the session and renews it, and Claude never sees the platform.

{% stepper %}
{% step %}

#### Install Node.js

The bridge runs with `npx`, which ships with Node.js. Install **Node.js 18 or later** from [nodejs.org](https://nodejs.org/) if it is not already present.
{% endstep %}

{% step %}

#### Edit the configuration file

Open the **Claude** menu, choose **Settings**, select the **Developer** tab, and click **Edit Config**. This opens `%APPDATA%\Claude\claude_desktop_config.json` (creating it if needed).

Add the Datasentinel server under `mcpServers`, bridging to your URL with `mcp-remote`. The `--transport http-only` flag pins the bridge to streamable HTTP, which is what Datasentinel serves:

```json
{
  "mcpServers": {
    "datasentinel-production": {
      "command": "npx",
      "args": ["mcp-remote", "https://<public-host>/mcp", "--transport", "http-only"]
    }
  }
}
```

For a **self-signed or otherwise invalid certificate**, add an `env` block to the same entry. Because the bridge runs as its own process, that `env` applies only to the bridge, so the exception does not affect anything else on your machine.

To disable certificate verification as a last resort, set `NODE_TLS_REJECT_UNAUTHORIZED` to `0`:

```json
{
  "mcpServers": {
    "datasentinel-production": {
      "command": "npx",
      "args": ["mcp-remote", "https://<public-host>/mcp", "--transport", "http-only"],
      "env": { "NODE_TLS_REJECT_UNAUTHORIZED": "0" }
    }
  }
}
```

{% hint style="warning" %}
`NODE_TLS_REJECT_UNAUTHORIZED` set to `0` turns off TLS validation for the bridge, so use it only when you cannot install the certificate's CA on the host. A valid certificate is still **highly recommended**. The safer alternative is to keep validation on and trust your internal CA with `NODE_EXTRA_CA_CERTS`; see Node's [`NODE_EXTRA_CA_CERTS` documentation](https://nodejs.org/api/cli.html#node_extra_ca_certsfile) for how to set it.
{% endhint %}
{% endstep %}

{% step %}

#### Restart Claude and sign in

Fully quit and reopen the Claude desktop app so it loads the new configuration. As the bridge starts, it registers itself with the Datasentinel server and opens the login page in your browser: sign in with your **platform login and password**, the same ones as the Datasentinel web interface. The browser then returns to a local address the bridge listens on, and the Datasentinel tools appear in Claude.

You sign in once. The bridge stores the session under `%USERPROFILE%\.mcp-auth` and renews it by itself; it opens the login page again only after ten days without using the server, or when an administrator ends the session. If a sign-in gets stuck, quit Claude, delete that folder and reopen the app to start afresh.

The bridge listens for the browser on a local port it derives from the server URL. To pin a port, add it as an extra argument after the URL, for example `"https://<public-host>/mcp", "19876"`. The bridge's device-code and client-credentials options do not apply: the Datasentinel server offers neither flow.

**For a script or a scheduled run**, where nobody can sign in, give the bridge the platform's 24-hour [user token](https://app.gitbook.com/o/DaDQkGCM7r2TghFSBFLQ/s/yE16Xb3IemPxJWydtPOj/implementation/platform-usage/api-reference/access-token) as a header instead; the bridge then skips the sign-in. Keep the token in the `env` block, and write the header without a space after the colon: on Windows, Claude Desktop mangles spaces inside `args`.

```json
{
  "mcpServers": {
    "datasentinel-production": {
      "command": "npx",
      "args": ["mcp-remote", "https://<public-host>/mcp", "--transport", "http-only", "--header", "Authorization:${DS_AUTH}"],
      "env": { "DS_AUTH": "Bearer <user token>" }
    }
  }
}
```

When the token expires, the calls fail until a fresh one is written; see [Refresh the user token automatically](/manual/ai-connector/developers/refresh-user-token.md). The bridge's options are documented in the [mcp-remote README](https://github.com/geelen/mcp-remote).
{% endstep %}
{% endstepper %}
{% endtab %}
{% endtabs %}

## 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 <https://app.datasentinel.io/ds-api/download/datasentinel-skill.zip>. In the desktop app, Skills are added through the interface rather than the file system. For the full reference, see Anthropic's [Use Skills in Claude](https://support.claude.com/en/articles/12512180-use-skills-in-claude) guide.

{% stepper %}
{% step %}

#### Enable code execution

Skills require code execution to be on. Open **Settings > Capabilities** and enable **Code execution and file creation**. On Team and Enterprise plans, an owner enables this at **Organization settings > Skills**.
{% endstep %}

{% step %}

#### Upload the Skill

Go to **Customize > Skills**, click **+**, then **Create Skill**, and upload `datasentinel-skill.zip`. The archive's root must be the `datasentinel` folder containing `SKILL.md` (not the files loose at the root, and not a nested subfolder), which is exactly how `datasentinel-skill.zip` is packaged.
{% endstep %}
{% endstepper %}

The Skill's `SKILL.md` frontmatter carries the `description` Claude uses to decide when to apply it:

```markdown
---
name: datasentinel
description: How to query Datasentinel metrics through the datasentinel-* MCP servers.
---

<instructions for using the Datasentinel MCP tools>
```

## Check your configuration

* **Custom connector:** it appears under **Customize > Connectors** as connected (a **Connect** or **Reconnect** button there means the sign-in is still to be done), and you enable it per conversation from the **+** menu.
* **Local bridge:** after restarting and signing in, an MCP tools indicator appears at the bottom-right of the message box; click it to see the Datasentinel tools. If it is missing, check the logs under `%APPDATA%\Claude\logs\` (`mcp.log` and `mcp-server-datasentinel-production.log`); the bridge's own log, with `--debug` in the arguments, lands under `%USERPROFILE%\.mcp-auth`.

{% hint style="info" %}
If you installed Claude from the Microsoft Store and configuration edits do not seem to load, the running build may read a virtualized copy of the file under `%LOCALAPPDATA%\Packages\` rather than the `%APPDATA%` copy that **Edit Config** opens. This is a reported issue with some Store builds; check that location if the bridge does not appear.
{% endhint %}

Once the server is connected and the Skill is uploaded, run through the checks below to confirm the end-to-end flow.

## How the Skill loads

The Datasentinel Skill loads on demand. Claude reads every Skill's name and `description` up front, and applies the full instructions automatically when your request 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 Claude answers generically instead (no Datasentinel tool calls in the response), load the Skill manually:

* Name it in the prompt: `Use the datasentinel skill to check the platform status.`
* Check the Skill's toggle: under **Customize > Skills**, the `datasentinel` Skill must be switched on, and **Code execution and file creation** must still be enabled under **Settings > Capabilities**, since Skills run through it.

See Anthropic's [Use Skills in Claude](https://support.claude.com/en/articles/12512180-use-skills-in-claude) guide for the details.

## Test the MCP server and Skill

Ask Claude, in plain language, to run the Datasentinel Skill's built-in checks (see [How the Skill loads](#how-the-skill-loads) above). Run these in order:

| Ask Claude 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 Claude 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, start by asking Claude what it sees on its side:

```
The datasentinel-production MCP server is not discovered. Tell me exactly which Datasentinel tools are available to you in this conversation, try to call one of them, and report the error you get verbatim.
```

Claude runs inside the app and cannot read your local configuration or logs, so it can only report its own view. That is still enough to separate a connector that never attached from one that attached and then failed on a tool call.

To go further on the **local bridge** setup, hand the debugging to an assistant that does have access to your machine, such as [Claude Code](/manual/ai-connector/connect-a-cli-assistant/configure-claude-code.md), and point it at the files that hold the answer:

```
Claude Desktop does not discover my datasentinel-production MCP server. Investigate and find the root cause: read %APPDATA%\Claude\claude_desktop_config.json, then the logs in %APPDATA%\Claude\logs\ (mcp.log and mcp-server-datasentinel-production.log), and check whether the /mcp endpoint answers.
```

Typical causes: a server name that misses the `datasentinel-` prefix, a typo in the URL, a connector left toggled off in the conversation, a connector or bridge whose sign-in was never completed, an app that was not fully restarted after the edit, a stale bridge session under `%USERPROFILE%\.mcp-auth`, a certificate the connector rejects, or a platform that is down.
{% endhint %}

## Go further: create a live dashboard artifact

With the MCP server and the Skill verified, Claude can go beyond chat answers and publish a **live dashboard artifact**: a self-contained HTML page that calls your Datasentinel MCP tools from inside the page, through your `datasentinel-*` connector, so the data on screen is fetched live every time you open, filter, or refresh it.

{% hint style="warning" %}
**Public MCP servers only.** Artifacts call the MCP server through a **custom connector**, from Anthropic's cloud. The server must be reachable from the internet with a publicly trusted certificate.

The configuration file method (`mcp-remote`) does not work for artifacts, even when it works in the chat. Anthropic documents both points in [Get started with custom connectors using remote MCP](https://support.claude.com/en/articles/11175166-get-started-with-custom-connectors-using-remote-mcp) and in its [artifacts documentation](https://code.claude.com/docs/en/artifacts#pull-live-data-with-mcp-connectors). For a private platform, see [MCP servers on a private network](/manual/ai-connector/troubleshooting/private-network-mcp-servers.md).
{% endhint %}

The [`datasentinel-claude-artifact`](https://github.com/datasentinel/datasentinel-claude-artifact) repository provides a ready-made reference implementation, `datasentinel-postgresql-monitor.html`: a PostgreSQL fleet workload monitor with cohort ranking, one tab per instance (overview, query detail with execution plans, top tables, vacuum and bloat, I/O, real-time), and an embedded "Ask Claude" chat over the data on screen. Its README carries the exact prompt to publish the dashboard against your own platform, and a public sandbox platform to try it without one.

{% stepper %}
{% step %}

#### Attach the reference file

Download `datasentinel-postgresql-monitor.html` from the [repository](https://github.com/datasentinel/datasentinel-claude-artifact) and attach it to a new conversation.
{% endstep %}

{% step %}

#### Paste the publishing prompt

Paste the publishing prompt from the repository's README. Claude lists your `datasentinel-*` connectors, asks which ones to include, adapts the file to your choice, and publishes it as an artifact. Open it and allow the connectors when Claude asks.
{% endstep %}
{% endstepper %}

To learn more about the dashboard, how to customize it by asking Claude, and how to troubleshoot its first load, see:

{% content-ref url="/pages/pkOrGusK2I5gkrlD1sWU" %}
[Claude Artifact](/manual/ai-connector/dynamic-dashboards/claude-artifact.md)
{% endcontent-ref %}


---

# 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-a-desktop-app/configure-claude-desktop-windows.md?ask=<question>&goal=<user_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.