> ## 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 servidores MCP con Cascade para acceder a herramientas personalizadas como GitHub, bases de datos y API. Configura transportes stdio, HTTP y SSE con controles de Admin para Teams.

**MCP (Model Context Protocol)** es un protocolo que permite a los LLM acceder a herramientas y servicios personalizados.
Un cliente MCP (Cascade, en este caso) puede enviar solicitudes a servidores MCP para acceder a las herramientas que proporcionan.
Cascade ahora se integra de forma nativa con MCP, lo que te permite usar tus propios servidores MCP con Cascade.
Consulta la [documentación oficial de MCP](https://modelcontextprotocol.io/) para obtener más información.

<Note>Los usuarios de Enterprise deben activar esto manualmente desde Settings</Note>

<div id="adding-a-new-mcp">
  ## Agregar un nuevo MCP
</div>

Se pueden agregar nuevos MCP desde MCP Marketplace, al que accedes
haciendo clic en el icono `MCPs` del menú superior derecho del panel de Cascade, o desde
la sección `Devin Settings` > `Cascade` > `MCP Servers`.

Si no encuentras el MCP que buscas, puedes agregarlo manualmente editando directamente el archivo `mcp_config.json`.

Los MCP oficiales aparecerán con una marca de verificación azul, lo que indica que fueron creados por la empresa responsable del servicio principal.

Cuando hagas clic en un MCP, simplemente haz clic en `Install` para poner el servidor y sus herramientas a disposición de Cascade.

<div id="one-click-install-via-deeplink">
  ### Instalación con un clic mediante deeplinks
</div>

Devin Desktop admite la instalación de MCP con un clic mediante deeplinks. Puedes usar estos enlaces para abrir directamente en Devin Desktop la página del registro de MCP, lo que resulta útil para compartir recomendaciones de servidores MCP o incluir botones de instalación en la documentación.

El formato del deeplink es:

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

* **Con `serverName`**: Abre la página del registro de MCP del servidor especificado, donde el usuario puede consultarlo e instalarlo.
* **Sin `serverName`**: Abre la página de MCP Marketplace.

Por ejemplo, `windsurf://windsurf-mcp-registry?serverName=github-mcp-server` abrirá la
página del registro del servidor MCP de GitHub en Devin Desktop.

<Note>Los enlaces directos de instalación con un clic requieren que el equipo del usuario tenga habilitado el acceso a MCP. Si un Admin deshabilita el acceso a MCP, el enlace directo no abrirá la página del registro.</Note>

Devin Desktop admite tres [tipos de transporte](https://modelcontextprotocol.io/docs/concepts/transports) para
servidores MCP: `stdio`,  `Streamable HTTP` y `SSE`.

Devin Desktop también admite OAuth para cada tipo de transporte.

Para los servidores `http`, la URL debe corresponder a la del endpoint y tener un formato similar 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">
  ## Configurar herramientas MCP
</div>

Cada MCP tiene acceso a una cantidad determinada de herramientas. Cascade tiene un límite de 100 herramientas en total a las que puede acceder en un momento dado.

En la página de Settings de cada MCP, puedes activar o desactivar las herramientas que quieras habilitar. Para
abrir la configuración de un MCP, haz clic en el icono `MCPs` del menú superior derecho del
panel de Cascade y haz clic en el MCP que desees.

<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>

El archivo `~/.codeium/windsurf/mcp_config.json` es un archivo JSON que contiene una lista de servidores a los que Cascade puede conectarse.

A continuación se muestra una configuración de ejemplo que configura un único servidor para GitHub:

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

Asegúrate de proporcionar los argumentos requeridos y las variables de entorno para los servidores que quieras usar.

Consulta el [repositorio oficial de referencia de servidores MCP](https://github.com/modelcontextprotocol/servers) o [OpenTools](https://opentools.com/) para ver algunos servidores de ejemplo.

<div id="popular-mcp-server-examples">
  ### Ejemplos populares de servidores MCP
</div>

A continuación se muestran ejemplos de configuración de algunos servidores MCP de uso frecuente. Se pueden agregar a tu archivo `mcp_config.json`.

<AccordionGroup>
  <Accordion title="GitHub" description="Gestión de repositorios, operaciones con archivos e integración con la API de GitHub.">
    El servidor MCP de GitHub proporciona herramientas para la gestión de repositorios, operaciones con archivos, seguimiento de issues y gestión de pull requests.

    **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>"
          }
        }
      }
    }
    ```

    Para crear un Personal Access Token, visita [GitHub Settings > Developer settings > Personal access tokens](https://github.com/settings/tokens).
  </Accordion>

  <Accordion title="Slack" description="Gestión de canales y funciones de mensajería para espacios de trabajo de Slack.">
    El servidor MCP de Slack permite gestionar canales, enviar mensajes e interactuar con el espacio de trabajo.

    ```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>"
          }
        }
      }
    }
    ```

    Para configurar un token de bot de Slack:

    1. Crea una Slack App en [api.slack.com/apps](https://api.slack.com/apps)
    2. Agrega los permisos de OAuth requeridos (p. ej., `channels:read`, `chat:write`, `users:read`)
    3. Instala la app en tu espacio de trabajo y copia el Bot User OAuth Token
  </Accordion>

  <Accordion title="PostgreSQL" description="Acceso de solo lectura a la base de datos con capacidades de inspección de esquemas.">
    El servidor MCP de PostgreSQL proporciona acceso de solo lectura a bases de datos PostgreSQL, incluida la inspección de esquemas y la ejecución de consultas.

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

    <Warning>El servidor de PostgreSQL proporciona acceso de solo lectura de forma predeterminada por seguridad. Asegúrate de que tu cadena de conexión use credenciales adecuadas con permisos limitados.</Warning>
  </Accordion>

  <Accordion title="Filesystem" description="Operaciones seguras con archivos y controles de acceso configurables.">
    El servidor MCP de Filesystem proporciona acceso seguro a archivos y directorios locales con controles de acceso configurables.

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

    Puedes especificar varios directorios permitidos agregando argumentos de ruta adicionales. Solo se podrá acceder a los archivos dentro de estos directorios.
  </Accordion>

  <Accordion title="Brave Search" description="Búsqueda web y local con la API de búsqueda de Brave.">
    El servidor MCP de Brave Search habilita funciones de búsqueda web mediante la API de búsqueda de Brave.

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

    Para obtener una clave de API de Brave, regístrate en [brave.com/search/api](https://brave.com/search/api/).
  </Accordion>

  <Accordion title="Memory" description="Sistema de memoria persistente basado en grafos de conocimiento.">
    El servidor MCP de Memory proporciona un sistema de memoria persistente que usa un grafo de conocimiento, lo que permite a Cascade recordar información entre sesiones.

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

    El servidor de memoria almacena datos localmente y persiste entre sesiones, por lo que resulta útil para mantener el contexto sobre proyectos, preferencias e información aprendida.
  </Accordion>
</AccordionGroup>

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

Es importante tener en cuenta que, en el caso de los MCP HTTP remotos, la configuración es ligeramente
distinta y requiere un campo `serverUrl` o `url`.

A continuación, se muestra un ejemplo de configuración para un servidor HTTP:

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

<div id="config-interpolation">
  ### Interpolación de la configuración
</div>

El archivo `~/.codeium/windsurf/mcp_config.json` admite la interpolación de variables
en los siguientes campos: `command`, `args`, `env`, `serverUrl`, `url` y
`headers`. Esto te permite evitar incluir secretos directamente en el archivo de configuración.

Se admiten dos patrones de interpolación:

* **`${env:VAR_NAME}`** — se sustituye por el valor de la variable de entorno `VAR_NAME`. Si la variable no está definida, se resuelve como una cadena vacía.
* **`${file:/path/to/file}`** — se sustituye por el contenido del archivo en la ruta indicada, sin espacios en blanco al principio ni al final. Se admiten rutas con tilde (p. ej., `~/secrets/key.txt`). Si no se puede leer el archivo, el patrón se deja sin cambios.

Aquí tienes un ejemplo de cómo usar una variable de entorno en `headers`:

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

A continuación se muestra un ejemplo de cómo leer una API key de un archivo:

```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">
  ## Controles de Admin (Equipos y empresas)
</div>

Los Admin del equipo pueden activar o desactivar el acceso a MCP para su equipo, así como definir una lista de permitidos de servidores MCP aprobados que el equipo puede usar:

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

Los equipos Enterprise pueden configurar registros de MCP personalizados para reemplazar el MCP Marketplace predeterminado de Devin Desktop. Los equipos pueden vincular las URL de sus propios registros para controlar qué MCP están disponibles para sus usuarios.

<Note>Los registros son la opción preferida para gestionar el acceso a los MCP, aunque las listas de permitidos también funcionan.</Note>

<div id="configuring-custom-registries">
  #### Configurar registros personalizados
</div>

1. Ve a la configuración de tu equipo
2. Busca la opción **MCP Registry URLs**
3. Agrega una o más URL de registro

Cuando se configuran múltiples URL de registro, Devin Desktop usa la **unión** de todos los registros: los usuarios verán los MCP de todas las fuentes configuradas en conjunto. El MCP Marketplace del equipo consultará estos registros internos en lugar del registro predeterminado de Devin Desktop.

<Note>Los registros personalizados deben seguir el [esquema oficial de registro de MCP](https://modelcontextprotocol.io/). Esto garantiza la compatibilidad y definiciones de servidor estandarizadas.</Note>

<div id="mcp-whitelist">
  ### Lista de permitidos de MCP
</div>

<Card title="MCP Team Settings" horizontal={true} icon="hammer" href="https://windsurf.com/team/settings">
  Configuración de MCP para tu equipo.
</Card>

<Warning>El enlace anterior solo funcionará si tienes privilegios de Admin para tu equipo.</Warning>

De forma predeterminada, los usuarios de un equipo podrán configurar sus propios servidores MCP. Sin embargo, en cuanto incluyas хотя sea un solo servidor MCP en la lista de permitidos, **todos los servidores que no estén en la lista de permitidos quedarán bloqueados** para tu equipo.

<Note>El ID del servidor en la lista de permitidos debe coincidir exactamente, respetando mayúsculas y minúsculas, con el nombre de la clave usado en el `mcp_config.json` del usuario.</Note>

<div id="how-server-matching-works">
  ### Cómo funciona la coincidencia de servidores
</div>

Cuando agregas un servidor MCP a la **lista de permitidos**, el sistema usa **coincidencia mediante patrones regex** con las siguientes reglas:

* **Coincidencia de cadena completa**: Todos los patrones se anclan automáticamente (se envuelven en `^(?:pattern)$`) para evitar coincidencias parciales
* **Campo de comando**: Debe coincidir exactamente o según tu patrón regex
* **Array de argumentos**: Cada argumento se compara individualmente con su patrón correspondiente
* **Longitud del array**: La cantidad de argumentos debe coincidir exactamente entre la lista de permitidos y la configuración del usuario
* **Caracteres especiales**: Caracteres como `$`, `.`, `[`, `]`, `(`, `)` tienen un significado especial en regex y deben escaparse con `\` si quieres una coincidencia literal

<div id="configuration-options">
  ### Opciones de configuración
</div>

<AccordionGroup>
  <Accordion title="Opción 1: valor predeterminado del Plugin Store (recomendado)" description="Deja vacío el campo Server Config (JSON) para permitir la configuración predeterminada del Devin Desktop MCP Plugin Store.">
    **Configuración de la lista de permitidos del Admin:**

    * **ID del servidor**: `github-mcp-server`
    * **Server Config (JSON)**: *(dejar vacío)*

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

    **Configuración de usuario correspondiente (`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"
          }
        }
      }
    }
    ```

    Esto permite a los usuarios instalar el servidor MCP de GitHub con cualquier configuración válida, siempre que el ID del servidor coincida con la entrada del Plugin Store.
  </Accordion>

  <Accordion title="Opción 2: configuración de coincidencia exacta" description="Proporciona la configuración exacta que los usuarios deben usar. Los usuarios deben usar esta configuración exactamente.">
    **Configuración de la lista de permitidos del Admin:**

    * **ID del servidor**: `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": ""
      }
    }
    ```

    **Configuración de usuario correspondiente (`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"
          }
        }
      }
    }
    ```

    Los usuarios deben usar esta configuración exacta; cualquier variación en `command` o `args` se bloqueará. La sección `env` puede tener valores diferentes.
  </Accordion>

  <Accordion title="Opción 3: patrones regex flexibles" description="Usa patrones regex para permitir variaciones en las configuraciones de los usuarios, manteniendo los controles de seguridad.">
    **Configuración de la lista de permitidos del Admin:**

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

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

    **Configuración de usuario correspondiente (`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"
          }
        }
      }
    }
    ```

    Este ejemplo ofrece flexibilidad a los usuarios sin dejar de mantener la seguridad:

    * La regex `/.*\\.py` coincide con cualquier ruta de archivo Python, como `/home/user/my_server.py`
    * La regex `[0-9]+` coincide con cualquier puerto numérico, como `8080` o `3000`
    * Los usuarios pueden personalizar las rutas de archivo y los puertos, mientras los Admin se aseguran de que solo se ejecuten scripts de Python
  </Accordion>
</AccordionGroup>

<div id="common-regex-patterns">
  ### Patrones comunes de regex
</div>

| Patrón          | Coincide con              | Ejemplo                |
| --------------- | ------------------------- | ---------------------- |
| `.*`            | Cualquier cadena          | `/home/user/script.py` |
| `[0-9]+`        | Cualquier número          | `8080`, `3000`         |
| `[a-zA-Z0-9_]+` | Alfanumérico + guion bajo | `api_key_123`          |
| `\\$HOME`       | `$HOME` literal           | `$HOME` (sin expandir) |
| `\\.py`         | `.py` literal             | `script.py`            |
| `\\[cli\\]`     | `[cli]` literal           | `mcp[cli]`             |

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

<div id="admin-configuration-guidelines">
  ### Pautas de configuración de Admin
</div>

* **Variables de entorno**: La sección `env` no se evalúa mediante `regex` y los usuarios pueden configurarla libremente
* **Herramientas deshabilitadas**: El arreglo `disabledTools` se gestiona por separado y no forma parte de la coincidencia con la lista de permitidos
* **Distinción entre mayúsculas y minúsculas**: Todas las coincidencias distinguen entre mayúsculas y minúsculas
* **Manejo de errores**: Los patrones de `regex` no válidos se registrarán y darán lugar a una denegación de acceso
* **Pruebas**: Prueba tus patrones de `regex` con cuidado; los patrones demasiado restrictivos pueden bloquear casos de uso legítimos

<div id="troubleshooting">
  ### Solución de problemas
</div>

Si los usuarios informan que sus servidores MCP no funcionan después de configurar la lista de permitidos:

1. **Comprueba la coincidencia exacta**: Asegúrate de que el patrón de la lista de permitidos coincida exactamente con la configuración del usuario
2. **Verifica el escape de regex**: Puede que sea necesario escapar los caracteres especiales (p. ej., `\.` para puntos literales)
3. **Revisa los logs**: Los patrones de regex no válidos se registran con advertencias
4. **Prueba los patrones**: Usa un comprobador de regex para verificar que tus patrones funcionen como se espera

Recuerda: Una vez que incluyas cualquier servidor en la lista de permitidos, **todos los demás servidores quedarán bloqueados automáticamente** para los miembros de tu equipo.

<div id="general-information">
  ### Información general
</div>

* Dado que las llamadas a herramientas de MCP pueden invocar código escrito por implementadores de servidores de terceros, no asumimos responsabilidad por fallos
  en las llamadas a herramientas de MCP. Para reiterarlo:
* Actualmente admitimos las [herramientas](https://modelcontextprotocol.io/docs/concepts/tools), los [recursos](https://modelcontextprotocol.io/docs/concepts/resources) y los [prompts](https://modelcontextprotocol.io/docs/concepts/prompts) de un servidor MCP.