---
title: "Collegare un server MCP | mcp.tc"
description: "Aggiungi un server MCP a Claude Code, claude.ai, Claude Desktop, ChatGPT, Cursor, VS Code e altri client, con accesso, chiavi API e server locali spiegati."
url: "https://mcp.tc/it/docs/connect"
markdown: "https://mcp.tc/it/docs/connect.md"
lang: "it"
---

# Collegare un server MCP

Come aggiungere un server da mcp.tc a Claude Code, claude.ai, Claude Desktop, ChatGPT, Cursor, VS Code e altri client. Ogni passaggio usa l’URL o il pacchetto del server stesso, come i pulsanti di ogni scheda.

## Prima di iniziare

Ogni scheda mostra in cima alla pagina con cosa collegarti: l’URL del server per un server remoto, o il comando di installazione per uno locale. Quando non siamo riusciti a confermare né l’uno né l’altro, rimanda alle istruzioni del progetto. I badge sotto il nome dicono cosa serve al server.

I passaggi qui sotto sono quelli che mostra la sezione **Configurazione** di ogni scheda, qui per quattro server di esempio. Scegline uno con le tab qui sotto; la scelta vale per tutti i client di questa pagina.

- **Senza account**: [DeepWiki, verificato](https://mcp.tc/it/i/deepwiki), un server remoto che chiunque può usare, a `https://mcp.deepwiki.com/mcp`.
- **Accesso richiesto**: [Notion, verificato](https://mcp.tc/it/i/notion), un server remoto che ti chiede di accedere con OAuth.
- **Chiave API**: un server inventato su `mcp.example.com` che richiede una chiave nell’header `Authorization`.
- **Locale**: [Memory, verificato](https://mcp.tc/it/i/memory), che il tuo client avvia con `npx -y @modelcontextprotocol/server-memory`.

Sulla pagina di una scheda gli stessi passaggi sono già pronti per quel server, e i pulsanti **Aggiungi a** fanno il primo passaggio per te.

Dal terminale, [mcp-tc](https://mcp.tc/it/cli), il nostro strumento open source da riga di comando, usa gli stessi passaggi. `npx mcp-tc add deepwiki --client cursor` aggiunge il server al tuo client come descrive la sezione **Configurazione**: mostra il comando che eseguirà o la modifica al file di configurazione, chiede prima di procedere, fa un backup del file di configurazione prima di scriverlo e lascia le chiavi API sul tuo computer. `npx mcp-tc scan` cerca su mcp.tc i server presenti nelle configurazioni dei tuoi client. Per ogni server invia un solo indirizzo: il suo URL https senza credenziali, parametri di query o parti del percorso che sembrano chiavi, oppure, per un server locale, il nome del pacchetto o l’URL del repository. Chiavi, header e variabili d’ambiente restano sul tuo computer, e gli indirizzi privati non vengono mai inviati.

## Claude Code

Claude Code aggiunge i server dal terminale con `claude mcp add`. In una scheda, **Aggiungi a Claude Code** copia il comando.

### Senza account

1. Eseguilo in un terminale, nella cartella del tuo progetto:

```
claude mcp add --transport http deepwiki https://mcp.deepwiki.com/mcp
```

2. Avvia Claude Code e digita `/mcp`. **deepwiki** dovrebbe risultare collegato.

Aggiungi `--scope user` per renderlo disponibile in tutti i progetti, non solo in questo.

### Accesso richiesto

1. Eseguilo in un terminale, nella cartella del tuo progetto:

```
claude mcp add --transport http notion https://mcp.notion.com/mcp
```

2. Avvia Claude Code, digita `/mcp`, scegli **notion** e seleziona **Authenticate**. Si apre una finestra del browser per accedere a Notion.

Aggiungi `--scope user` per renderlo disponibile in tutti i progetti, non solo in questo.

### Chiave API

1. Eseguilo in un terminale, nella cartella del tuo progetto:

```
claude mcp add --transport http example https://mcp.example.com/mcp --header "Authorization: Bearer <YOUR_API_KEY>"
```

2. Sostituisci il segnaposto con la tua chiave prima di eseguirlo, poi controlla con `/mcp` dentro Claude Code.

Aggiungi `--scope user` per renderlo disponibile in tutti i progetti, non solo in questo.

### Locale

1. Eseguilo in un terminale, nella cartella del tuo progetto:

```
claude mcp add --transport stdio memory -- npx -y @modelcontextprotocol/server-memory
```

2. Avvia Claude Code e digita `/mcp`. **memory** dovrebbe risultare collegato.

Aggiungi `--scope user` per renderlo disponibile in tutti i progetti.

## claude.ai

claude.ai aggiunge i server remoti come connettori personalizzati. **Aggiungi a claude.ai** apre il modulo del connettore con nome e URL già compilati. Funziona anche un server che richiede una chiave API: aggiungi la chiave in **Request headers** nello stesso modulo, per esempio `Authorization: Bearer YOUR_KEY`. claude.ai non può avviare server locali, quindi le schede locali non lo propongono.

### Senza account

1. Apri il modulo dei connettori su claude.ai. Questo pulsante compila nome e URL per te:

[Aggiungi a claude.ai](https://claude.ai/customize/connectors?modal=add-custom-connector&connectorName=DeepWiki&connectorUrl=https%3A%2F%2Fmcp.deepwiki.com%2Fmcp)

2. Controlla che l’URL sia `https://mcp.deepwiki.com/mcp` e fai clic su **Add**.
3. Attivalo in una chat dal menu degli strumenti.

I piani gratuiti consentono un connettore personalizzato. Nei piani Team ed Enterprise lo aggiunge un owner in **Organization settings → Connectors**.

### Accesso richiesto

1. Apri il modulo dei connettori su claude.ai. Questo pulsante compila nome e URL per te:

[Aggiungi a claude.ai](https://claude.ai/customize/connectors?modal=add-custom-connector&connectorName=Notion&connectorUrl=https%3A%2F%2Fmcp.notion.com%2Fmcp)

2. Controlla che l’URL sia `https://mcp.notion.com/mcp` e fai clic su **Add**.
3. Fai clic su **Connect** e accedi quando te lo chiede Notion.

I piani gratuiti consentono un connettore personalizzato. Nei piani Team ed Enterprise lo aggiunge un owner in **Organization settings → Connectors**.

### Chiave API

1. Apri il modulo dei connettori su claude.ai. Questo pulsante compila nome e URL per te:

[Aggiungi a claude.ai](https://claude.ai/customize/connectors?modal=add-custom-connector&connectorName=Example&connectorUrl=https%3A%2F%2Fmcp.example.com%2Fmcp)

2. Controlla che l’URL sia `https://mcp.example.com/mcp`. In **Request headers** aggiungi `Authorization: Bearer <YOUR_API_KEY>` con la tua chiave di Example, poi fai clic su **Add**.
3. Attivalo in una chat dal menu degli strumenti.

I piani gratuiti consentono un connettore personalizzato. Nei piani Team ed Enterprise lo aggiunge un owner in **Organization settings → Connectors**.

## Claude Desktop

I server remoti passano dai **Connectors**, gli stessi che vedi su claude.ai, compresi quelli che richiedono una chiave API in **Request headers**. I server locali vanno nel suo file di configurazione JSON. Per tenere una chiave sul tuo computer, usa invece il bridge `mcp-remote`.

### Senza account

1. Apri **Customize → Connectors**, fai clic su **+ Add**, poi su **Add custom connector**.
2. Chiamalo **DeepWiki** e incolla questo URL:

```
https://mcp.deepwiki.com/mcp
```

3. Fai clic su **Add**. I suoi tool compaiono nel menu degli strumenti della chat.

Il file di configurazione JSON di Claude Desktop avvia solo server locali. I server remoti passano dai Connectors, e i connettori che aggiungi su claude.ai compaiono anche qui.

### Accesso richiesto

1. Apri **Customize → Connectors**, fai clic su **+ Add**, poi su **Add custom connector**.
2. Chiamalo **Notion** e incolla questo URL:

```
https://mcp.notion.com/mcp
```

3. Fai clic su **Add**, poi su **Connect**, e accedi quando te lo chiede Notion.

Il file di configurazione JSON di Claude Desktop avvia solo server locali. I server remoti passano dai Connectors, e i connettori che aggiungi su claude.ai compaiono anche qui.

### Chiave API

1. Usa il bridge `mcp-remote`, che tiene la chiave su questo computer (anche un connettore aggiunto su claude.ai con la chiave in **Request headers** compare qui). Apri **Settings → Developer → Edit Config** e aggiungi:

`claude_desktop_config.json`:

```
{
  "mcpServers": {
    "example": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "https://mcp.example.com/mcp",
        "--header",
        "Authorization: Bearer <YOUR_API_KEY>"
      ]
    }
  }
}
```

2. Sostituisci il segnaposto con la tua chiave e riavvia Claude Desktop.

Il bridge richiede Node.js sul tuo computer.

### Locale

1. Apri **Settings → Developer → Edit Config**. Si apre `claude_desktop_config.json`. Aggiungi:

`claude_desktop_config.json`:

```
{
  "mcpServers": {
    "memory": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-memory"
      ]
    }
  }
}
```

2. Salva il file e riavvia Claude Desktop.

Richiede Node.js sul tuo computer. Il file si trova in `~/Library/Application Support/Claude/` su macOS e in `%APPDATA%\Claude\` su Windows.

## ChatGPT

ChatGPT si collega ai server remoti che aggiungi in Plugins. Come claude.ai, non può avviare server locali né inviare l’header di una chiave API.

### Senza account

1. Su chatgpt.com vai su **Plugins**, seleziona **+** e poi **Add custom MCP server**.
2. Inserisci un nome per il server.
3. In **Connection** incolla `https://mcp.deepwiki.com/mcp` come URL del server, poi come autenticazione scegli **No authentication**.
4. Spunta **I understand and want to continue** e poi seleziona **Create as a plugin**.

Se puoi aggiungere un server MCP personalizzato dipende dal tuo piano ChatGPT e dai permessi del tuo workspace (nei workspace Business possono farlo admin e owner).

### Accesso richiesto

1. Su chatgpt.com vai su **Plugins**, seleziona **+** e poi **Add custom MCP server**.
2. Inserisci un nome per il server.
3. In **Connection** incolla `https://mcp.notion.com/mcp` come URL del server, poi come autenticazione scegli **OAuth**. ChatGPT ti manda su Notion per accedere.
4. Spunta **I understand and want to continue** e poi seleziona **Create as a plugin**.

Se puoi aggiungere un server MCP personalizzato dipende dal tuo piano ChatGPT e dai permessi del tuo workspace (nei workspace Business possono farlo admin e owner).

## Cursor

**Aggiungi a Cursor** apre la pagina di installazione di Cursor con i dati del server già inseriti. Puoi anche aggiungerlo a mano in `mcp.json`.

### Senza account

[Aggiungi a Cursor](https://cursor.com/install-mcp?name=deepwiki&config=eyJ1cmwiOiJodHRwczovL21jcC5kZWVwd2lraS5jb20vbWNwIn0%3D)

Oppure aggiungilo a mano in `~/.cursor/mcp.json` (tutti i progetti) o in `.cursor/mcp.json` (questo progetto):

`mcp.json`:

```
{
  "mcpServers": {
    "deepwiki": {
      "url": "https://mcp.deepwiki.com/mcp"
    }
  }
}
```

### Accesso richiesto

[Aggiungi a Cursor](https://cursor.com/install-mcp?name=notion&config=eyJ1cmwiOiJodHRwczovL21jcC5ub3Rpb24uY29tL21jcCJ9)

Oppure aggiungilo a mano in `~/.cursor/mcp.json` (tutti i progetti) o in `.cursor/mcp.json` (questo progetto):

`mcp.json`:

```
{
  "mcpServers": {
    "notion": {
      "url": "https://mcp.notion.com/mcp"
    }
  }
}
```

Cursor mostra **Needs authentication** accanto al server. Fai clic sul pulsante lì accanto per accedere.

### Chiave API

[Aggiungi a Cursor](https://cursor.com/install-mcp?name=example&config=eyJ1cmwiOiJodHRwczovL21jcC5leGFtcGxlLmNvbS9tY3AiLCJoZWFkZXJzIjp7IkF1dGhvcml6YXRpb24iOiJCZWFyZXIgPFlPVVJfQVBJX0tFWT4ifX0%3D)

Oppure aggiungilo a mano in `~/.cursor/mcp.json` (tutti i progetti) o in `.cursor/mcp.json` (questo progetto):

`mcp.json`:

```
{
  "mcpServers": {
    "example": {
      "url": "https://mcp.example.com/mcp",
      "headers": {
        "Authorization": "Bearer <YOUR_API_KEY>"
      }
    }
  }
}
```

### Locale

[Aggiungi a Cursor](https://cursor.com/install-mcp?name=memory&config=eyJjb21tYW5kIjoibnB4IiwiYXJncyI6WyIteSIsIkBtb2RlbGNvbnRleHRwcm90b2NvbC9zZXJ2ZXItbWVtb3J5Il19)

Oppure aggiungilo a mano in `~/.cursor/mcp.json` (tutti i progetti) o in `.cursor/mcp.json` (questo progetto):

`mcp.json`:

```
{
  "mcpServers": {
    "memory": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-memory"
      ]
    }
  }
}
```

Richiede Node.js sul tuo computer.

## VS Code

**Aggiungi a VS Code** apre la richiesta di installazione di VS Code. Puoi anche eseguire `code --add-mcp`, o fare commit di `.vscode/mcp.json` così chiunque lavori al progetto ha il server.

### Senza account

[Installa in VS Code](https://vscode.dev/redirect/mcp/install?name=deepwiki&config=%7B%22type%22%3A%22http%22%2C%22url%22%3A%22https%3A%2F%2Fmcp.deepwiki.com%2Fmcp%22%7D)

Oppure da un terminale:

```
code --add-mcp '{"name":"deepwiki","type":"http","url":"https://mcp.deepwiki.com/mcp"}'
```

Oppure fai commit nel repository in `.vscode/mcp.json`:

`.vscode/mcp.json`:

```
{
  "servers": {
    "deepwiki": {
      "type": "http",
      "url": "https://mcp.deepwiki.com/mcp"
    }
  }
}
```

### Accesso richiesto

[Installa in VS Code](https://vscode.dev/redirect/mcp/install?name=notion&config=%7B%22type%22%3A%22http%22%2C%22url%22%3A%22https%3A%2F%2Fmcp.notion.com%2Fmcp%22%7D)

Oppure da un terminale:

```
code --add-mcp '{"name":"notion","type":"http","url":"https://mcp.notion.com/mcp"}'
```

Oppure fai commit nel repository in `.vscode/mcp.json`:

`.vscode/mcp.json`:

```
{
  "servers": {
    "notion": {
      "type": "http",
      "url": "https://mcp.notion.com/mcp"
    }
  }
}
```

VS Code ti chiede di accedere la prima volta che il server si avvia.

### Chiave API

Aggiungilo a `.vscode/mcp.json`. VS Code chiede la chiave la prima volta e la conserva in modo sicuro:

`.vscode/mcp.json`:

```
{
  "servers": {
    "example": {
      "type": "http",
      "url": "https://mcp.example.com/mcp",
      "headers": {
        "Authorization": "Bearer ${input:api-key}"
      }
    }
  },
  "inputs": [
    {
      "type": "promptString",
      "id": "api-key",
      "description": "API key",
      "password": true
    }
  ]
}
```

### Locale

[Installa in VS Code](https://vscode.dev/redirect/mcp/install?name=memory&config=%7B%22type%22%3A%22stdio%22%2C%22command%22%3A%22npx%22%2C%22args%22%3A%5B%22-y%22%2C%22%40modelcontextprotocol%2Fserver-memory%22%5D%7D)

Oppure da un terminale:

```
code --add-mcp '{"name":"memory","type":"stdio","command":"npx","args":["-y","@modelcontextprotocol/server-memory"]}'
```

Oppure fai commit nel repository in `.vscode/mcp.json`:

`.vscode/mcp.json`:

```
{
  "servers": {
    "memory": {
      "type": "stdio",
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-memory"
      ]
    }
  }
}
```

Richiede Node.js sul tuo computer.

## Altri client

### Devin Desktop (ex Windsurf)

### Senza account

1. Aggiungilo a `~/.config/devin/mcp_config.json` (macOS e Linux) o a `%APPDATA%\devin\mcp_config.json` (Windows):

`mcp_config.json`:

```
{
  "mcpServers": {
    "deepwiki": {
      "serverUrl": "https://mcp.deepwiki.com/mcp"
    }
  }
}
```

2. Aggiorna l’elenco dei server MCP in Cascade.

Devin Desktop è il nuovo nome di Windsurf. Per i server remoti legge `serverUrl` (o `url`).

### Accesso richiesto

1. Aggiungilo a `~/.config/devin/mcp_config.json` (macOS e Linux) o a `%APPDATA%\devin\mcp_config.json` (Windows):

`mcp_config.json`:

```
{
  "mcpServers": {
    "notion": {
      "serverUrl": "https://mcp.notion.com/mcp"
    }
  }
}
```

2. Aggiorna l’elenco dei server MCP in Cascade e accedi quando richiesto.

Devin Desktop è il nuovo nome di Windsurf. Per i server remoti legge `serverUrl` (o `url`).

### Chiave API

1. Aggiungilo a `~/.config/devin/mcp_config.json` (macOS e Linux) o a `%APPDATA%\devin\mcp_config.json` (Windows):

`mcp_config.json`:

```
{
  "mcpServers": {
    "example": {
      "serverUrl": "https://mcp.example.com/mcp",
      "headers": {
        "Authorization": "Bearer <YOUR_API_KEY>"
      }
    }
  }
}
```

2. Aggiorna l’elenco dei server MCP in Cascade.

Devin Desktop è il nuovo nome di Windsurf. Per i server remoti legge `serverUrl` (o `url`).

### Locale

1. Aggiungilo a `~/.config/devin/mcp_config.json` (macOS e Linux) o a `%APPDATA%\devin\mcp_config.json` (Windows):

`mcp_config.json`:

```
{
  "mcpServers": {
    "memory": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-memory"
      ]
    }
  }
}
```

2. Aggiorna l’elenco dei server MCP in Cascade.

Devin Desktop è il nuovo nome di Windsurf.

### Codex

### Senza account

```
codex mcp add deepwiki --url https://mcp.deepwiki.com/mcp
```

Oppure modifica direttamente `~/.codex/config.toml`:

`config.toml`:

```
[mcp_servers.deepwiki]
url = "https://mcp.deepwiki.com/mcp"
```

### Accesso richiesto

```
codex mcp add notion --url https://mcp.notion.com/mcp
codex mcp login notion
```

Oppure modifica direttamente `~/.codex/config.toml`:

`config.toml`:

```
[mcp_servers.notion]
url = "https://mcp.notion.com/mcp"
```

### Chiave API

```
codex mcp add example --url https://mcp.example.com/mcp --bearer-token-env-var EXAMPLE_API_KEY
```

Oppure modifica direttamente `~/.codex/config.toml`:

`config.toml`:

```
[mcp_servers.example]
url = "https://mcp.example.com/mcp"
bearer_token_env_var = "EXAMPLE_API_KEY"
```

Imposta `EXAMPLE_API_KEY` con la tua chiave nella shell che esegue Codex.

### Locale

```
codex mcp add memory -- npx -y @modelcontextprotocol/server-memory
```

Oppure modifica direttamente `~/.codex/config.toml`:

`config.toml`:

```
[mcp_servers.memory]
command = "npx"
args = ["-y", "@modelcontextprotocol/server-memory"]
```

Richiede Node.js sul tuo computer.

### Gemini CLI

### Senza account

```
gemini mcp add --transport http deepwiki https://mcp.deepwiki.com/mcp
```

Così lo aggiungi al progetto corrente. Aggiungi `-s user` per usarlo ovunque.

### Accesso richiesto

```
gemini mcp add --transport http notion https://mcp.notion.com/mcp
```

Poi, dentro Gemini CLI, esegui `/mcp auth notion` per accedere.

Così lo aggiungi al progetto corrente. Aggiungi `-s user` per usarlo ovunque.

### Chiave API

```
gemini mcp add --transport http --header "Authorization: Bearer <YOUR_API_KEY>" example https://mcp.example.com/mcp
```

Così lo aggiungi al progetto corrente. Aggiungi `-s user` per usarlo ovunque.

### Locale

```
gemini mcp add memory npx -- -y @modelcontextprotocol/server-memory
```

Così lo aggiungi al progetto corrente. Aggiungi `-s user` per usarlo ovunque.

### Qualsiasi altro client

### Senza account

La maggior parte dei client accetta questa forma. Alcuni chiamano diversamente il campo dell’URL: `serverUrl` in Devin Desktop, `httpUrl` nel file di impostazioni di Gemini CLI.

```
{
  "mcpServers": {
    "deepwiki": {
      "type": "http",
      "url": "https://mcp.deepwiki.com/mcp"
    }
  }
}
```

Zed mette i server sotto `context_servers` nelle sue impostazioni. Cline ha bisogno di `"type": "streamableHttp"`, altrimenti presume SSE.

Il tuo client avvia solo server locali? Collegalo con `npx -y mcp-remote https://mcp.deepwiki.com/mcp`.

### Accesso richiesto

La maggior parte dei client accetta questa forma. Alcuni chiamano diversamente il campo dell’URL: `serverUrl` in Devin Desktop, `httpUrl` nel file di impostazioni di Gemini CLI.

```
{
  "mcpServers": {
    "notion": {
      "type": "http",
      "url": "https://mcp.notion.com/mcp"
    }
  }
}
```

Zed mette i server sotto `context_servers` nelle sue impostazioni. Cline ha bisogno di `"type": "streamableHttp"`, altrimenti presume SSE.

Il tuo client avvia solo server locali? Collegalo con `npx -y mcp-remote https://mcp.notion.com/mcp`.

### Chiave API

La maggior parte dei client accetta questa forma. Alcuni chiamano diversamente il campo dell’URL: `serverUrl` in Devin Desktop, `httpUrl` nel file di impostazioni di Gemini CLI.

```
{
  "mcpServers": {
    "example": {
      "type": "http",
      "url": "https://mcp.example.com/mcp",
      "headers": {
        "Authorization": "Bearer <YOUR_API_KEY>"
      }
    }
  }
}
```

Zed mette i server sotto `context_servers` nelle sue impostazioni. Cline ha bisogno di `"type": "streamableHttp"`, altrimenti presume SSE.

Il tuo client avvia solo server locali? Collegalo con `npx -y mcp-remote https://mcp.example.com/mcp`.

### Locale

La maggior parte dei client che avviano server locali accetta questa forma:

```
{
  "mcpServers": {
    "memory": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-memory"
      ]
    }
  }
}
```

Zed mette i server sotto `context_servers` nelle sue impostazioni, con gli stessi campi `command`, `args` ed `env`.

Richiede Node.js sul tuo computer.

## Accesso, chiavi API e server locali

### Accesso (OAuth)

La prima volta che il tuo client si collega, il server chiede chi sei. Il tuo client apre la pagina di accesso del fornitore in un browser, lì autorizzi l’accesso, e il client conserva il token. In Claude Code succede con `/mcp` e **Authenticate**, in Cursor con **Needs authentication** nelle impostazioni MCP, in Codex con `codex mcp login` e in Gemini CLI con `/mcp auth`.

Il token viene emesso per l’URL del server stesso, e il tuo client lo invia solo lì: l’accesso MCP lega ogni token a un unico server (resource indicator OAuth, RFC 8707). È uno dei motivi per cui ogni configurazione su mcp.tc usa l’URL del server stesso, e per cui mcp.tc non vede mai le tue credenziali.

### Chiave API

Procurati una chiave dal fornitore. I frammenti mettono un segnaposto come `<YOUR_API_KEY>` nell’header che il server si aspetta, il più delle volte `Authorization: Bearer <YOUR_API_KEY>`. Sostituiscilo nella tua configurazione e tieni quel file fuori dai repository condivisi. VS Code chiede la chiave la prima volta e la conserva in modo sicuro, e Codex la legge da una variabile d’ambiente. Su claude.ai e Claude Desktop aggiungi la chiave in **Request headers** quando crei il connettore personalizzato. ChatGPT non può inviare l’header di una chiave.

Alcuni server funzionano senza chiave e ne accettano una per avere di più. Il loro badge dice **Accesso facoltativo**, i loro comandi non includono la chiave, e la nota sotto i passaggi indica l’header in cui inviarla.

### Server locali

Il tuo client avvia un server locale come programma sul tuo computer, con il comando di installazione della sua pagina. Il comando determina cosa devi avere installato:

- `npx` richiede Node.js.
- `uvx` richiede uv (Python).
- `pipx` richiede pipx (Python).
- `docker` richiede Docker.
- `dnx` richiede .NET 10.

Un server locale gira con i permessi del tuo account utente, quindi leggi l’elenco dei suoi tool prima di aggiungerlo. Le impostazioni di cui ha bisogno, chiavi comprese, sono variabili d’ambiente, e i frammenti le mostrano come segnaposto. claude.ai e ChatGPT si collegano solo a server remoti, quindi non possono usare quelli locali.

### Accesso non confermato

Un anello grigio e **Accesso non confermato** significano che il nostro controllo non ha capito se il server richiede un accesso. I passaggi usano l’URL semplice. Se il server chiede credenziali, la documentazione del fornitore dice quali.

## Cosa fa un link di mcp.tc in un client

Il link di mcp.tc è la pagina della scheda, non l’indirizzo di un server. Un browser riceve la pagina. Un client MCP che ci si collega riceve invece un errore: HTTP 409 con un messaggio JSON-RPC che indica l’URL del server (o, per un server locale, il suo comando di installazione) e la pagina. Alcuni client mostrano il messaggio, così puoi copiarne l’indirizzo giusto; Claude Code segnala solo «Failed to connect». Questa è la risposta che riceve un client a `mcp.tc/i/deepwiki` (il messaggio è sempre in inglese, la lingua che i client si aspettano):

`HTTP 409, application/json`:

```
{
  "jsonrpc": "2.0",
  "id": 1,
  "error": {
    "code": -32001,
    "message": "mcp.tc: this link is a page, not an MCP endpoint. Connect to DeepWiki directly with its own URL: https://mcp.deepwiki.com/mcp (no sign-in needed). Setup for each client: https://mcp.tc/i/deepwiki",
    "data": {
      "listing": "https://mcp.tc/i/deepwiki",
      "endpoint": "https://mcp.deepwiki.com/mcp"
    }
  }
}
```

`data.endpoint` contiene l’URL del server, `data.command` il comando di installazione di un server locale e `data.listing` la pagina. Un link non in elenco risponde 404, e una scheda rimossa risponde 410.

Perché il link non rimanda il tuo client al server, o non inoltra le richieste? Gli SDK MCP attuali (TypeScript 1.32 e successivi, Python 1.30 e successivi) rifiutano di essere rimandati a un sito diverso, e comunque un token di accesso funziona solo all’URL del server stesso. Inoltrare le richieste renderebbe anche il tuo client dipendente da mcp.tc, quindi ogni link di mcp.tc è solo una pagina.

## Risoluzione dei problemi

### Il mio client dice «this link is a page, not an MCP endpoint»

Hai aggiunto il link di mcp.tc. Sostituiscilo con l’URL indicato in quel messaggio, o copia l’URL dal riquadro in cima alla scheda. Per un server locale usa invece il comando di installazione.

### Il server non si collega

Se l’URL che hai aggiunto inizia con `https://mcp.tc/i/`, quello è il link della pagina: sostituiscilo con l’URL del server indicato nella scheda. Altrimenti controlla che l’URL corrisponda esattamente a quello della scheda, percorso compreso: `https://mcp.deepwiki.com/mcp` e `https://mcp.deepwiki.com` sono indirizzi diversi. Riavvia il client dopo aver modificato un file di configurazione. Un badge **Ultimo controllo fallito** sulla scheda significa che anche i nostri controlli giornalieri falliscono, quindi il problema potrebbe essere dal lato del fornitore.

### Continua a chiedermi di accedere, o risponde 401

Il server richiede un accesso e il tuo client non l’ha completato. In Claude Code digita `/mcp`, scegli il server e seleziona **Authenticate**. In Cursor apri le impostazioni MCP e usa il pulsante accanto a **Needs authentication**. In Codex esegui `codex mcp login` con il nome del server, e in Gemini CLI `/mcp auth`. Con una chiave API controlla di aver sostituito il segnaposto e che l’header corrisponda alla documentazione del fornitore.

### Un server locale non si avvia

Esegui prima il suo comando di installazione in un terminale. Se lì non funziona, non può avviarlo nemmeno il client, e di solito manca il runtime: Node.js per `npx`, uv per `uvx`, Docker per `docker`. Sostituisci ogni segnaposto, come `<YOUR_API_KEY>` o `/path/to/allowed/dir`, con un valore reale.

### Il mio client avvia solo server locali

Collega il server remoto con `npx -y mcp-remote` seguito dall’URL del server. Il bridge gira sul tuo computer e richiede Node.js.

### La scheda dice SSE

Il server usa il vecchio trasporto SSE, che alcuni client non supportano più. Claude Code accetta `--transport sse`, VS Code `"type": "sse"`, e Codex ha bisogno del bridge `mcp-remote`. I passaggi di configurazione della scheda usano già quello giusto.

### I tool di un server sono cambiati dopo che l’ho aggiunto

Apri la sua scheda e guarda la sezione **Cronologia**. Quando possiamo leggere i tool del server, elenca quelli aggiunti, rimossi o modificati dalla nostra prima lettura, con ogni descrizione prima e dopo. Il tuo client potrebbe usare ancora l’elenco che avevi approvato, quindi confrontalo con ciò che mostra adesso. Per ricevere un’email alla prossima modifica, accedi e **Segui** la scheda.

### Qualcosa nella scheda è sbagliato

Usa **Segnala questa scheda** sulla sua pagina. Il testo è scritto con l’aiuto dell’AI dai metadati del server stesso, quindi capitano errori, e una persona legge ogni segnalazione.

---
Fonte: https://mcp.tc/it/docs/connect. Versione Markdown per agenti AI (chiedi `text/markdown` o aggiungi `.md` all’indirizzo). Panoramica del sito: https://mcp.tc/llms.txt
