<!-- Generated from mcp-servers-windows.md. Do not edit by hand. -->

> Markdown twin of https://conduitllm.com/mcp-servers-windows.html
> Set up MCP servers on Windows: install Node.js and uv, add local servers with npx or uvx, add remote ones by URL or from the registry, fix common errors.

---
Tutorial

# How to set up MCP servers on Windows

Updated 31 October 2026

Most MCP setup guides assume a Mac and a JSON file. This one is for Windows, with [Conduit](https://conduitllm.com/), a free, open-source desktop AI app, as the client: what to install, what to type in each field, and what the errors mean when a server won't start.

## Introduction

The Model Context Protocol (MCP) lets an AI app use tools from other programs: read and write files, search documentation, query a database, open issues. Each set of tools comes from an **MCP server**. A **local** server is a program the app starts on your computer, usually with `npx` (Node.js) or `uvx` (Python). A **remote** server runs elsewhere and is reached by URL.

On Windows, local servers fail for a few predictable reasons: the runtime isn't installed or isn't on the `PATH`, the app tries to run a shell script as a program, or a folder path contains a space. This tutorial avoids each one.

You will install Node.js and uv, add the official **Filesystem** server with `npx` and the **Fetch** server with `uvx`, and add **Microsoft Learn**, a remote server for Microsoft's documentation. Then you will use them from a chat, approve a tool that changes a file, and see what a server that won't start looks like and how to fix it. In Conduit, MCP servers are called **connectors**.

## Key takeaways

- Install Node.js for `npx` servers and uv for `uvx` servers, then restart Conduit so it sees them on the `PATH`.
- Type `npx` or `uvx` as the command. Conduit finds `npx.cmd` and the other Windows launchers itself; don't wrap them in `cmd /c`.
- Arguments are split at spaces, so pass folder paths without spaces.
- Remote servers need nothing installed: add one by URL or find it in the official registry.
- Tools that only read run straight away. Tools that change something ask first, showing exactly what they will send.

## Prerequisites

To follow this tutorial, you will need:

- **Windows 10 or 11** with **winget**, which comes with current versions of Windows.
- **Conduit installed**. Download the latest release from the [releases page](https://github.com/runningpixels/conduit/releases).
- **A model provider set up in Conduit**. This tutorial uses GLM 5.3 Flash through OpenRouter; see the [provider guides](https://conduitllm.com/providers.html). Models that are good at calling tools work best with connectors.

## Step 1 — Installing Node.js and uv

Most local MCP servers are Node.js packages, started with `npx`, or Python packages, started with `uvx`. In this step, you will install both runtimes.

Open PowerShell and run:

```
winget install OpenJS.NodeJS.LTS
winget install astral-sh.uv
```

uv downloads the Python version each server needs, so you don't install Python separately. Close PowerShell, open a new window, and check that both are found:

```
npx --version
uvx --version
```

Each prints a version number. If PowerShell says the command isn't recognised, sign out of Windows and back in, so the new `PATH` applies, and try again.

Finally, **quit Conduit and open it again**, including from the tray if it is still running there. A program sees the `PATH` it was started with, so a Conduit that was open during the installs can't find `npx` or `uvx` yet.

Next, you will add the first server.

## Step 2 — Adding a local server with npx

The Filesystem server gives the assistant tools to list, read, search and write files, but only inside the folders you name. In this step, you will add it for one folder.

Choose **Context** in the side rail, then **Connectors** at the top, then **Add connector**. The panel has three ways to add a server: **Official MCP registry**, **Remote server by URL** and **Local command**. Under **Local command**, fill in:

1. **Connector name**: `Filesystem`.
2. **Command**: `npx`.
3. **Arguments**: `-y @modelcontextprotocol/server-filesystem C:\Users\Public\Documents\Northwind`, with your own folder at the end. `-y` lets `npx` download the package without asking.

Leave **Env** empty; this server needs no keys. Choose **Add local connector**. The connector is listed as **stopped**. Choose **Start**.

The first start takes a little longer while `npx` downloads the package. Then the status changes to **live** and the server's tools are listed, each marked with what it does:

**Only reads** tools run without asking. **Changes things, asks first** tools ask for your approval each time, until you tell Conduit to remember it. Conduit takes these labels from what the server declares about each tool.

Conduit starts the server without a console window. The command is run directly, never through a shell, which is why `npx` works here without `cmd /c`: Conduit looks the name up on the `PATH` itself and finds `npx.cmd`.

Next, you will add a Python server.

## Step 3 — Adding a local server with uvx

Python servers work the same way, with `uvx` as the command. In this step, you will add the Fetch server, which downloads a web page and turns it into Markdown.

Choose **Add connector** again. Under **Local command**, enter `Fetch` as the name, `uvx` as the command and `mcp-server-fetch` as the arguments:

Choose **Add local connector**, then **Start**. The first start downloads the server and its Python packages, which takes a few seconds, and the connector goes **live** with one tool, `fetch`.

**Note:** Conduit already has its own web search and page reading. Fetch is here as an example of a Python server; any server published for `uvx` is added the same way.

Next, you will add a server that runs remotely.

## Step 4 — Adding a remote server

A remote server needs nothing installed. In this step, you will add Microsoft Learn, Microsoft's official server for searching its documentation, which needs no account.

You can find remote servers in the official MCP registry. In **Add connector**, type a word under **Official MCP registry** and choose **Search**:

**Install** adds a server from the list. The registry is open to anyone, so check who publishes a server before you install it. If you know the server's address, you can add it directly instead. Under **Remote server by URL**, enter `Microsoft Learn` as the name and `https://learn.microsoft.com/api/mcp` as the URL:

Choose **Add remote connector**, then **Start**. The connector goes **live** with three tools for searching the documentation, finding code samples and reading a page, all marked **Only reads**.

A remote server that needs an account shows **sign in** instead of starting. Choose **Sign in** on the connector, finish signing in in your browser, and Conduit stores the access it was given.

Next, you will use the servers in a chat.

## Step 5 — Using the servers in a chat

In this step, you will ask a question that a connector answers, then ask for a change that needs your approval.

Choose **Chats** and **New chat**. Conduit gives the model a way to look up connector tools when it needs them, so you don't have to turn anything on. The most reliable way to get a particular server used is to name it. Send:

```
Use the Microsoft Learn connector: how do I check which version of PowerShell I'm
running, and how do I update it on Windows 11? Link the pages you used.
```

Each tool call is a line in the reply, with the connector and tool name, what was asked and how long it took. Click one to see exactly what was sent and what came back. The searches only read, so they ran without asking.

Now ask for something that changes a file. In a new chat, send:

```
Use the Filesystem connector: list the files in C:\Users\Public\Documents\Northwind,
then create a file there called reading-list.md that lists each PDF with a one-line
description of what it probably covers, based on its name.
```

Listing the folder only reads, so it runs. Writing the file stops and waits for you:

The prompt shows the tool, the server's own description of it, and the data that will be sent, including the path and the content to be written. **Deny** stops it. Tick **Remember for this chat** to let this tool run again in this chat without asking, or **Always allow this tool** for every chat, then choose **Approve and run**.

The file is now in the folder. To review or withdraw a remembered approval later, open the connector on the Connectors page and use **Forget** under **Remembered tool approvals**.

## Step 6 — Fixing a server that won't start

In this step, you will see what a failed server looks like and how to find out why.

A server that exits as soon as it starts is shown as **down**, with the reason Conduit saw:

**connector stdout closed (child exited)** means the server started and then quit, usually with an error it printed. To see that error, run the same command and arguments in PowerShell. For the connector above:

```
npx -y @modelcontextprotocol/server-filesystem C:\Users\Public\Shared Files
```

```
Warning: Cannot access directory C:\Users\Public\Shared, skipping
Error: None of the specified directories are accessible
```

The path contains a space, so it arrived as two arguments, `C:\Users\Public\Shared` and `Files`, and neither is a folder. The causes Windows users hit most:

| What you see | Cause | Fix |
| --- | --- | --- |
| `spawn 'npx' failed` | Node.js isn't installed, or Conduit was started before it was. | Install it (step 1), then quit Conduit completely and open it again. |
| The command is refused | The command is a shell, such as `cmd`, `powershell` or `wsl`. Conduit doesn't run commands through a shell. | Put the program itself in **Command**: `npx`, `uvx`, `node`, `python`, or the full path to an `.exe`. |
| **down** with a folder argument | The path contains a space. **Arguments** are split at every space. | Use a folder whose path has no spaces, such as `C:\Users\Public\Documents\Projects`. |
| **down** for a server that needs a key | The key is missing. | Add it to **Env** as a `KEY=VALUE` line, using the variable name in the server's documentation. |

To change a connector's command or arguments, add it again with the new values, then open the old one and choose **Revoke**, which stops it and turns off its tools.

## Questions

**Do I need Node.js and Python to use MCP servers?**

Only for local servers written in them. A server started with `npx` needs Node.js, and one started with `uvx` needs uv, which fetches its own Python. Remote servers, added by URL or from the registry, run elsewhere and need nothing installed. Conduit itself needs neither.

**Can I reuse my Claude Desktop MCP configuration?**

Not by importing the file, but the same values work. For each server in `claude_desktop_config.json`, put `command` in **Command**, the items of `args` in **Arguments** separated by spaces, and each entry of `env` as a `KEY=VALUE` line in **Env**.

**Can I add a remote server that needs an API key?**

Only if it signs in with OAuth. Conduit signs in to remote servers with OAuth through your browser, using the **Sign in** button on the connector, and has no field for an API key header yet. A server that also runs locally usually takes its key as an environment variable, which you can set in **Env**.

**Does an MCP server run with my permissions?**

Yes. A local server is a program on your computer and can do whatever your Windows account can, so add only servers you trust, from sources you know. Conduit asks before running any tool that changes something, but the server itself decides what each tool does.

**Does this work on macOS and Linux?**

Yes. The Connectors page is the same on every platform. Install Node.js and uv with your package manager instead of winget, and use paths like `/Users/you/Documents`; the rest of the tutorial applies as written.

## Conclusion

In this tutorial, you installed Node.js and uv, added a local MCP server with `npx` and another with `uvx`, added a remote server by URL and from the registry, used them from a chat, approved a tool that writes a file, and diagnosed a server that wouldn't start.

The same three fields, command, arguments and environment, are all any local server needs, so the servers in the MCP registry and in project READMEs can be set up the same way. To go further, explore these guides:

- [Conduit as your MCP client](https://conduitllm.com/use-cases/mcp-client.html), for everything Conduit supports in MCP.
- [Best MCP clients](https://conduitllm.com/best-mcp-clients.html), to compare desktop MCP clients.
- [How to run AI agents side by side in Conduit](https://conduitllm.com/run-ai-agents.html), to give an agent connector tools it uses on its own.

[Download Conduit](https://conduitllm.com/#get)

Conduit details match the latest release and are checkable in [the documentation](https://conduitllm.com/docs.html) and [the source](https://github.com/runningpixels/conduit). Found an error? [Tell us](https://github.com/runningpixels/conduit/discussions) and we will fix it.

## Related

- [How to turn a PDF into a slide deck with AI](https://conduitllm.com/pdf-to-slides.html) — Turn a PDF report into an editable slide deck with AI: attach the PDF, approve a storyline, build the slides, edit the words and export to HTML, PowerPoint or PDF.
- [How to chat with your PDFs and get cited answers](https://conduitllm.com/chat-with-pdfs.html) — Ask questions across several PDFs at once and see which document and passage each answer came from: build a collection, attach it, check sources.
- [How to run AI agents side by side in Conduit](https://conduitllm.com/run-ai-agents.html) — Define AI agents once, each with its own model and tools, then hand them work from chat, watch them work side by side, have their work reviewed and run them on a schedule.
- [How to do deep research with Conduit and Exa](https://conduitllm.com/research-with-exa.html) — Turn on Exa search, write a research brief and read a cited report in Conduit, with solar cell research as the worked example. No Exa key needed.
- [How to automate tasks with Conduit Workflows](https://conduitllm.com/automate-with-workflows.html) — Build a Conduit workflow that watches a project's releases, summarizes each with a low-cost model, saves the summary and alerts you only to breaking changes.
