---
title: "MCP Servers"
description: "Manage your team's MCP servers centrally on localskills.sh and install them into Claude Code, Cursor, Windsurf, VS Code, and other tools with one CLI command."
---

> Documentation Index
> Fetch the complete documentation index at: https://docs.localskills.sh/llms.txt
> Use this file to discover all available pages before exploring further.

# MCP Servers

Team admins register **MCP server configurations** centrally, and members
install them into their AI tools with one command. No more copy-pasting JSON
snippets around Slack: the registry is the source of truth, and installs stay
in sync.

## Registering a server

Open `Dashboard → Team → MCP Servers` and register a server. Three transports
are supported, one local and two remote:

| Flag | Description |
| --- | --- |
| `stdio` | A local process (e.g. an npx package): command, arguments, env vars |
| `http / sse` | A hosted remote server: URL plus headers |

Env vars and headers are declared as specs. Each spec is either a **fixed
value** (plain, non-secret config the admin sets once) or **member-supplied**
(each member provides their own value at install time).

> **Note**
>
> Never put secrets in fixed values; they are stored in plain text on the
> platform. Mark secrets as member-supplied instead; those values are prompted
> locally and never reach localskills.sh.

## Installing

List what your teams offer, then install:

```sh
localskills mcp list
localskills mcp install acme/github
```

By default the CLI installs into every detected tool that supports the
server's transport. Narrow it with flags:

| Flag | Description |
| --- | --- |
| `-t, --target <platforms>` | Comma-separated targets, e.g. claude,cursor |
| `-g, --global` | Install into user-level configs |
| `-p, --project [dir]` | Install into project configs (default: cwd) |
| `--var NAME=value` | Provide a member-supplied value non-interactively (CI) |
| `--force` | Overwrite an entry that localskills did not create |

Supported tools and the config file each install writes:

| Flag | Description |
| --- | --- |
| `claude` | `.mcp.json` (project) / `~/.claude.json` (global) |
| `cursor` | `.cursor/mcp.json` (project) / `~/.cursor/mcp.json` (global) |
| `windsurf` | `~/.codeium/windsurf/mcp_config.json` (global only) |
| `copilot` | `.vscode/mcp.json` (project only, native inputs for secrets) |
| `cline` | `~/.cline/data/settings/cline_mcp_settings.json` (global only) |
| `codex` | `~/.codex/config.toml` (global only) |
| `opencode` | `opencode.json` (project) / `~/.config/opencode/opencode.json` |

> **Note**
>
> aider is not a target; it has no MCP support. Installing an org config means
> your machine runs a command your team admins defined; it is the same trust
> model as installing team skills.

## Linking servers to skills

A **private** skill that depends on an MCP server (say, a Linear triage skill
that needs the Linear server) can declare it as a **required MCP server**. Open
the skill's `Edit` page and tick the servers it needs. Requirements are shown
on the skill page, and `localskills install` offers to install any that are
missing right after the skill itself:

```text
localskills install acme/linear-triage
◇ Installed to 1 target(s).
◆ Install required MCP server Linear (acme/linear)?
│ ● Yes / ○ No
```

Requirements exist only on private team skills, so installers are always
members. The prompt appears in interactive terminals; CI and other
non-interactive runs get a printed note with the exact
`localskills mcp install` commands instead. Offers are location- and
platform-aware: a server in your user-level config counts everywhere for that
tool, a project install only counts for that project, and each targeted tool
needs its own entry. Installing
the skill in a new project, or adding a new tool (say Cursor after Claude
Code), offers its servers there again, writing only the missing entries.
Declining never affects the skill install, and `localskills pull` lists
requirements added after you installed.

> **Note**
>
> Requirements are limited to **private skills** for now: the MCP registry is
> member-only, so a public installer couldn't fetch the servers anyway. Making
> a linked skill public or unlisted is rejected until its requirements are
> removed. Skill pages show only a required server's name, slug, and transport,
> never its command, URL, env, or headers. Uninstalling a skill never removes
> MCP servers; other skills or tools may share them.

Requirements are set per skill (not per version) via the edit page or
`PUT /api/skills/{id}` with `requiredMcpServerIds`, and only servers registered
to the skill's own team can be required. Changing them needs `skill:update`.

## Secrets

The platform stores only the *names* of member-supplied vars. At install the
CLI prompts for values (hidden input for secrets) and writes them directly into
your tool's own config file, exactly where that tool expects them. The VS Code
target goes one step further: it emits native `inputs` declarations so VS Code
prompts you itself and keeps values in its secret storage.

## Updating

Every edit to a server bumps its revision. `localskills mcp list` flags
installs that are behind, and:

```sh
localskills mcp pull
```

rewrites drifted entries while preserving the values you supplied at install.
If an update added a new required var, the CLI prompts for just that one.

## Permissions

Browsing and installing requires the `mcpServer:read` permission, which the
built-in member role has. Registering, editing, and deleting servers requires
`mcpServer:create/update/delete`, held by owners and admins and grantable to
custom roles. All changes appear in the team audit log.

Source: https://docs.localskills.sh/mcp-servers/index.mdx