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

# Marketplace MCP (Model Context Protocol)

MCP è un protocollo aperto che consente a Devin di utilizzare centinaia di strumenti e sorgenti di dati esterni. Devin supporta 3 metodi di trasporto (stdio, SSE e HTTP).

<div id="why-use-mcp">
  ## Perché usare MCP?
</div>

Con MCP, Devin può aiutarti a:

* analizzare i log di Sentry, Datadog e Vercel
* [usare Devin come data analyst](https://devin.ai/ai-data-analyst-1) in Slack con MCP per database
* approfondire i problemi di SonarQube, CircleCI e Jam
* creare in blocco ticket Linear, documenti Notion, Google Docs (tramite Zapier) e altro ancora
* ottenere contesto da Airtable, Stripe e Hubspot e interagirci direttamente
* molto altro ancora!

<div id="get-started-with-mcps">
  ## Per iniziare a usare gli MCP
</div>

Vai su [Settings > Connessioni > server MCP](https://app.devin.ai/settings/connections?tab=mcps) per esplorare e abilitare gli MCP.

<CardGroup cols={2}>
  <Card title="Usa Devin per l'analisi dei dati su Slack collegando Devin agli MCP di database" icon="chart-simple" href="https://devin.ai/ai-data-analyst-1/">
    Consulta la nostra guida passo passo!
  </Card>

  <Card title="Esplora i casi d'uso MCP" icon="grid-2" href="/it/use-cases/gallery/index">
    Esplora esempi pratici di Devin con MCP come Datadog, Sentry, Linear, Figma e altro.
  </Card>
</CardGroup>

<div id="configuration-tips">
  ## Suggerimenti di configurazione
</div>

<Note>
  Per gli MCP che si autenticano con OAuth, Devin ti chiederà di visitare un URL per collegare il tuo account. **Consigliamo vivamente di usare un account di servizio**, non il tuo account personale, poiché l'accesso sarà condiviso all'interno della tua organizzazione.
</Note>

<Note>
  Non trovi l'MCP che ti serve? Gli amministratori dell'organizzazione possono aggiungere qualsiasi server MCP usando il pulsante **Add a custom MCP**. Se non hai autorizzazioni di amministratore, usa **Suggest MCP Integration** per richiederne uno.

  Hai problemi? Contattaci tramite la nostra [pagina di supporto](https://app.devin.ai/settings/support) o via [support@cognition.ai](mailto:support@cognition.ai).
</Note>

<div id="setting-up-a-custom-mcp-server">
  ## Configurare un server MCP personalizzato
</div>

Se l’MCP di cui hai bisogno non è nel marketplace, gli admin dell’organizzazione possono aggiungere qualsiasi server MCP usando il pulsante **Add a custom MCP**. Devin supporta tre tipi di trasporto per i server personalizzati:

<Note>
  L’aggiunta di server MCP personalizzati richiede l’autorizzazione **Gestire server MCP**. Se non vedi il pulsante **Add a custom MCP**, contatta un admin della tua organizzazione oppure usa l’opzione **Suggest MCP Integration** per richiedere un nuovo server.
</Note>

| Trasporto | Ideale per                                                | Campi richiesti                          |
| --------- | --------------------------------------------------------- | ---------------------------------------- |
| **STDIO** | Server locali basati su CLI (ad es. `npx`, `uvx`, Docker) | Comando, argomenti, variabili d'ambiente |
| **SSE**   | Server remoti che usano Server-Sent Events                | URL del server, intestazioni             |
| **HTTP**  | Server remoti che usano Streamable HTTP                   | URL del server, intestazioni             |

<div id="step-by-step-adding-a-custom-mcp-server">
  ### Procedura passo passo: aggiungere un MCP server personalizzato
</div>

1. Vai a [Settings > Connessioni > server MCP](https://app.devin.ai/settings/connections?tab=mcps).
2. Clicca su **Add a custom MCP** nella parte superiore della pagina.
3. Compila i dettagli del server:
   * **Server Name**: un nome descrittivo per il server (ad es. "Internal API Gateway").
   * **Icon** (opzionale): un'emoji o un URL da usare come icona del server.
   * **Short Description**: un breve riepilogo di ciò che fa il server.
4. Seleziona il **tipo di trasporto** (STDIO, SSE o HTTP).
5. Compila i campi di configurazione specifici del trasporto (vedi [Configuration format](#configuration-format) di seguito).
6. Clicca su **Save** per creare il server.
7. Clicca su **Test listing tools** per verificare la connessione. Devin avvierà un ambiente di test isolato, si connetterà al tuo server e proverà a rilevarne gli strumenti disponibili.

<Note>
  Il pulsante **Test listing tools** è disabilitato finché non salvi la configurazione. Se la convalida non riesce, controlla il messaggio di errore visualizzato: indicherà se il problema riguarda la connettività, l'autenticazione o un timeout.
</Note>

<div id="configuration-format">
  ### Formato di configurazione
</div>

<Note>
  Gli esempi seguenti mostrano le rappresentazioni JSON dei campi di configurazione di ciascun trasporto. In pratica, compilerai questi campi tramite il form web: non è necessario scrivere o incollare JSON. Il formato JSON è mostrato qui per chiarezza e come riferimento per configurazioni basate su API o programmatiche.
</Note>

<div id="stdio-transport">
  #### Trasporto STDIO
</div>

Usa STDIO per i server eseguiti come processi locali. Devi fornire il comando per avviare il server, insieme a eventuali argomenti e variabili d'ambiente.

**Campi:**

* **Command** (obbligatorio): L'eseguibile da lanciare (ad es. `npx`, `uvx`, `docker`).
* **Arguments**: Argomenti da riga di comando passati al server.
* **Environment Variables**: Coppie chiave-valore impostate nell'ambiente del processo del server. Usale per passare API key, token o valori di configurazione.

**Esempio — un server STDIO personalizzato che usa `npx`:**

```json theme={null}
{
  "transport": "STDIO",
  "command": "npx",
  "args": ["-y", "@example/my-mcp-server"],
  "env_variables": {
    "API_KEY": "your-api-key",
    "API_BASE_URL": "https://internal-api.example.com"
  }
}
```

**Esempio — un server STDIO personalizzato con Docker:**

```json theme={null}
{
  "transport": "STDIO",
  "command": "docker",
  "args": ["run", "-i", "--rm", "-e", "DB_CONNECTION_STRING", "my-org/my-mcp-server:latest"],
  "env_variables": {
    "DB_CONNECTION_STRING": "postgresql://user:pass@host:5432/mydb"
  }
}
```

<div id="sse-and-http-transports">
  #### Trasporti SSE e HTTP
</div>

Usa SSE o HTTP per server remoti accessibili tramite la rete. HTTP (Streamable HTTP) è consigliato per le nuove integrazioni; SSE è supportato per i server legacy.

**Campi:**

* **Server URL** (obbligatorio): L'URL dell'endpoint del server MCP.
* **Metodo di autenticazione**: Scegli tra `None`, `Auth Header` o `OAuth`.
  * Per **Auth Header**: Fornisci la chiave dell'intestazione (impostata per impostazione predefinita su `Authorization`) e il valore dell'intestazione (ad esempio `Bearer your-token`).
  * Per **OAuth**: Devin ti chiederà di completare un flusso OAuth durante la tua prima sessione. Se il tuo provider richiede applicazioni OAuth pre-registrate (senza registrazione dinamica del client), fornisci il tuo Client ID e il tuo secret in **credenziali OAuth** e aggiungi l'URL di callback di Devin `https://api.devin.ai/mcp/oauth/callback` all'allowlist degli URI di reindirizzamento nelle Settings della tua applicazione OAuth.

**Esempio — server HTTP remoto con autenticazione tramite bearer token:**

```json theme={null}
{
  "transport": "HTTP",
  "url": "https://mcp.internal-service.example.com/mcp",
  "auth_method": "auth_header",
  "headers": {
    "Authorization": "Bearer your-api-token"
  }
}
```

**Esempio — un server SSE remoto senza autenticazione:**

```json theme={null}
{
  "transport": "SSE",
  "url": "https://mcp.example.com/sse"
}
```

<Tip>
  Quando devi scegliere tra SSE e HTTP, preferisci **HTTP** (Streamable HTTP). SSE è un protocollo legacy ed è in fase di deprecazione in tutto l'ecosistema MCP.
</Tip>

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

<div id="connecting-to-an-internal-api">
  ### Connessione a un'API interna
</div>

Esponi la tua API interna come server MCP in modo che Devin possa interrogarla direttamente. Usa il trasporto STDIO con un wrapper che traduce le chiamate degli strumenti MCP in richieste API.

```json theme={null}
{
  "transport": "STDIO",
  "command": "npx",
  "args": ["-y", "@example/api-mcp-bridge"],
  "env_variables": {
    "API_BASE_URL": "https://api.internal.example.com",
    "API_TOKEN": "your-internal-api-token"
  }
}
```

In alternativa, se la tua API interna è raggiungibile in rete, usa il trasporto HTTP:

```json theme={null}
{
  "transport": "HTTP",
  "url": "https://api.internal.example.com/mcp",
  "headers": {
    "Authorization": "Bearer your-internal-api-token"
  }
}
```

<div id="connecting-to-a-database">
  ### Connessione a un database
</div>

Utilizza un server MCP per database per concedere a Devin l’accesso in lettura o scrittura ai tuoi dati. Esistono molti server mantenuti dalla community per i database più comuni.

```json theme={null}
{
  "transport": "STDIO",
  "command": "npx",
  "args": ["-y", "@modelcontextprotocol/server-postgres", "postgresql://user:password@host:5432/database"]
}
```

<Note>
  Per i database di produzione, utilizza una stringa di connessione **di sola lettura** o un utente del database con permessi limitati. Devin esegue query in base alle istruzioni dell'utente, quindi è importante limitare correttamente i relativi diritti di accesso.
</Note>

<div id="connecting-to-a-custom-tool-or-script">
  ### Collegamento a uno strumento o script personalizzato
</div>

Incapsula qualsiasi tool CLI o script come server MCP. Ad esempio, un server Python che utilizza `uvx`:

```json theme={null}
{
  "transport": "STDIO",
  "command": "uvx",
  "args": ["my-custom-mcp-server"],
  "env_variables": {
    "CONFIG_PATH": "/path/to/config.json"
  }
}
```

Oppure un server Docker per l'esecuzione isolata:

```json theme={null}
{
  "transport": "STDIO",
  "command": "docker",
  "args": ["run", "-i", "--rm", "my-org/custom-mcp-server:latest"]
}
```

<div id="using-environment-variables-for-secrets">
  ### Utilizzo delle variabili d'ambiente per i segreti
</div>

Passa i valori sensibili tramite variabili d'ambiente anziché codificarli direttamente negli argomenti. La funzionalità [Secrets](/it/product-guides/secrets) di Devin può gestire questi valori — memorizza le tue API key o i token come segreti, quindi richiamali nella configurazione del server MCP.

<div id="troubleshooting-custom-mcp-servers">
  ## Risoluzione dei problemi relativi ai server MCP personalizzati
</div>

<div id="test-listing-tools-fails">
  ### "Test listing tools" non riesce
</div>

| Sintomo                                                 | Causa probabile                                             | Soluzione                                                                                                                                              |
| ------------------------------------------------------- | ----------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------ |
| "Verify server URL and network connectivity"            | L'URL del server non è raggiungibile                        | Verifica che l'URL sia corretto e accessibile da Internet (o dalla rete di Devin se usi una VPN)                                                       |
| "Check authentication credentials and permissions"      | Credenziali di autenticazione non valide o mancanti         | Verifica la tua API key, il token o la configurazione OAuth                                                                                            |
| "Server took too long to respond - check server status" | Il server non ha risposto entro il timeout                  | Assicurati che il server sia in esecuzione e reattivo; controlla se ci sono regole del firewall che bloccano la connessione                            |
| "MCP server validation failed" (generico)               | Comando non trovato, dipendenze mancanti o crash del server | Per i server STDIO, verifica che il comando esista e venga eseguito in locale; assicurati che tutte le variabili di ambiente richieste siano impostate |

<div id="server-connects-but-tools-arent-available">
  ### Il server si connette ma gli strumenti non sono disponibili
</div>

* Verifica che il server implementi correttamente il metodo `tools/list` del protocollo MCP.
* Per i server STDIO, assicurati che il processo scriva messaggi JSON-RPC validi su stdout e legga da stdin — i log o l'output di debug su stdout possono interrompere il protocollo.
* Controlla che le variabili d'ambiente siano impostate correttamente. Valori mancanti (ad esempio una API key vuota) possono consentire l'avvio del server ma impedirgli di registrare gli strumenti.

<div id="oauth-authentication-issues">
  ### Problemi di autenticazione OAuth
</div>

* Quando ti viene richiesto di autenticarti, completa il flusso OAuth nella finestra del browser che si apre. Devin attenderà il callback.
* Se l'autenticazione non riesce, verifica che l'URL di reindirizzamento OAuth sia configurato correttamente presso il provider. Quando usi le credenziali del tuo client OAuth, il provider deve consentire l'URL di callback di Devin `https://api.devin.ai/mcp/oauth/callback` come URI di reindirizzamento: molti provider rifiutano il flusso OAuth se questo URL non è incluso nella whitelist.
* Solo gli utenti con l'autorizzazione **Gestire server MCP** possono autenticare server MCP basati su OAuth. Se visualizzi un errore di autorizzazione, contatta l'amministratore della tua org.

<Note>
  Per MCP basati su OAuth, **usa un account di servizio** invece del tuo account personale. L'accesso è condiviso all'interno della tua organizzazione e tutte le sessioni di tutti i membri utilizzeranno la stessa connessione autenticata.
</Note>

<div id="general-debugging-tips">
  ### Suggerimenti generali per il debug
</div>

* **Controlla prima il server in locale.** Prima di aggiungere un server personalizzato a Devin, verifica che funzioni eseguendo il comando o effettuando una richiesta all'URL dalla tua macchina.
* **Esamina i log di sessione di Devin.** Se un server genera errori durante una sessione, Devin registrerà l'errore. Cerca messaggi relativi all'MCP nell'output della sessione.
* **Semplifica e procedi per iterazioni.** Inizia con la configurazione minima (ad esempio, senza autenticazione, impostazioni predefinite) e aggiungi complessità solo dopo che la connessione di base funziona.
* **Verifica le variabili d'ambiente.** Un problema comune sono le variabili d'ambiente mancanti o con nomi errati. Ricontrolla che ogni variabile richiesta sia impostata nella configurazione.

<Tip>
  Se stai creando il tuo server MCP, la [specifica del Model Context Protocol](https://modelcontextprotocol.io/introduction) contiene documentazione dettagliata sul protocollo, sui metodi di trasporto e sulle definizioni degli strumenti.
</Tip>

***

<div id="marketplace-mcps">
  ## MCP del Marketplace
</div>

Di seguito trovi i dettagli di configurazione per specifici MCP disponibili nel Marketplace.

<div id="vercel-atlassian-notion-sentry-neon-asana-jam-and-many-more">
  ### Vercel, Atlassian, Notion, Sentry, Neon, Asana, Jam e molti altri
</div>

Molti MCP nel nostro marketplace possono essere abilitati senza configurazione con 1 clic!

Ti basta fare clic su "Enable". Ti verrà chiesto di collegare un account di servizio durante la sessione con Devin o quando fai clic su "Test listing tools".

Gli MCP disponibili includono:

* AlloyDB
* Asana
* Atlassian
* BigQuery
* Cloud SQL (MySQL)
* Cloud SQL (PostgreSQL)
* Cloud SQL (SQL Server)
* Cloudflare
* Cortex
* Dataplex
* Figma
* Fireflies
* Firestore
* Jam
* Linear
* Looker
* Metabase
* MySQL
* Neon
* Notion
* PostgreSQL
* Prisma
* Sentry
* Spanner
* SQL Server
* Vercel
* Altri qui sotto!

<Note>
  **Linear**: se hai collegato l'[integrazione Linear](/it/integrations/linear), Devin dispone già di strumenti Linear nativi e non è necessario configurare l'MCP Linear separatamente.
</Note>

<div id="datadog">
  ### Datadog
</div>

Questo è il server MCP remoto ufficiale di Datadog. Quando lo abiliti dal marketplace, ti verrà chiesto di autenticarti con il tuo account Datadog tramite OAuth.

Dovrai anche selezionare il sito/la regione di Datadog (ad es. US1, US3, US5, EU, AP1, AP2, US1-FED) quando abiliti l'MCP.

[Documentazione](https://docs.datadoghq.com/bits_ai/mcp_server/)

<div id="slack">
  ### Slack
</div>

Questo è il server MCP remoto ufficiale di Slack. Quando lo attivi dal marketplace, ti verrà chiesto di autenticarti con il tuo account Slack tramite OAuth.

Tieni presente che utilizza OAuth a livello di utente: se è connesso con accesso esteso all'intera organizzazione, tutti i membri dell'org condividono la stessa identità utente, quindi consigliamo di usare l'accesso personale.

[Documentazione](https://docs.slack.dev/ai/slack-mcp-server)

<div id="supabase">
  ### Supabase
</div>

Dovrai fornire un token di accesso personale, che puoi trovare e creare su [https://supabase.com/dashboard/account/tokens](https://supabase.com/dashboard/account/tokens)

[Documentazione](https://mcpservers.org/servers/supabase-community/supabase-mcp)

<div id="figma">
  ### Figma
</div>

Questo è il server MCP remoto ufficiale di Figma. Quando abiliti l'MCP dal marketplace, ti verrà chiesto di autenticarti con il tuo account Figma tramite OAuth.

Quando usi questo MCP, assicurati di inviare a Devin il link al tuo file Figma.

[Documentazione](https://developers.figma.com/docs/figma-mcp-server/remote-server-installation/)

<div id="stripe">
  ### Stripe
</div>

Dovrai fornire un header di autorizzazione nel formato `Bearer <TOKEN>`, dove `<TOKEN>` è la tua chiave API di Stripe. Ulteriori informazioni su: [https://docs.stripe.com/mcp#bearer-token](https://docs.stripe.com/mcp#bearer-token)

[Documentazione](https://docs.stripe.com/mcp)

<div id="zapier">
  ### Zapier
</div>

È necessario fornire un header di autorizzazione nel formato `Bearer <TOKEN>`.

Devi estrarre il tuo token Bearer dall'URL del server indicato su [https://mcp.zapier.com/mcp/servers](https://mcp.zapier.com/mcp/servers) > Connect

L'URL del tuo server avrà questo aspetto: [https://mcp.zapier.com/api/mcp/s/\*\*\*\*\*/mcp](https://mcp.zapier.com/api/mcp/s/*****/mcp)

Estrai la parte contrassegnata dagli asterischi (\*\*\*\*\*) e usala nell'header di autorizzazione che fornisci: `Bearer *****`

<Frame>
  <img src="https://mintcdn.com/cognitionai-enterprise/oqBYXWmkhuOhl3HZ/images/Zapier_MCP.png?fit=max&auto=format&n=oqBYXWmkhuOhl3HZ&q=85&s=4369b99546ea6d4168d1c6a3e186195b" alt="Devin" width="1201" height="649" data-path="images/Zapier_MCP.png" />
</Frame>

[Documentazione](https://zapier.com/mcp)

<div id="airtable">
  ### Airtable
</div>

Dovrai fornire una chiave API di Airtable. Puoi trovare la tua chiave API all'indirizzo: [https://airtable.com/create/tokens](https://airtable.com/create/tokens)

[Documentazione](https://www.npmjs.com/package/airtable-mcp-server)

<div id="docker-hub">
  ### Docker Hub
</div>

Credenziali richieste:

* Nome utente Docker Hub: può essere ottenuto da My Hub
* Personal Access Token: vai su Impostazioni account > Personal access tokens e crea un token
  <Frame>
    <img src="https://mintcdn.com/cognitionai-enterprise/JQ4gdhcxD51zUhW4/images/dockermcp.png?fit=max&auto=format&n=JQ4gdhcxD51zUhW4&q=85&s=93ca26c0361a410120b0ed9c313a930a" alt="Devin" width="1836" height="942" data-path="images/dockermcp.png" />
  </Frame>

[Documentazione](https://hub.docker.com/r/mcp/dockerhub)

<div id="sonarqube">
  ### SonarQube
</div>

Per ottenere le credenziali necessarie:

* Token SonarQube: vai su My Account > Security e genera il tuo token API
* Org SonarQube: corrisponde al tuo username, come mostrato nell'immagine qui sotto
  <Frame>
    <img src="https://mintcdn.com/cognitionai-enterprise/A1NrXl_1--Cgx5nh/images/sonarqubemcp.png?fit=max&auto=format&n=A1NrXl_1--Cgx5nh&q=85&s=e5054e50938f9c50e35ecb01b5336ffd" alt="Devin" width="1836" height="652" data-path="images/sonarqubemcp.png" />
  </Frame>
* URL SonarQube:
  * Per l'istanza self-hosted: il formato è [http://localhost:9000](http://localhost:9000/) OPPURE [https://sonarqube.mycompany.com](https://sonarqube.mycompany.com/)
  * Per SonarCloud: usa [https://sonarcloud.io](https://sonarcloud.io/)

[Documentazione](https://github.com/SonarSource/sonarqube-mcp-server)

<div id="netlify">
  ### Netlify
</div>

Dovrai fornire un Personal Access Token (PAT), che puoi visualizzare e creare all'indirizzo [https://app.netlify.com/user/applications#personal-access-tokens](https://app.netlify.com/user/applications#personal-access-tokens). Assicurati di copiare il PAT non appena viene creato: non potrai più visualizzarlo successivamente!

<Frame>
  <img src="https://mintcdn.com/cognitionai-enterprise/oD-FO9nMcsNLafKf/images/netlify.png?fit=max&auto=format&n=oD-FO9nMcsNLafKf&q=85&s=a84824c48aae17d32da4f0d410cf2bfd" alt="Devin" width="1334" height="782" data-path="images/netlify.png" />
</Frame>

[Documentazione](https://docs.netlify.com/welcome/build-with-ai/netlify-mcp-server/)

<div id="pulumi">
  ### Pulumi
</div>

È possibile ottenere un token di accesso a Pulumi dalla sezione **Access tokens** nella barra laterale della dashboard di Pulumi.

<Frame>
  <img src="https://mintcdn.com/cognitionai-enterprise/p6mfZwd14EeP9cx_/images/pulumi.png?fit=max&auto=format&n=p6mfZwd14EeP9cx_&q=85&s=7365b1d99d3036bd1b8967eff22a06c0" alt="Devin" width="1827" height="902" data-path="images/pulumi.png" />
</Frame>

[Documentazione](https://www.pulumi.com/docs/iac/using-pulumi/mcp-server/)

<div id="parallel">
  ### Parallel
</div>

È necessario fornire una chiave API, che puoi generare all'indirizzo [https://platform.parallel.ai/](https://platform.parallel.ai/)

[Documentazione](https://docs.parallel.ai/features/remote-mcp)

<div id="heroku">
  ### Heroku
</div>

Dovrai fornire una chiave API, che puoi trovare all’indirizzo [https://dashboard.heroku.com/account](https://dashboard.heroku.com/account)

<Frame>
  <img src="https://mintcdn.com/cognitionai-enterprise/oqBYXWmkhuOhl3HZ/images/Heroku.png?fit=max&auto=format&n=oqBYXWmkhuOhl3HZ&q=85&s=f8d4fc8875f4698fb4d8f4aa66dd7a45" alt="Devin" width="1087" height="672" data-path="images/Heroku.png" />
</Frame>

[Documentazione](https://www.heroku.com/blog/introducing-official-heroku-mcp-server/)

<div id="circleci">
  ### CircleCI
</div>

Devi fornire 2 variabili d'ambiente:

* `CIRCLECI_TOKEN` - Token API di CircleCI, che puoi creare su [https://app.circleci.com/settings/user/tokens](https://app.circleci.com/settings/user/tokens). Assicurati di copiare il token API subito dopo la creazione: non potrai più visualizzarlo in seguito!

<Frame>
  <img src="https://mintcdn.com/cognitionai-enterprise/oqBYXWmkhuOhl3HZ/images/CircleCI.png?fit=max&auto=format&n=oqBYXWmkhuOhl3HZ&q=85&s=519e872376d5a77abc06b28c681090f9" alt="Devin" width="1301" height="893" data-path="images/CircleCI.png" />
</Frame>

* `CIRCLECI_BASE_URL` \[Opzionale] - Variabile opzionale, necessaria solo per i clienti on‑prem. Il valore predefinito è `"https://circleci.com"`

[Documentazione](https://hub.docker.com/r/mcp/circleci)

<div id="cortex">
  ### Cortex
</div>

Per abilitare questo MCP, devi fornire un personal access token di Cortex:

1. Accedi alla tua istanza di Cortex.
2. Dal menu a sinistra, vai su *Settings → My access tokens*.
3. Fai clic su *Create new token*.
4. Inserisci un nome e una descrizione per il token.
5. Fai clic su *Create token* e copia il token.

Quando utilizzi questo MCP, assicurati che Devin sia configurato con l'URL corretto dell'API di Cortex (valore predefinito: `https://api.getcortexapp.com`).

[Documentazione](https://docs.cortex.io/get-started/mcp)

<div id="square">
  ### Square
</div>

Dovrai fornire un'intestazione `Authorization` nel formato `Bearer &lt;TOKEN&gt;`, dove `&lt;TOKEN&gt;` è il tuo token di accesso Square. Maggiori informazioni: [https://developer.squareup.com/docs/build-basics/access-tokens](https://developer.squareup.com/docs/build-basics/access-tokens)

[Documentazione](https://developer.squareup.com/docs/mcp)

<div id="hubspot">
  ### Hubspot
</div>

Dovrai fornire un token di accesso come variabile di ambiente. Per ottenere il tuo token di accesso:

1. Crea una private app in HubSpot:
2. Vai su Settings > Integrations > Private Apps
3. Fai clic su "Create private app"
4. Assegna un nome alla tua app e imposta gli scope richiesti
5. Fai clic su "Create app"
6. Copia il token di accesso generato dalla scheda "Auth"

[Documentazione](https://www.npmjs.com/package/@hubspot/mcp-server)

<div id="redis">
  ### Redis
</div>

Credenziali richieste:

* Host Redis
* Porta Redis
* Nome utente Redis
* Password Redis

[Documentazione](https://redis.io/docs/latest/integrate/redis-mcp/client-conf/)

<div id="google-maps">
  ### Google Maps
</div>

Dovrai (1) fornire una chiave API e (2) abilitare le singole API a cui vuoi che Devin abbia accesso.

Per ottenere la chiave API, vai su [https://console.cloud.google.com/apis/credentials](https://console.cloud.google.com/apis/credentials) e apri il menu laterale > APIs and services > Credentials.

Per abilitare una singola API, cerca l'API e fai clic su Abilita.

<Frame>
  <img src="https://mintcdn.com/cognitionai-enterprise/oqBYXWmkhuOhl3HZ/images/MapsMCP1.png?fit=max&auto=format&n=oqBYXWmkhuOhl3HZ&q=85&s=5054d6697f072d088d531f4b42aa2975" alt="Devin" width="1602" height="957" data-path="images/MapsMCP1.png" />
</Frame>

<Frame>
  <img src="https://mintcdn.com/cognitionai-enterprise/oqBYXWmkhuOhl3HZ/images/MapsMCP2.png?fit=max&auto=format&n=oqBYXWmkhuOhl3HZ&q=85&s=cac430aaaec5353619807a9e880d73a3" alt="Devin" width="1840" height="885" data-path="images/MapsMCP2.png" />
</Frame>

<Frame>
  <img src="https://mintcdn.com/cognitionai-enterprise/oqBYXWmkhuOhl3HZ/images/MapsMCP4.png?fit=max&auto=format&n=oqBYXWmkhuOhl3HZ&q=85&s=ff52adfbdecdd26b72d592420c6d8f56" alt="Devin" width="1088" height="831" data-path="images/MapsMCP4.png" />
</Frame>

[Documentazione](https://www.npmjs.com/package/@modelcontextprotocol/server-google-maps)

<div id="playwright">
  ### Playwright
</div>

Non servono variabili d'ambiente per questa integrazione: ti basta abilitarla.

[Documentazione](https://hub.docker.com/r/mcp/playwright)

<div id="firecrawl">
  ### Firecrawl
</div>

Dovrai fornire una chiave API (`FIRECRAWL_API_KEY`), che puoi creare e visualizzare su [https://www.firecrawl.dev/app/api-keys](https://www.firecrawl.dev/app/api-keys).

[Documentazione](https://hub.docker.com/r/mcp/firecrawl#use-this-mcp-server)

<div id="elasticsearch">
  ### ElasticSearch
</div>

È necessario fornire 2 variabili d’ambiente:

* `ES_URL` - URL o endpoint di ElasticSearch, disponibile nella pagina /overview in Elasticsearch.
* `ES_API_KEY` - Chiave API di ElasticSearch, che può essere creata nella pagina `/indices/index_details/<name>/data` in Elasticsearch.

<Frame>
  <img src="https://mintcdn.com/cognitionai-enterprise/JQ4gdhcxD51zUhW4/images/elasticsearch.png?fit=max&auto=format&n=JQ4gdhcxD51zUhW4&q=85&s=eb064fe58f44f992873b29a086e731b1" alt="Devin" width="1383" height="637" data-path="images/elasticsearch.png" />
</Frame>

`ES_SSL_SKIP_VERIFY` è una variabile d’ambiente opzionale. Quando è impostata su `true`, salta la verifica del certificato SSL/TLS durante la connessione a Elasticsearch.

[Documentazione](https://hub.docker.com/r/mcp/elasticsearch)

<div id="postgres">
  ### Postgres
</div>

L'unica credenziale necessaria è la stringa di connessione di Postgres.

[Documentazione](https://www.npmjs.com/package/@modelcontextprotocol/server-postgres?activeTab=readme)

<div id="plaid">
  ### Plaid
</div>

L'unica credenziale richiesta è un token di accesso OAuth Bearer che può essere ottenuto eseguendo il seguente codice:

```jsx theme={null}
curl -X POST https://production.plaid.com/oauth/token \
-H 'Content-Type: application/json' \
-d '{
"client_id": "YOUR_PLAID_CLIENT_ID",
"client_secret": "YOUR_PRODUCTION_SECRET",
"grant_type": "client_credentials",
"scope": "mcp:dashboard"
}'
```

Per ottenere il client ID e il client secret di produzione, vai su [https://dashboard.plaid.com/developers/keys](https://dashboard.plaid.com/developers/keys)

[Documentazione](https://plaid.com/docs/resources/mcp/)

<div id="replicate">
  ### Replicate
</div>

L'unica credenziale richiesta è il token API, disponibile all'indirizzo [https://replicate.com/account/api-tokens](https://replicate.com/account/api-tokens)

[Documentazione](https://replicate.com/docs/reference/mcp)

<div id="grafana">
  ### Grafana
</div>

Devi fornire 2 variabili d'ambiente:

* URL di Grafana
* Token dell'account di servizio di Grafana: per ottenere il token, nella barra laterale vai su Administration > Users and access > Service accounts > Add service account (se non ne hai già uno) > Add service account token

<Frame>
  <img src="https://mintcdn.com/cognitionai-enterprise/JQ4gdhcxD51zUhW4/images/grafana.png?fit=max&auto=format&n=JQ4gdhcxD51zUhW4&q=85&s=07d1f8c4160b53743368c0c7cc6df2bf" alt="Devin" width="1862" height="987" data-path="images/grafana.png" />
</Frame>

<div id="pinecone">
  ### Pinecone
</div>

NOTA: l'MCP Pinecone supporta solo gli indici con embedding integrato. Gli indici per vettori creati con modelli di embedding esterni non sono ancora supportati al 16/07/25.

L'unica credenziale richiesta è la chiave API di Pinecone, che può essere ottenuta dalla pagina delle chiavi API nella dashboard di Pinecone, come mostrato di seguito:

<Frame>
  <img src="https://mintcdn.com/cognitionai-enterprise/oD-FO9nMcsNLafKf/images/pinecone.png?fit=max&auto=format&n=oD-FO9nMcsNLafKf&q=85&s=b5141e1593f2cb0479ec040802280762" alt="Devin" width="1840" height="947" data-path="images/pinecone.png" />
</Frame>

<div id="snyk">
  ### Snyk
</div>

1. Per prima cosa, configura il server MCP. La documentazione è disponibile [qui](https://docs.snyk.io/integrations/developer-guardrails-for-agentic-workflows/quickstart-guides-for-mcp/devin-guide). Nota: assicurati di aggiungere una variabile d'ambiente alla fine (non elencata nella guida).
   <Frame>
     <img src="https://mintcdn.com/cognitionai-enterprise/fh-R0_T65dbpUS2r/images/snyk.png?fit=max&auto=format&n=fh-R0_T65dbpUS2r&q=85&s=1c5a165b7e2ccdac68beaacf0a413c3d" alt="Devin" width="939" height="797" data-path="images/snyk.png" />
   </Frame>
2. Installa la Snyk CLI sulla macchina di Devin. La documentazione è disponibile [qui](https://docs.snyk.io/developer-tools/snyk-cli/install-or-update-the-snyk-cli).

```jsx theme={null}
brew tap snyk/tap
brew install snyk-cli

snyk --disable-trust
```

Nota: alcuni test Snyk richiedono attendibilità per funzionare correttamente: installali sulla macchina dopo aver installato Homebrew. La documentazione è disponibile [qui](https://docs.snyk.io/integrations/developer-guardrails-for-agentic-workflows/troubleshooting-for-the-snyk-mcp-server#folder-trust).

**Suggerimento**:\
Se la configurazione è corretta, l'elenco completo delle scansioni Snyk dovrebbe essere eseguito al primo tentativo. Tuttavia, a seconda del framework, alcune scansioni richiedono il passaggio di un flag “unmanaged: true” (ad es. C++). Al momento puoi impostarlo nella knowledge base o durante la tua sessione con Devin: ecco un esempio:

<Frame>
  <img src="https://mintcdn.com/cognitionai-enterprise/fh-R0_T65dbpUS2r/images/synk-example.png?fit=max&auto=format&n=fh-R0_T65dbpUS2r&q=85&s=b1e3752ddfc4c1d5f7cbf9d56c11d630" alt="Devin" width="1020" height="158" data-path="images/synk-example.png" />
</Frame>

**Suggerimento**: Abbiamo scritto un [playbook di esempio](https://app.devin.ai/settings/playbooks/163db5ecab7e47e6a82c71bf8d338678) per aiutarti a iniziare.

[Documentazione](https://docs.snyk.io/integrations/developer-guardrails-for-agentic-workflows/quickstart-guides-for-mcp/devin-guide)