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

# Model Context Protocol (MCP)

> Integra i server MCP con Cascade per accedere a strumenti personalizzati come GitHub, database e API. Configura i trasporti stdio, HTTP e SSE con controlli amministrativi per i team.

**MCP (Model Context Protocol)** è un protocollo che consente agli LLM di accedere a strumenti e servizi personalizzati.
Un client MCP (in questo caso, Cascade) può inviare richieste ai server MCP per accedere agli strumenti che mettono a disposizione.
Cascade ora si integra nativamente con MCP, consentendoti di usare la tua selezione di server MCP in Cascade.
Per ulteriori informazioni, consulta la [documentazione ufficiale di MCP](https://modelcontextprotocol.io/).

<Note>Gli utenti Enterprise devono attivarlo manualmente nelle Settings</Note>

<div id="adding-a-new-mcp">
  ## Aggiungere un nuovo MCP
</div>

I nuovi MCP possono essere aggiunti dal MCP Marketplace, a cui puoi accedere
facendo clic sull'icona `MCPs` nel menu in alto a destra del pannello Cascade, oppure dalla
sezione `Devin Settings` > `Cascade` > `MCP Servers`.

Se non riesci a trovare l'MCP desiderato, puoi aggiungerlo manualmente modificando direttamente il file `mcp_config.json`.

Gli MCP ufficiali saranno contrassegnati da un segno di spunta blu, a indicare che sono realizzati dall'azienda che gestisce il servizio.

Quando fai clic su un MCP, ti basta selezionare `Install` per rendere disponibili a Cascade il server e i relativi strumenti.

<div id="one-click-install-via-deeplink">
  ### Installazione con un clic tramite deeplink
</div>

Devin Desktop supporta l'installazione di MCP con un clic tramite deeplink. Puoi usare questi collegamenti per aprire direttamente la pagina del registry MCP in Devin Desktop, utile per condividere suggerimenti sui server MCP o integrare pulsanti di installazione nella documentazione.

Il formato del deeplink è:

```
windsurf://windsurf-mcp-registry?serverName=<server-name>
```

* **Con `serverName`**: apre la pagina del registry MCP per il server specificato, dove l'utente può consultarlo e installarlo.
* **Senza `serverName`**: apre la pagina di MCP Marketplace.

Ad esempio, `windsurf://windsurf-mcp-registry?serverName=github-mcp-server` aprirà la pagina del registry del server MCP GitHub in Devin Desktop.

<Note>I deeplink di installazione con un clic richiedono che il team dell'utente abbia l'accesso a MCP abilitato. Se l'accesso a MCP è disabilitato da un amministratore, il deeplink non aprirà la pagina del registry.</Note>

Devin Desktop supporta tre [tipi di trasporto](https://modelcontextprotocol.io/docs/concepts/transports) per i server MCP: `stdio`,  `Streamable HTTP` e `SSE`.

Devin Desktop supporta anche OAuth per ogni tipo di trasporto.

Per i server `http`, l'URL deve corrispondere a quello dell'endpoint e avere un formato simile a `https://<your-server-url>/mcp`.

<Frame>
  <img src="https://mintcdn.com/cognitionai/hxeMffzXgF_RWx-U/desktop/assets/windsurf/cascade/mcp/mcp-plugin-store.png?fit=max&auto=format&n=hxeMffzXgF_RWx-U&q=85&s=cedf7260fa823c72486f1c35faa542f0" width="955" height="774" data-path="desktop/assets/windsurf/cascade/mcp/mcp-plugin-store.png" />
</Frame>

<div id="configuring-mcp-tools">
  ## Configurazione degli strumenti MCP
</div>

Ogni MCP ha accesso a un certo numero di strumenti. Cascade ha un limite massimo di 100 strumenti accessibili in un dato momento.

In ogni pagina Settings di un MCP, puoi abilitare o disabilitare gli strumenti desiderati. Per
aprire le Settings di un MCP, fai clic sull'icona `MCPs` nel menu in alto a destra del
pannello Cascade, quindi fai clic sull'MCP desiderato.

<Frame>
  <img src="https://mintcdn.com/cognitionai/hxeMffzXgF_RWx-U/desktop/assets/windsurf/cascade/mcp/mcp-manage-plugin-tools.png?fit=max&auto=format&n=hxeMffzXgF_RWx-U&q=85&s=81513e7073b00eb6d9c53017789b08c1" width="893" height="639" data-path="desktop/assets/windsurf/cascade/mcp/mcp-manage-plugin-tools.png" />
</Frame>

<div id="mcp_configjson">
  ## mcp\_config.json
</div>

Il file `~/.codeium/windsurf/mcp_config.json` è un file JSON che contiene un elenco di server a cui Cascade può collegarsi.

Ecco un esempio di configurazione che imposta un singolo server per GitHub:

```json theme={null}
{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-github"
      ],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "<YOUR_PERSONAL_ACCESS_TOKEN>"
      }
    }
  }
}
```

Assicurati di fornire gli argomenti richiesti e le variabili d'ambiente per i server che intendi usare.

Consulta il [repository di riferimento ufficiale dei server MCP](https://github.com/modelcontextprotocol/servers) o [OpenTools](https://opentools.com/) per alcuni esempi di server.

<div id="popular-mcp-server-examples">
  ### Esempi di server MCP più diffusi
</div>

Di seguito sono riportati alcuni esempi di configurazione per server MCP di uso comune. Puoi aggiungerli al file `mcp_config.json`.

<AccordionGroup>
  <Accordion title="GitHub" description="Gestione dei repository, operazioni sui file e integrazione con l'API di GitHub.">
    Il server MCP di GitHub fornisce strumenti per la gestione dei repository, le operazioni sui file, il monitoraggio delle issue e la gestione delle pull request.

    **Con npx:**

    ```json theme={null}
    {
      "mcpServers": {
        "github": {
          "command": "npx",
          "args": ["-y", "@modelcontextprotocol/server-github"],
          "env": {
            "GITHUB_PERSONAL_ACCESS_TOKEN": "<YOUR_PERSONAL_ACCESS_TOKEN>"
          }
        }
      }
    }
    ```

    **Con Docker:**

    ```json theme={null}
    {
      "mcpServers": {
        "github": {
          "command": "docker",
          "args": [
            "run", "-i", "--rm",
            "-e", "GITHUB_PERSONAL_ACCESS_TOKEN",
            "ghcr.io/github/github-mcp-server"
          ],
          "env": {
            "GITHUB_PERSONAL_ACCESS_TOKEN": "<YOUR_PERSONAL_ACCESS_TOKEN>"
          }
        }
      }
    }
    ```

    Per creare un token di accesso personale, vai a [GitHub Settings > Developer settings > Personal access tokens](https://github.com/settings/tokens).
  </Accordion>

  <Accordion title="Slack" description="Gestione dei canali e funzionalità di messaggistica per i workspace Slack.">
    Il server MCP di Slack consente di gestire i canali, inviare messaggi e interagire con il workspace.

    ```json theme={null}
    {
      "mcpServers": {
        "slack": {
          "command": "npx",
          "args": ["-y", "@anthropic/mcp-server-slack"],
          "env": {
            "SLACK_BOT_TOKEN": "<YOUR_SLACK_BOT_TOKEN>",
            "SLACK_TEAM_ID": "<YOUR_SLACK_TEAM_ID>"
          }
        }
      }
    }
    ```

    Per configurare un token bot di Slack:

    1. Crea una Slack App su [api.slack.com/apps](https://api.slack.com/apps)
    2. Aggiungi gli OAuth scopes richiesti (ad es. `channels:read`, `chat:write`, `users:read`)
    3. Installa l'app nel tuo workspace e copia il Bot User OAuth Token
  </Accordion>

  <Accordion title="PostgreSQL" description="Accesso al database in sola lettura con funzionalità di ispezione dello schema.">
    Il server MCP di PostgreSQL fornisce accesso in sola lettura ai database PostgreSQL, inclusi l'ispezione dello schema e l'esecuzione di query.

    ```json theme={null}
    {
      "mcpServers": {
        "postgres": {
          "command": "npx",
          "args": ["-y", "@modelcontextprotocol/server-postgres"],
          "env": {
            "POSTGRES_CONNECTION_STRING": "postgresql://user:password@localhost:5432/database"
          }
        }
      }
    }
    ```

    <Warning>Per motivi di sicurezza, il server PostgreSQL fornisce per impostazione predefinita accesso in sola lettura. Assicurati che la stringa di connessione utilizzi credenziali appropriate con autorizzazioni limitate.</Warning>
  </Accordion>

  <Accordion title="Filesystem" description="Operazioni sicure sui file con controlli di accesso configurabili.">
    Il server MCP Filesystem fornisce accesso sicuro a file e directory locali con controlli di accesso configurabili.

    ```json theme={null}
    {
      "mcpServers": {
        "filesystem": {
          "command": "npx",
          "args": [
            "-y", "@modelcontextprotocol/server-filesystem",
            "/path/to/allowed/directory"
          ]
        }
      }
    }
    ```

    Puoi specificare più directory consentite aggiungendo ulteriori argomenti di percorso. Saranno accessibili solo i file all'interno di queste directory.
  </Accordion>

  <Accordion title="Brave Search" description="Ricerca sul web e locale tramite l'API Search di Brave.">
    Il server MCP Brave Search abilita funzionalità di ricerca sul web tramite l'API Search di Brave.

    ```json theme={null}
    {
      "mcpServers": {
        "brave-search": {
          "command": "npx",
          "args": ["-y", "@anthropic/mcp-server-brave-search"],
          "env": {
            "BRAVE_API_KEY": "<YOUR_BRAVE_API_KEY>"
          }
        }
      }
    }
    ```

    Per ottenere una API key di Brave, registrati su [brave.com/search/api](https://brave.com/search/api/).
  </Accordion>

  <Accordion title="Memory" description="Sistema di memoria persistente basato su grafo della conoscenza.">
    Il server MCP Memory fornisce un sistema di memoria persistente basato su un grafo della conoscenza, che consente a Cascade di ricordare informazioni da una sessione all'altra.

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

    Il server di memoria archivia i dati localmente e li conserva tra le sessioni, risultando utile per mantenere il contesto relativo a progetti, preferenze e informazioni apprese.
  </Accordion>
</AccordionGroup>

<div id="remote-http-mcps">
  ### MCP HTTP remoti
</div>

È importante tenere presente che, per i MCP HTTP remoti, la configurazione è leggermente
diversa e richiede un campo `serverUrl` o `url`.

Ecco un esempio di configurazione per un server HTTP:

```json theme={null}
{
  "mcpServers": {
    "remote-http-mcp": {
      "serverUrl": "<your-server-url>/mcp",
      "headers": {
        "API_KEY": "value"
      }
    }
  }
}
```

<div id="config-interpolation">
  ### Interpolazione della configurazione
</div>

Il file `~/.codeium/windsurf/mcp_config.json` supporta l'interpolazione delle variabili
nei seguenti campi: `command`, `args`, `env`, `serverUrl`, `url` e
`headers`. In questo modo puoi evitare di inserire i segreti direttamente nel file di configurazione.

Sono supportati due pattern di interpolazione:

* **`${env:VAR_NAME}`** — sostituito con il valore della variabile d'ambiente `VAR_NAME`. Se la variabile non è impostata, si risolve in una stringa vuota.
* **`${file:/path/to/file}`** — sostituito con il contenuto del file nel percorso specificato, senza spazi iniziali o finali. Sono supportati i percorsi con tilde (ad es. `~/secrets/key.txt`). Se il file non può essere letto, il pattern resta invariato.

Ecco un esempio che usa una variabile d'ambiente in `headers`:

```json theme={null}
{
  "mcpServers": {
    "remote-http-mcp": {
      "serverUrl": "<your-server-url>/mcp",
      "headers": {
        "API_KEY": "Bearer ${env:AUTH_TOKEN}"
      }
    }
  }
}
```

Ecco un esempio di come leggere una chiave API da un file:

```json theme={null}
{
  "mcpServers": {
    "my-server": {
      "command": "node",
      "args": ["server.js"],
      "env": {
        "API_KEY": "${file:~/.secrets/api_key.txt}"
      }
    }
  }
}
```

<div id="admin-controls-teams-enterprises">
  ## Controlli amministrativi (Team ed Enterprise)
</div>

Gli amministratori del team possono attivare o disattivare l'accesso a MCP per il proprio team, nonché inserire nella whitelist i server MCP approvati che il team può usare:

<div id="mcp-registry">
  ### MCP Registry
</div>

I team Enterprise possono configurare registry MCP personalizzati in sostituzione del marketplace MCP predefinito di Devin Desktop. I team possono collegare gli URL dei propri registry per controllare quali MCP sono disponibili per i propri utenti.

<Note>I registry sono l'approccio preferito per gestire l'accesso agli MCP, anche se anche le whitelist funzionano.</Note>

<div id="configuring-custom-registries">
  #### Configurazione di registry personalizzati
</div>

1. Apri Team Settings
2. Trova l'impostazione **MCP Registry URLs**
3. Aggiungi uno o più URL di registry

Quando sono configurati più URL di registry, Devin Desktop usa l'**unione** di tutti i registry: gli utenti vedranno gli MCP di tutte le fonti configurate in un unico elenco. Il marketplace MCP del team recupererà quindi i dati da questi registry interni anziché dal registry predefinito di Devin Desktop.

<Note>I registry personalizzati devono seguire lo [schema ufficiale del registry MCP](https://modelcontextprotocol.io/). Questo garantisce la compatibilità e definizioni standardizzate dei server.</Note>

<div id="mcp-whitelist">
  ### Whitelist MCP
</div>

<Card title="Settings del team MCP" horizontal={true} icon="hammer" href="https://windsurf.com/team/settings">
  Impostazioni MCP configurabili per il tuo team.
</Card>

<Warning>Il collegamento sopra funzionerà solo se disponi dei privilegi di amministratore per il tuo team.</Warning>

Per impostazione predefinita, gli utenti di un team possono configurare i propri server MCP. Tuttavia, non appena inserisci nella whitelist anche un solo server MCP, **tutti i server non inclusi nella whitelist verranno bloccati** per il tuo team.

<Note>Il Server ID nella whitelist deve corrispondere, con distinzione tra maiuscole e minuscole, al nome della chiave usato nel file `mcp_config.json` dell'utente.</Note>

<div id="how-server-matching-works">
  ### Come funziona la corrispondenza dei server
</div>

Quando inserisci un server MCP nella whitelist, il sistema usa la **corrispondenza tramite pattern regex** secondo le seguenti regole:

* **Corrispondenza dell'intera stringa**: tutti i pattern sono automaticamente ancorati (racchiusi in `^(?:pattern)$`) per evitare corrispondenze parziali
* **Campo Command**: deve corrispondere esattamente o in base al pattern regex specificato
* **Array Arguments**: ogni argomento viene confrontato singolarmente con il pattern corrispondente
* **Lunghezza dell'array**: il numero di argomenti deve corrispondere esattamente tra la whitelist e la configurazione utente
* **Caratteri speciali**: caratteri come `$`, `.`, `[`, `]`, `(`, `)` hanno un significato speciale nelle regex e devono essere preceduti da `\` se vuoi una corrispondenza letterale

<div id="configuration-options">
  ### Opzioni di configurazione
</div>

<AccordionGroup>
  <Accordion title="Opzione 1: predefinita del Plugin Store (consigliata)" description="Lascia vuoto il campo Server Config (JSON) per consentire l'uso della configurazione predefinita del Devin Desktop MCP Plugin Store.">
    **Configurazione della whitelist degli admin:**

    * **Server ID**: `github-mcp-server`
    * **Server Config (JSON)**: *(lasciare vuoto)*

    ```json theme={null}
    {}
    ```

    **Configurazione utente corrispondente (`mcp_config.json`):**

    ```json theme={null}
    {
      "mcpServers": {
        "github-mcp-server": {
          "command": "docker",
          "args": [
            "run",
            "-i",
            "--rm",
            "-e",
            "GITHUB_PERSONAL_ACCESS_TOKEN",
            "ghcr.io/github/github-mcp-server"
          ],
          "env": {
            "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_your_token_here"
          }
        }
      }
    }
    ```

    Questo consente agli utenti di installare il server MCP di GitHub con qualsiasi configurazione valida, purché il Server ID corrisponda alla voce del Plugin Store.
  </Accordion>

  <Accordion title="Opzione 2: configurazione con corrispondenza esatta" description="Fornisci la configurazione esatta che gli utenti devono usare. Questa configurazione deve essere rispettata esattamente.">
    **Configurazione della whitelist degli admin:**

    * **Server ID**: `github-mcp-server`
    * **Server Config (JSON)**:

    ```json theme={null}
    {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "-e",
        "GITHUB_PERSONAL_ACCESS_TOKEN",
        "ghcr.io/github/github-mcp-server"
      ],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": ""
      }
    }
    ```

    **Configurazione utente corrispondente (`mcp_config.json`):**

    ```json theme={null}
    {
      "mcpServers": {
        "github-mcp-server": {
          "command": "docker",
          "args": [
            "run",
            "-i",
            "--rm",
            "-e",
            "GITHUB_PERSONAL_ACCESS_TOKEN",
            "ghcr.io/github/github-mcp-server"
          ],
          "env": {
            "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_your_token_here"
          }
        }
      }
    }
    ```

    Gli utenti devono usare esattamente questa configurazione: qualsiasi variazione nel comando o negli argomenti verrà bloccata. La sezione `env` può avere valori diversi.
  </Accordion>

  <Accordion title="Opzione 3: pattern regex flessibili" description="Usa pattern regex per consentire variazioni nelle configurazioni utente mantenendo i controlli di sicurezza.">
    **Configurazione della whitelist degli admin:**

    * **Server ID**: `python-mcp-server`
    * **Server Config (JSON)**:

    ```json theme={null}
    {
      "command": "python3",
      "args": ["/.*\\.py", "--port", "[0-9]+"]
    }
    ```

    **Configurazione utente corrispondente (`mcp_config.json`):**

    ```json theme={null}
    {
      "mcpServers": {
        "python-mcp-server": {
          "command": "python3",
          "args": ["/home/user/my_server.py", "--port", "8080"],
          "env": {
            "PYTHONPATH": "/home/user/mcp"
          }
        }
      }
    }
    ```

    Questo esempio offre agli utenti flessibilità mantenendo al tempo stesso la sicurezza:

    * La regex `/.*\\.py` corrisponde a qualsiasi percorso di file Python, ad esempio `/home/user/my_server.py`
    * La regex `[0-9]+` corrisponde a qualsiasi porta numerica, ad esempio `8080` o `3000`
    * Gli utenti possono personalizzare i percorsi dei file e le porte, mentre gli admin garantiscono che vengano eseguiti solo script Python
  </Accordion>
</AccordionGroup>

<div id="common-regex-patterns">
  ### Pattern regex comuni
</div>

| Pattern         | Corrisponde a                       | Esempio                |
| --------------- | ----------------------------------- | ---------------------- |
| `.*`            | Una stringa qualsiasi               | `/home/user/script.py` |
| `[0-9]+`        | Qualsiasi numero                    | `8080`, `3000`         |
| `[a-zA-Z0-9_]+` | Caratteri alfanumerici + underscore | `api_key_123`          |
| `\\$HOME`       | `$HOME` letterale                   | `$HOME` (non espanso)  |
| `\\.py`         | `.py` letterale                     | `script.py`            |
| `\\[cli\\]`     | `[cli]` letterale                   | `mcp[cli]`             |

<div id="notes">
  ## Note
</div>

<div id="admin-configuration-guidelines">
  ### Linee guida per la configurazione Admin
</div>

* **Variabili d'ambiente**: la sezione `env` non è soggetta a corrispondenza con `regex` e può essere configurata liberamente dagli utenti
* **Strumenti disabilitati**: l'array `disabledTools` viene gestito separatamente e non rientra nella corrispondenza della whitelist
* **Sensibilità alle maiuscole/minuscole**: tutta la corrispondenza distingue tra maiuscole e minuscole
* **Gestione degli errori**: i pattern `regex` non validi vengono registrati nei log e comportano il rifiuto dell'accesso
* **Testing**: testa con attenzione i tuoi pattern `regex` - pattern troppo restrittivi potrebbero bloccare casi d'uso legittimi

<div id="troubleshooting">
  ### Risoluzione dei problemi
</div>

Se gli utenti segnalano che i loro server MCP non funzionano dopo essere stati inseriti nella whitelist:

1. **Verifica la corrispondenza esatta**: assicurati che il pattern della whitelist corrisponda esattamente alla configurazione dell'utente
2. **Verifica l'escape delle regex**: i caratteri speciali potrebbero dover essere sottoposti a escape (ad es. `\.` per i punti letterali)
3. **Controlla i log**: i pattern regex non validi vengono registrati con avvisi
4. **Testa i pattern**: usa uno strumento di test per regex per verificare che i pattern funzionino come previsto

Ricorda: una volta inserito nella whitelist un server qualsiasi, **tutti gli altri server vengono automaticamente bloccati** per i membri del tuo team.

<div id="general-information">
  ### Informazioni generali
</div>

* Poiché le chiamate agli strumenti MCP possono invocare codice scritto da implementatori di server terzi, non ci assumiamo alcuna responsabilità
  per eventuali errori nelle chiamate agli strumenti MCP. Per ribadirlo:
* Al momento supportiamo gli [strumenti](https://modelcontextprotocol.io/docs/concepts/tools), le [risorse](https://modelcontextprotocol.io/docs/concepts/resources) e i [prompt](https://modelcontextprotocol.io/docs/concepts/prompts) di un server MCP.