> ## Documentation Index
> Fetch the complete documentation index at: https://tomee-rohan-testing.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Protocolo de Contexto del Modelo (MCP)

> Conecta tu documentación y endpoints de API a herramientas de IA como Claude y Cursor con un servidor de Protocolo de Contexto de Modelos (MCP) alojado.

export const PreviewButton = ({children, href}) => {
  return <a href={href} className="text-sm font-medium text-white dark:!text-zinc-950 bg-zinc-900 hover:bg-zinc-700 dark:bg-zinc-100 hover:dark:bg-zinc-300 rounded-full px-3.5 py-1.5 not-prose">
        {children}
      </a>;
};

<div id="about-mcp-servers">
  ## Acerca de los servidores MCP
</div>

El Model Context Protocol (MCP) es un protocolo abierto que crea conexiones estandarizadas entre aplicaciones de IA y servicios externos, como la documentación. Mintlify genera un servidor MCP a partir de tu documentación, preparando tu contenido para el ecosistema de IA más amplio, donde cualquier cliente MCP (como Claude, Cursor, Goose y otros) puede conectarse a tu documentación.

Tu servidor MCP expone herramientas para que las aplicaciones de IA puedan buscar en tu documentación y obtener el contenido completo de las páginas. Tus usuarios deben conectar tu servidor MCP a sus herramientas.

<Tip>
  ¿Quieres permitir que los agentes editen tu contenido en lugar de solo leerlo? Consulta el [servidor MCP de Mintlify](/ai/mintlify-mcp) para acceder a un servidor MCP autenticado que expone herramientas de branching, edición de páginas, navegación y `docs.json` a agentes de confianza.
</Tip>

<div id="how-mcp-servers-work">
  ### Cómo funcionan los servidores MCP
</div>

Cuando una aplicación de IA se conecta a tu servidor MCP de documentación, puede buscar en tu documentación y obtener el contenido completo de las páginas directamente en respuesta a la instrucción de un usuario, en lugar de basarse en información de sus datos de entrenamiento o realizar una búsqueda genérica en la web. Tu servidor MCP proporciona acceso a todo el contenido indexado de tu sitio de documentación.

* Las aplicaciones de IA pueden buscar proactivamente en tu documentación mientras generan una respuesta, incluso si no se les pide explícitamente que busquen en tu documentación para encontrar una respuesta.
* Las aplicaciones de IA determinan cuándo usar las herramientas disponibles según el contexto de la conversación y la relevancia de tu documentación.
* Cada llamada a la herramienta ocurre durante el proceso de generación, por lo que la aplicación de IA utiliza información actualizada de tu documentación para generar su respuesta.

<Tip>
  Algunas herramientas de IA como Claude son compatibles tanto con MCP como con skills. MCP proporciona acceso al contenido de tu documentación, mientras que los skills indican a los agentes cómo usar ese contenido de forma eficaz. Son complementarios y al conectar tu servidor MCP los agentes obtienen acceso a ambos.
</Tip>

<div id="mcp-tools">
  ### Herramientas MCP
</div>

Tu servidor MCP proporciona dos herramientas que los agentes pueden usar:

* **Search**: Busca en toda tu documentación para encontrar contenido relevante, devolviendo fragmentos con títulos y enlaces. Úsala para descubrir información o encontrar páginas que coincidan con una consulta.
* **Query docs filesystem**: Lee y navega el sistema de archivos virtual de tu documentación usando comandos de estilo shell. Úsala para obtener el contenido de páginas, explorar la estructura de la documentación o extraer secciones específicas, incluyendo lecturas de múltiples páginas en una sola llamada.

Los agentes determinan cuándo usar cada herramienta según el contexto de la conversación. Por ejemplo, un agente podría primero buscar en tu documentación para encontrar páginas relevantes y luego usar la herramienta query docs filesystem para leer el contenido completo de los resultados más relevantes.

<div id="mcp-resources">
  ### Recursos MCP
</div>

Tu servidor MCP también expone tus [archivos skill.md](/es/ai/skillmd) como recursos MCP. Los agentes conectados a tu servidor MCP pueden descubrir y acceder a tus archivos de skill sin necesidad de instalarlos por separado.

Los recursos `Skill.md` aparecen en la lista de recursos del servidor MCP y contienen las descripciones de capacidades que Mintlify genera o que tú defines en tus [archivos de skill personalizados](/es/ai/skillmd#custom-skill-files).

<div id="search-parameters">
  ### Parámetros de búsqueda
</div>

La herramienta de búsqueda MCP admite parámetros opcionales que las aplicaciones de IA usan para controlar y refinar los resultados de búsqueda.

* **`version`**: Filtra los resultados a una versión específica de la documentación. Por ejemplo, `'v0.7'`. Solo está disponible cuando tu documentación tiene varias versiones. Solo devuelve contenido etiquetado con la versión especificada o contenido disponible en todas las versiones.
* **`language`**: Filtra los resultados a un código de idioma específico. Por ejemplo, `'en'`, `'zh'` o `'es'`. Solo está disponible cuando tu documentación tiene varios idiomas. Solo devuelve contenido en el idioma especificado o contenido disponible en todos los idiomas.

Las aplicaciones de IA determinan cuándo aplicar estos parámetros en función del contexto de la búsqueda del usuario. Por ejemplo, si un usuario pregunta por una versión específica de la API, la aplicación de IA puede aplicar automáticamente el filtro adecuado para ofrecer resultados más relevantes.

<div id="mcp-compared-to-web-search">
  ### MCP en comparación con la búsqueda en la web
</div>

Las herramientas de IA pueden buscar en la web, pero MCP ofrece ventajas claras para la documentación.

* **Acceso directo a la fuente**: La búsqueda en la web depende de lo que los motores de búsqueda hayan indexado, lo cual puede estar desactualizado o incompleto. MCP busca directamente en tu documentación indexada actual.
* **Flujo de trabajo integrado**: MCP permite que la IA busque mientras genera la respuesta, en lugar de realizar una búsqueda web por separado.
* **Sin ruido de búsqueda**: Los algoritmos de SEO (optimización para motores de búsqueda) y de clasificación influyen en los resultados de búsqueda en la web. MCP va directamente al contenido de tu documentación.

<div id="access-your-mcp-server">
  ## Accede a tu servidor MCP
</div>

Mintlify genera un servidor MCP para tu documentación y lo aloja en la ruta `/mcp` de la URL de tu documentación. Por ejemplo, el servidor MCP de Mintlify está disponible en `https://mintlify.com/docs/mcp`.

* Para la documentación pública, tu servidor MCP está disponible para cualquiera. Busca en todas las páginas públicas indexadas.
* Para la documentación con autenticación parcial, donde algunas páginas son públicas y otras requieren iniciar sesión, debes habilitar tu servidor MCP antes de que los usuarios puedan acceder a él. Los usuarios no autenticados pueden buscar en el contenido público. Los usuarios que se autentican pueden buscar en todo el contenido al que tienen permiso de acceso según sus [grupos de usuarios](/es/deploy/authentication-setup).
* Para la documentación en la que todas las páginas requieren autenticación, debes habilitar tu servidor MCP antes de que esté disponible para los usuarios. Los usuarios deben autenticarse antes de conectarse a tu servidor MCP. Tu servidor MCP busca solo en el contenido al que cada usuario tiene acceso según sus [grupos de usuarios](/es/deploy/authentication-setup).

Puedes ver y copiar la URL de tu servidor MCP en la [página del servidor MCP](https://dashboard.mintlify.com/products/mcp) de tu dashboard.

<Frame>
  <img src="https://mintcdn.com/tomee-rohan-testing/ufPIF8s9ColsSkEr/images/mcp/mcp-server-page-light.png?fit=max&auto=format&n=ufPIF8s9ColsSkEr&q=85&s=fd7f993cfdc87e087733252b353f23f6" alt="Página del servidor MCP en el dashboard." className="block dark:hidden" width="2066" height="972" data-path="images/mcp/mcp-server-page-light.png" />

  <img src="https://mintcdn.com/tomee-rohan-testing/ufPIF8s9ColsSkEr/images/mcp/mcp-server-page-dark.png?fit=max&auto=format&n=ufPIF8s9ColsSkEr&q=85&s=1414198b9c10539d7741c2310cf68821" alt="Página del servidor MCP en el dashboard." className="hidden dark:block" width="2068" height="974" data-path="images/mcp/mcp-server-page-dark.png" />
</Frame>

<Note>
  Los servidores MCP alojados utilizan las rutas `/mcp` y `/authed/mcp`. Otros elementos de navegación no pueden utilizar estas rutas.
</Note>

<div id="discovery-endpoint">
  ### Endpoint de descubrimiento
</div>

Mintlify aloja un documento de descubrimiento en `/.well-known/mcp` para que los agentes y herramientas localicen tu servidor MCP sin configuración previa.

`GET /.well-known/mcp` devuelve un documento JSON que describe tu servidor MCP:

```json theme={null}
{
  "version": "1.0.0",
  "transport": "http",
  "url": "https://your-docs.com/mcp",
  "servers": [
    {
      "name": "public",
      "url": "https://your-docs.com/mcp",
      "transport": "http",
      "authentication": "none"
    },
    {
      "name": "authenticated",
      "url": "https://your-docs.com/authed/mcp",
      "transport": "http",
      "authentication": "oauth2"
    }
  ]
}
```

| Campo                      | Descripción                                                                                                                                                         |
| -------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `version`                  | La versión del servidor MCP.                                                                                                                                        |
| `transport`                | El protocolo de transporte. Siempre es `http`.                                                                                                                      |
| `url`                      | La URL pública predeterminada del servidor MCP.                                                                                                                     |
| `servers`                  | Servidores MCP disponibles. Siempre incluye una entrada `public`. Cuando la autenticación está habilitada en tu sitio, también incluye una entrada `authenticated`. |
| `servers[].name`           | Identificador de la entrada del servidor.                                                                                                                           |
| `servers[].authentication` | Método de autenticación de la entrada del servidor.                                                                                                                 |

<div id="enable-authenticated-mcp">
  ### Habilitar MCP autenticado
</div>

Si tu documentación requiere autenticación, tu servidor MCP exige que los usuarios se autentiquen antes de conectarse. Cuando un usuario añade la URL de tu servidor MCP a su herramienta de IA, debe iniciar sesión con sus credenciales existentes. Después de autenticarse, se le redirige de vuelta a su herramienta. El servidor MCP solo devuelve el contenido al que cada usuario tiene permiso de acceso según sus [grupos de usuarios](/es/deploy/authentication-setup).

Si tu documentación tiene autenticación parcial con páginas públicas y protegidas, dispones de dos endpoints del servidor MCP:

* `/mcp`: No requiere autenticación. Devuelve solo contenido público. Comparte este endpoint con usuarios que necesiten acceso al contenido público.
* `/authed/mcp`: Siempre requiere autenticación. Devuelve contenido según los permisos de cada usuario basados en sus [grupos de usuarios](/es/deploy/authentication-setup). Comparte este endpoint con usuarios que necesiten acceso al contenido protegido.

El endpoint `/authed/mcp` utiliza su propio flujo OAuth en `/authed/mcp/oauth/*`. Los dominios de redirección configurados para tu servidor MCP se aplican tanto a `/mcp` como a `/authed/mcp`.

De forma predeterminada, tu servidor MCP solo está disponible para herramientas en localhost. Para permitir que se conecten herramientas basadas en la web, agrega los dominios de redirección de las herramientas de IA. Un dominio de redirección es el nombre de host que usa una herramienta de IA después de que un usuario completa la autenticación, como `claude.ai` o `app.cursor.ai`. Las herramientas de IA de tus usuarios no pueden completar la autenticación a menos que su dominio de redirección esté en esta lista.

<Steps>
  <Step title="Habilitar MCP autenticado en tu dashboard">
    1. Ve a la [página del servidor MCP](https://dashboard.mintlify.com/products/mcp) en tu dashboard.
    2. Haz clic en el interruptor **Enable MCP Server**.
  </Step>

  <Step title="Agregar dominios de redirección">
    Agrega los dominios de redirección de las herramientas de IA a las que quieres dar acceso a tus usuarios. Las herramientas de IA de tus usuarios no pueden completar la autenticación a menos que su dominio de redirección esté en esta lista. Entre los dominios de redirección más comunes están `claude.ai` y `vscode.dev/redirect`.

    De forma predeterminada, los dominios de redirección utilizan `https://`. Para permitir un esquema de protocolo personalizado, incluye el protocolo completo en la entrada del dominio. Por ejemplo, un callback de aplicación nativa como `myapp://callback`. Mintlify siempre bloquea protocolos peligrosos como `javascript:`, `data:` y `file:`.

    Las direcciones loopback (`localhost`, `127.0.0.1`) siempre son de confianza y no es necesario agregarlas.
  </Step>
</Steps>

<div id="client-credentials">
  ### Credenciales de cliente
</div>

Las credenciales de cliente te permiten conectarte a tu servidor MCP autenticado de forma programática sin un inicio de sesión basado en el navegador. Usa las credenciales de cliente para integraciones del lado del servidor, pipelines de CI/CD, flujos de trabajo automatizados y cualquier entorno donde un usuario no pueda completar un flujo OAuth interactivo.

Las credenciales de cliente se autentican contra el endpoint `/authed/mcp` y devuelven todo el contenido de las páginas públicas y de las páginas autenticadas que no estén restringidas a grupos específicos.

<Steps>
  <Step title="Crear una credencial de cliente">
    1. Ve a la [página del servidor MCP](https://dashboard.mintlify.com/products/mcp) en tu dashboard.
    2. En la sección **Client Credentials**, selecciona **Create credential**.
    3. Ingresa una etiqueta para la credencial para identificar su propósito.
    4. Copia el **client ID** y el **client secret**. El client secret solo se muestra una vez. No podrás recuperarlo después.
  </Step>

  <Step title="Intercambiar credenciales por un token de acceso">
    Envía una solicitud POST al endpoint de token de tu servidor MCP con tu client ID y secret. Tu endpoint de token se encuentra en la ruta `/authed/mcp/oauth/token` de la URL de tu documentación.

    <CodeGroup>
      ```bash cURL theme={null}
      curl -X POST https://your-docs.com/authed/mcp/oauth/token \
        -H 'Content-Type: application/x-www-form-urlencoded' \
        -d 'grant_type=client_credentials&client_id=CLIENT_ID&client_secret=CLIENT_SECRET'
      ```

      ```bash cURL (Basic Auth) theme={null}
      curl -X POST https://your-docs.com/authed/mcp/oauth/token \
        -H 'Content-Type: application/x-www-form-urlencoded' \
        -H 'Authorization: Basic BASE64_CLIENT_ID_COLON_SECRET' \
        -d 'grant_type=client_credentials'
      ```
    </CodeGroup>

    La respuesta incluye un token de acceso y un token de actualización:

    ```json theme={null}
    {
      "access_token": "eyJhbGciOi...",
      "token_type": "Bearer",
      "expires_in": 1209600,
      "refresh_token": "eyJhbGciOi...",
      "scope": "mcp:search"
    }
    ```

    Los tokens de acceso expiran después del número de segundos especificado en `expires_in`. Usa el `refresh_token` para obtener un nuevo token de acceso cuando el actual expire.
  </Step>

  <Step title="Conectarse al servidor MCP">
    Usa el token de acceso como bearer token al conectarte al endpoint `/authed/mcp`.

    <CodeGroup>
      ```bash cURL theme={null}
      curl -X POST https://your-docs.com/authed/mcp \
        -H 'Authorization: Bearer ACCESS_TOKEN' \
        -H 'Content-Type: application/json' \
        -H 'Accept: application/json, text/event-stream' \
        -d '{
          "jsonrpc": "2.0",
          "id": 1,
          "method": "initialize",
          "params": {
            "protocolVersion": "2025-03-26",
            "capabilities": {},
            "clientInfo": {"name": "my-integration", "version": "1.0.0"}
          }
        }'
      ```

      ```bash Claude Code theme={null}
      claude mcp add --transport http \
        --header "Authorization: Bearer ACCESS_TOKEN" \
        my-docs https://your-docs.com/authed/mcp
      ```
    </CodeGroup>
  </Step>
</Steps>

<div id="managing-client-credentials">
  #### Gestión de credenciales de cliente
</div>

Puedes gestionar tus credenciales de cliente desde la [página del servidor MCP](https://dashboard.mintlify.com/products/mcp) en tu dashboard.

* **Eliminar una credencial** para revocar el acceso de forma permanente. Esta acción no se puede deshacer.

<Warning>
  Trata los client secrets como contraseñas. No los incluyas en el control de código fuente ni los expongas en código del lado del cliente. Usa variables de entorno o un administrador de secretos para almacenarlos.
</Warning>

<div id="rate-limits">
  ### Límites de uso
</div>

Para proteger la disponibilidad, Mintlify aplica límites de uso a los servidores MCP.

| Alcance                                                               | Límite                      | Descripción                                                                                                                  |
| :-------------------------------------------------------------------- | :-------------------------- | :--------------------------------------------------------------------------------------------------------------------------- |
| Por usuario (dirección IP)                                            | 5.000 solicitudes por hora  | Limita la frecuencia con la que un solo usuario puede consultar la configuración de tu servidor MCP.                         |
| Search por sitio de documentación (domain)                            | 10.000 solicitudes por hora | Limita el total de llamadas a la herramienta de búsqueda entre todos los usuarios de tu servidor MCP.                        |
| Query docs filesystem por sitio de documentación (domain)             | 10.000 solicitudes por hora | Limita el total de llamadas a la herramienta query docs filesystem entre todos los usuarios de tu servidor MCP.              |
| Search autenticado por sitio de documentación (domain)                | 5.000 solicitudes por hora  | Limita el total de llamadas autenticadas a la herramienta de búsqueda entre todos los usuarios de tu servidor MCP.           |
| Query docs filesystem autenticado por sitio de documentación (domain) | 5.000 solicitudes por hora  | Limita el total de llamadas autenticadas a la herramienta query docs filesystem entre todos los usuarios de tu servidor MCP. |

<div id="content-filtering-and-indexing">
  ## Filtrado de contenido e indexación
</div>

Tu servidor MCP busca contenido que Mintlify indexa a partir de tu repositorio de documentación. La forma en que se procesan los archivos y se realiza la indexación de búsqueda determina qué contenido está disponible a través de tu servidor MCP.

En la documentación que requiere autenticación, tu servidor MCP indexa las [páginas públicas](/es/deploy/authentication-setup#make-pages-public) y cualquier página a la que un usuario autenticado tenga permiso de acceso según sus [grupos de usuarios](/es/deploy/authentication-setup#restrict-pages-to-specific-user-groups).

En la documentación con autenticación parcial, los usuarios no autenticados pueden buscar en las páginas públicas. Los usuarios autenticados pueden buscar en las páginas públicas y en cualquier página a la que tengan permiso de acceso según sus grupos de usuarios.

<div id="file-processing-with-mintignore">
  ### Procesamiento de archivos con `.mintignore`
</div>

Si los archivos coinciden con los patrones de [.mintignore](/es/organize/mintignore), Mintlify no los procesa ni los indexa. Estos archivos no están disponibles mediante tu servidor MCP.

<div id="search-indexing-with-docsjson">
  ### Indexación de búsqueda con `docs.json`
</div>

De forma predeterminada, Mintlify solo indexa las páginas incluidas en la navigation de tu `docs.json` para la búsqueda a través de tu servidor MCP.

Mintlify excluye las [páginas ocultas](/es/organize/hidden-pages) (páginas que no están en tu navigation) del índice de búsqueda a menos que elijas indexar todas las páginas. Para incluir páginas ocultas en los resultados de búsqueda de tu servidor MCP, agrega la propiedad `seo.indexing` a tu `docs.json`.

```json theme={null}
"seo": {
    "indexing": "all"
}
```

Para excluir una página específica de la indexación en buscadores, agrega `noindex: true` a su frontmatter.

```mdx theme={null}
---
title: "Página oculta"
description: "Esta página no está en la navegación y no está disponible mediante búsqueda."
noindex: true
---
```

<div id="use-your-mcp-server">
  ## Usa tu servidor MCP
</div>

Tus usuarios deben conectar tu servidor MCP a sus herramientas de IA preferidas.

1. Haz que la URL de tu servidor MCP sea pública.
2. Los usuarios copian la URL de tu servidor MCP y la añaden a sus herramientas.
3. Los usuarios acceden a tu documentación desde sus herramientas.

Estas son algunas formas en que puedes ayudar a tus usuarios a conectarse a tu servidor MCP:

<Tabs>
  <Tab title="Menú contextual">
    Agrega opciones en el [menú contextual](/es/ai/contextual-menu) para que tus usuarios se conecten a tu servidor MCP desde cualquier página de tu documentación.

    | Opción                                   | Identificador | Descripción                                                     |
    | :--------------------------------------- | :------------ | :-------------------------------------------------------------- |
    | **Copiar URL del servidor MCP**          | `mcp`         | Copia la URL de tu servidor MCP en el portapapeles del usuario. |
    | **Copiar comando de instalación de MCP** | `add-mcp`     | Copia el comando `npx add-mcp` para instalar el servidor MCP.   |
    | **Conectar con Cursor**                  | `cursor`      | Instala tu servidor MCP en Cursor.                              |
    | **Conectar con VS Code**                 | `vscode`      | Instala tu servidor MCP en VS Code.                             |
  </Tab>

  <Tab title="Claude">
    <Steps>
      <Step title="Obtén la URL de tu servidor MCP.">
        Ve a tu [dashboard](https://dashboard.mintlify.com/products/mcp) y encuentra la URL de tu servidor MCP.
      </Step>

      <Step title="Publica la URL de tu servidor MCP para tus usuarios.">
        Crea una guía para tus usuarios que incluya la URL de tu servidor MCP y los pasos para conectarlo a Claude.

        1. Ve a la página de [Connectors](https://claude.ai/settings/connectors) en la configuración de Claude.
        2. Selecciona **Add custom connector**.
        3. Agrega el nombre y la URL de tu servidor MCP.
        4. Selecciona **Add**.
        5. Al usar Claude, selecciona el botón de adjuntos (el ícono de más).
        6. Selecciona tu servidor MCP.
      </Step>
    </Steps>

    Consulta la [documentación de Model Context Protocol](https://modelcontextprotocol.io/docs/tutorials/use-remote-mcp-server#connecting-to-a-remote-mcp-server) para más detalles.
  </Tab>

  <Tab title="Claude Code">
    <Steps>
      <Step title="Obtén la URL de tu servidor MCP.">
        Ve a tu [dashboard](https://dashboard.mintlify.com/products/mcp) y encuentra la URL de tu servidor MCP.
      </Step>

      <Step title="Publica la URL de tu servidor MCP para tus usuarios.">
        Crea una guía para tus usuarios que incluya la URL de tu servidor MCP y el comando para conectarlo a Claude Code.

        ```bash theme={null}
        claude mcp add --transport http <name> <url>
        ```
      </Step>
    </Steps>

    Consulta la [documentación de Claude Code](https://docs.anthropic.com/en/docs/claude-code/mcp#installing-mcp-servers) para más detalles.
  </Tab>

  <Tab title="Cursor">
    <Steps>
      <Step title="Obtén la URL de tu servidor MCP.">
        Ve a tu [dashboard](https://dashboard.mintlify.com/products/mcp) y encuentra la URL de tu servidor MCP.
      </Step>

      <Step title="Publica la URL de tu servidor MCP para tus usuarios.">
        Crea una guía para tus usuarios que incluya la URL de tu servidor MCP y los pasos para conectarlo a Cursor.

        1. Usa <kbd>Command</kbd> + <kbd>Shift</kbd> + <kbd>P</kbd> (<kbd>Ctrl</kbd> + <kbd>Shift</kbd> + <kbd>P</kbd> en Windows) para abrir la paleta de comandos.
        2. Busca "Open MCP settings".
        3. Selecciona **Add custom MCP**. Esto abrirá el archivo `mcp.json`.
        4. En `mcp.json`, configura tu servidor:

        ```json theme={null}
        {
          "mcpServers": {
            "<your-mcp-server-name>": {
              "url": "<your-mcp-server-url>"
            }
          }
        }
        ```
      </Step>
    </Steps>

    Consulta la [documentación de Cursor](https://docs.cursor.com/en/context/mcp#installing-mcp-servers) para más detalles.
  </Tab>

  <Tab title="VS Code">
    <Steps>
      <Step title="Obtén la URL de tu servidor MCP.">
        Ve a tu [dashboard](https://dashboard.mintlify.com/products/mcp) y encuentra la URL de tu servidor MCP.
      </Step>

      <Step title="Publica la URL de tu servidor MCP para tus usuarios.">
        Crea una guía para tus usuarios que incluya la URL de tu servidor MCP y los pasos para conectarlo a VS Code.

        1. Crea un archivo `.vscode/mcp.json`.
        2. En `mcp.json`, configura tu servidor:

        ```json theme={null}
        {
          "servers": {
            "<your-mcp-server-name>": {
              "type": "http",
              "url": "<your-mcp-server-url>"
            }
          }
        }
        ```
      </Step>
    </Steps>

    Consulta la [documentación de VS Code](https://code.visualstudio.com/docs/copilot/chat/mcp-servers) para más detalles.
  </Tab>
</Tabs>

<div id="example-connect-to-the-mintlify-mcp-server">
  ### Ejemplo: Conectarse al servidor MCP de Mintlify
</div>

Conéctate al servidor MCP de Mintlify para buscar en este sitio de documentación desde tu herramienta de IA preferida. Esto te dará respuestas más precisas sobre cómo usar Mintlify en tu entorno local y demuestra cómo puedes ayudar a tus usuarios a conectarse a tu servidor MCP.

<Tabs>
  <Tab title="Contextual menu">
    En la parte superior de esta página, selecciona el menú contextual y elige **Connect to Cursor** o **Connect to VS Code** para conectar el servidor MCP de Mintlify con el IDE de tu preferencia.
  </Tab>

  <Tab title="Claude">
    Para usar el servidor MCP de Mintlify con Claude:

    <Steps>
      <Step title="Add the Mintlify MCP server to Claude">
        1. Ve a la página [Connectors](https://claude.ai/settings/connectors) en la configuración de Claude.
        2. Selecciona **Add custom connector**.
        3. Agrega el servidor MCP de Mintlify:

        * Name: `Mintlify`
        * URL: `https://mintlify.com/docs/mcp`

        4. Selecciona **Add**.
      </Step>

      <Step title="Access the MCP server in your chat">
        1. Cuando uses Claude, selecciona el botón de adjuntos (el icono de suma).
        2. Selecciona el servidor MCP de Mintlify.
        3. Hazle a Claude una pregunta sobre Mintlify.
      </Step>
    </Steps>

    Consulta la [documentación de Model Context Protocol](https://modelcontextprotocol.io/docs/tutorials/use-remote-mcp-server#connecting-to-a-remote-mcp-server) para más detalles.
  </Tab>

  <Tab title="Claude Code">
    Para usar el servidor MCP de Mintlify con Claude Code, ejecuta el siguiente comando:

    ```bash theme={null}
    claude mcp add --transport http Mintlify https://mintlify.com/docs/mcp
    ```

    Prueba la conexión ejecutando:

    ```bash theme={null}
    claude mcp list
    ```

    Consulta la [documentación de Claude Code](https://docs.anthropic.com/en/docs/claude-code/mcp#installing-mcp-servers) para más detalles.
  </Tab>

  <Tab title="Cursor">
    <PreviewButton href="cursor://anysphere.cursor-deeplink/mcp/install?name=mintlify&config=eyJ1cmwiOiJodHRwczovL21pbnRsaWZ5LmNvbS9kb2NzL21jcCJ9">Install in Cursor</PreviewButton>

    Para conectar el servidor MCP de Mintlify a Cursor, haz clic en el botón **Install in Cursor**. O, para conectar el servidor MCP manualmente, sigue estos pasos:

    <Steps>
      <Step title="Open MCP settings">
        1. Usa <kbd>Command</kbd> + <kbd>Shift</kbd> + <kbd>P</kbd> (<kbd>Ctrl</kbd> + <kbd>Shift</kbd> + <kbd>P</kbd> en Windows) para abrir la paleta de comandos.
        2. Busca "Open MCP settings".
        3. Selecciona **Add custom MCP**. Esto abrirá el archivo `mcp.json`.
      </Step>

      <Step title="Configure the Mintlify MCP server">
        En `mcp.json`, agrega:

        ```json theme={null}
        {
          "mcpServers": {
            "Mintlify": {
              "url": "https://mintlify.com/docs/mcp"
            }
          }
        }
        ```
      </Step>

      <Step title="Test the connection">
        En el chat de Cursor, pregunta "What tools do you have available?" Cursor debería mostrar el servidor MCP de Mintlify como una herramienta disponible.
      </Step>
    </Steps>

    Consulta [Installing MCP servers](https://docs.cursor.com/en/context/mcp#installing-mcp-servers) en la documentación de Cursor para más detalles.
  </Tab>

  <Tab title="VS Code">
    <PreviewButton href="https://vscode.dev/redirect/mcp/install?name=mintlify&config=%7B%22type%22%3A%22http%22%2C%22url%22%3A%22https%3A%2F%2Fmintlify.com%2Fdocs%2Fmcp%22%7D">Install in VS Code</PreviewButton>

    Para conectar el servidor MCP de Mintlify a VS Code, haz clic en el botón **Install in VS Code**. O, para conectar el servidor MCP manualmente, crea un archivo `.vscode/mcp.json` y agrega:

    ```json theme={null}
    {
      "servers": {
        "Mintlify": {
          "type": "http",
          "url": "https://mintlify.com/docs/mcp"
        }
      }
    }
    ```

    Consulta la [documentación de VS Code](https://code.visualstudio.com/docs/copilot/chat/mcp-servers) para más detalles.
  </Tab>
</Tabs>

<div id="using-multiple-mcp-servers">
  ### Uso de varios servidores MCP
</div>

Los usuarios pueden conectar varios servidores MCP a sus herramientas de IA. Los servidores MCP conectados no consumen contexto hasta que la IA llama a una herramienta de búsqueda. La IA decide cuándo buscar según la relevancia de la búsqueda, por lo que no busca en todos los servidores conectados para cada pregunta.

Cuando la IA realiza una búsqueda, cada búsqueda arroja múltiples resultados que se añaden al contexto de la conversación. Si la IA busca en varios servidores para una sola pregunta, esto puede consumir una cantidad significativa de contexto.

Mejores prácticas para usar varios servidores MCP:

* Conecta solo los servidores MCP relevantes para tu trabajo actual.
* Sé específico en tus instrucciones para que la IA busque en el servidor más relevante.
* Desconecta los servidores que no estés usando activamente para reducir el posible uso de contexto.