> ## Documentation Index
> Fetch the complete documentation index at: https://docs.windsurf.com/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 APIs. Configura los transportes stdio, HTTP y SSE con controles de administración para Teams.

**MCP (Model Context Protocol)** es un protocolo que permite a los modelos de lenguaje (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 estos proporcionan.
Cascade ahora se integra de forma nativa con MCP, lo que te permite usar tu propia selección de servidores MCP para que Cascade los utilice.
Consulta la [documentación oficial de MCP](https://modelcontextprotocol.io/) para obtener más información.

<Note>Los usuarios de Enterprise deben activar esta opción manualmente en la configuración</Note>

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

Se pueden añadir nuevos MCP desde el MCP Marketplace, al que se accede
haciendo clic en el icono `MCPs` en el menú superior derecho del panel de Cascade, o desde
la sección `Windsurf Settings` > `Cascade` > `MCP Servers`.

Si no encuentras el MCP que deseas, puedes añadirlo manualmente editando directamente el archivo `mcp_config.json`.

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

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

Windsurf es compatible con tres [tipos de transporte](https://modelcontextprotocol.io/docs/concepts/transports) para servidores MCP:
`stdio`, `Streamable HTTP` y `SSE`.

Windsurf también es compatible con OAuth para cada tipo de transporte.

Para servidores `http`, la URL debe corresponder al endpoint y tener un formato similar a `https://<your-server-url>/mcp`.

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

<div id="configuring-mcp-tools">
  ## Configuración de herramientas MCP
</div>

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

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

<Frame>
  <img src="https://mintcdn.com/codeium/Rm_zdSOuabDsfa9L/assets/windsurf/cascade/mcp/mcp-manage-plugin-tools.png?fit=max&auto=format&n=Rm_zdSOuabDsfa9L&q=85&s=167fd87ffb6cf42228f6e62ff8cb6596" width="893" height="639" data-path="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 un ejemplo de configuración que define un único servidor para GitHub:

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

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

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 muy utilizados. Puedes agregarlos a tu archivo `mcp_config.json`.

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

    **Usando npx:**

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

    **Usando 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, ve a [GitHub Settings > Developer settings > Personal access tokens](https://github.com/settings/tokens).
  </Accordion>

  <Accordion title="Slack" description="Capacidades de gestión de canales y mensajería para workspaces de Slack.">
    El servidor MCP de Slack permite la gestión de canales, mensajería e interacciones con el 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>"
          }
        }
      }
    }
    ```

    Para configurar un Slack bot token:

    1. Crea una Slack App en [api.slack.com/apps](https://api.slack.com/apps)
    2. Añade los OAuth scopes necesarios (por ejemplo, `channels:read`, `chat:write`, `users:read`)
    3. Instala la app en tu workspace y copia el Bot User OAuth Token
  </Accordion>

  <Accordion title="PostgreSQL" description="Acceso de solo lectura a bases de datos con capacidades de inspección de esquemas.">
    El servidor MCP de PostgreSQL proporciona acceso de solo lectura a bases de datos PostgreSQL, incluyendo inspección de esquemas y 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 apropiadas con permisos limitados.</Warning>
  </Accordion>

  <Accordion title="Filesystem" description="Operaciones de archivos seguras con 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 múltiples directorios permitidos añadiendo argumentos de ruta adicionales. Solo serán accesibles los archivos dentro de esos directorios.
  </Accordion>

  <Accordion title="Brave Search" description="Búsqueda web y local usando la API de búsqueda de Brave.">
    El servidor MCP de Brave Search habilita capacidades de búsqueda web usando 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 un grafo de conocimiento.">
    El servidor MCP de Memory proporciona un sistema de memoria persistente usando un grafo de conocimiento, lo que permite que Cascade recuerde información entre sesiones.

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

    El servidor de memoria almacena los datos localmente y los mantiene entre sesiones, lo que lo hace útil para conservar 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, para MCP HTTP remotos, la configuración es ligeramente diferente y requiere un campo `serverUrl` o `url`.

Aquí tienes un ejemplo de configuración para un servidor HTTP:

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

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

El archivo `~/.codeium/windsurf/mcp_config.json` gestiona la interpolación de
variables de entorno en estos campos: `command`, `args`, `env`, `serverUrl`, `url` y
`headers`.

Aquí tienes un ejemplo de configuración que utiliza una variable de entorno `AUTH_TOKEN`
en `headers`.

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

<div id="admin-controls-teams-enterprises">
  ## Controles de administración (Teams & Enterprise)
</div>

Los administradores de equipo pueden activar o desactivar el acceso a MCP para su equipo, así como definir una lista de servidores MCP aprobados para que su equipo los use:

<Card title="Ajustes de MCP del equipo" horizontal={true} icon="hammer" href="https://windsurf.com/team/settings">
  Ajustes configurables de MCP para tu equipo.
</Card>

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

De manera predeterminada, los usuarios de un equipo podrán configurar sus propios servidores MCP. Sin embargo, una vez que añadas siquiera un solo servidor MCP a la lista de permitidos, **todos los servidores que no estén en esa lista quedarán bloqueados** para tu equipo.

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

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

Cuando incluyes en la lista de permitidos un servidor MCP, el sistema utiliza **coincidencia de patrones con expresiones regulares (regex)** con las siguientes reglas:

* **Coincidencia de cadena completa**: Todos los patrones se anclan automáticamente (se envuelven con `^(?:pattern)$`) para evitar coincidencias parciales
* **Campo Command**: Debe coincidir exactamente o conforme a tu patrón de regex
* **Matriz de argumentos**: Cada argumento se compara individualmente con su patrón correspondiente
* **Longitud de la matriz**: 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 deseas una coincidencia literal

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

<AccordionGroup>
  <Accordion title="Opción 1: Predeterminado de la tienda de plugins (recomendado)" description="Deja vacío el campo Server Config (JSON) para usar la configuración predeterminada de la Windsurf MCP Plugin Store.">
    **Configuración de lista de permitidos del administrador:**

    * **Server ID**: `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 de la tienda de plugins.
  </Accordion>

  <Accordion title="Opción 2: Coincidencia exacta de configuración" description="Proporciona la configuración exacta que deben usar los usuarios. Deben coincidir con esta configuración exactamente.">
    **Configuración de lista de permitidos del administrador:**

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

    **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 exactamente esta configuración: cualquier desviación en `command` o `args` será bloqueada. 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 usuario manteniendo los controles de seguridad.">
    **Configuración de lista de permitidos del administrador:**

    * **Server ID**: `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 comprometer 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 rutas y puertos mientras los administradores garantizan 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`       | Literal `$HOME`           | `$HOME` (sin expandir) |
| `\\.py`         | Literal `.py`             | `script.py`            |
| `\\[cli\\]`     | Literal `[cli]`           | `mcp[cli]`             |

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

<div id="admin-configuration-guidelines">
  ### Directrices de configuración para administradores
</div>

* **Variables de entorno**: La sección `env` no se compara con expresiones regulares (regex) y los usuarios pueden configurarla libremente
* **Herramientas deshabilitadas**: El array `disabledTools` se maneja por separado y no forma parte de la comprobación de la lista de permitidos (whitelist)
* **Sensible a 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 la denegación de acceso
* **Pruebas**: Prueba tus patrones de regex cuidadosamente; 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 incluirlos en la lista de permitidos:

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

Recuerda: Una vez que incluyes en la lista de permitidos cualquier servidor, **todos los demás servidores se bloquean automáticamente** para los miembros de tu equipo.

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

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