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

# Servidor Search Model Context Protocol (MCP)

> Conecta herramientas de IA como Claude, Cursor y ChatGPT a tu servidor MCP de búsqueda alojado para que consulten y recuperen contenido de tu sitio.

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 Search MCP para tu sitio, preparando tu contenido para el ecosistema de IA más amplio. Cualquier cliente MCP como Claude, Cursor, Goose o ChatGPT puede conectarse a tu contenido.

Tu servidor Search MCP expone herramientas para que las aplicaciones de IA busquen y recuperen tu contenido. Tus usuarios deben conectar tu servidor Search MCP a sus herramientas.

<Tip>
  ¿Quieres permitir que los agentes editen tu contenido en lugar de solo leerlo? Usa el [servidor Admin MCP](/es/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 Search MCP, puede buscar en tu contenido y recuperar páginas completas en formato Markdown en respuesta al prompt de un usuario. Esto evita basarse en información de los datos de entrenamiento o en búsquedas web genéricas. Tu servidor Search MCP proporciona acceso a todo el contenido indexado de tu sitio Mintlify.

* Las aplicaciones de IA pueden buscar proactivamente en tu contenido mientras generan una respuesta, incluso si no se les pide explícitamente que busquen 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 contenido.
* 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 sitio para generar su respuesta.

<Tip>
  Algunas herramientas de IA como Claude son compatibles tanto con MCP como con skills. MCP proporciona acceso a tu contenido, 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 Search MCP proporciona dos herramientas que los agentes pueden usar:

* **Search**: Busca en tu sitio 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 sitio usando comandos de estilo shell. Úsala para explorar y recuperar contenido, 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 sitio 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 Search MCP también expone tus [archivos skill.md](/es/ai/skillmd) como recursos MCP. Los agentes conectados a tu servidor Search 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 Search 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 del sitio. Por ejemplo, `'v0.7'`. Solo está disponible cuando tu sitio 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 sitio 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">
  ### Search MCP en comparación con la búsqueda en la web
</div>

Las herramientas de IA pueden buscar en la web, pero el Search MCP ofrece ventajas claras.

* **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. El Search MCP busca directamente en tu contenido indexado 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 a tu contenido.

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

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

* Para contenido público, tu servidor Search MCP está disponible para cualquiera. Busca en todas las páginas públicas indexadas.
* Para contenido con autenticación parcial, donde algunas páginas son públicas y otras requieren iniciar sesión, debes habilitar tu servidor Search 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 contenido en el que todas las páginas requieren autenticación, debes habilitar tu servidor Search MCP antes de que esté disponible para los usuarios. Los usuarios deben autenticarse antes de conectarse a tu servidor Search MCP. Tu servidor Search 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 Search MCP en la [página del servidor MCP](https://dashboard.mintlify.com/products/mcp) de tu dashboard.

<Frame>
  <img src="https://mintcdn.com/adminroletesting-justin-client-exports/PdUMLzGWBM_RlEqQ/images/mcp/mcp-server-page-light.png?fit=max&auto=format&n=PdUMLzGWBM_RlEqQ&q=85&s=58705aec1d14e018b5ded69304dc7272" alt="Página del servidor MCP en el dashboard." className="block dark:hidden" width="2408" height="923" data-path="images/mcp/mcp-server-page-light.png" />

  <img src="https://mintcdn.com/adminroletesting-justin-client-exports/PdUMLzGWBM_RlEqQ/images/mcp/mcp-server-page-dark.png?fit=max&auto=format&n=PdUMLzGWBM_RlEqQ&q=85&s=c78fe0f3951941bc659de687b52cc88a" alt="Página del servidor MCP en el dashboard." className="hidden dark:block" width="2408" height="923" data-path="images/mcp/mcp-server-page-dark.png" />
</Frame>

<Note>
  Los servidores Search MCP 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 Search MCP sin configuración previa.

`GET /.well-known/mcp` devuelve un documento JSON que describe tu servidor Search 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.                                                                                                                 |

Para la compatibilidad con agentes, el mismo documento de descubrimiento también está disponible en `/.well-known/mcp.json`. Mintlify además expone una tarjeta de servidor MCP en `/.well-known/mcp/server-card.json` y una lista de tarjetas de servidor en `/.well-known/mcp/server-cards.json`. Todos los endpoints de descubrimiento se sirven automáticamente y no requieren configuración.

<div id="server-card-endpoints">
  #### Endpoints de la tarjeta de servidor
</div>

`GET /.well-known/mcp/server-card.json` devuelve una única tarjeta de servidor que describe tu servidor MCP. `GET /.well-known/mcp/server-cards.json` devuelve un arreglo `servers` con una tarjeta por cada endpoint disponible (siempre incluye una tarjeta de servidor pública y una tarjeta de servidor autenticada cuando la autenticación está habilitada).

Cada tarjeta de servidor incluye los campos de descubrimiento estándar y un arreglo `tools` que describe las herramientas MCP que el servidor anuncia. Úsalo para precargar los metadatos de las herramientas en los clientes MCP sin tener que realizar una llamada `initialize` al servidor.

```json theme={null}
{
  "name": "your-docs-search",
  "version": "1.0.0",
  "url": "https://your-docs.com/mcp",
  "transport": "http",
  "description": "Search and retrieve your documentation",
  "capabilities": {
    "tools": true,
    "resources": true
  },
  "authentication": "none",
  "tools": [
    {
      "name": "search_your_docs",
      "title": "Search documentation",
      "description": "Search across your documentation site.",
      "inputSchema": {
        "type": "object",
        "properties": {
          "query": { "type": "string", "description": "Search query" }
        },
        "required": ["query"]
      },
      "annotations": {
        "readOnlyHint": true,
        "destructiveHint": false,
        "idempotentHint": true,
        "openWorldHint": false
      }
    }
  ]
}
```

| Campo                 | Descripción                                                                                                                                                                                                               |
| --------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `tools[].name`        | Nombre de la herramienta anunciada a través de MCP. Los nombres de las herramientas son específicos de cada sitio, así que usa el valor devuelto por el endpoint de descubrimiento en lugar de codificarlo de forma fija. |
| `tools[].title`       | Título opcional, legible por humanos, de la herramienta.                                                                                                                                                                  |
| `tools[].description` | Descripción legible por humanos de lo que hace la herramienta.                                                                                                                                                            |
| `tools[].inputSchema` | JSON Schema de los parámetros de entrada de la herramienta.                                                                                                                                                               |
| `tools[].annotations` | [Anotaciones de herramientas MCP](https://modelcontextprotocol.io/specification/2025-06-18/server/tools#tool-annotations) opcionales que describen el comportamiento de la herramienta.                                   |

Las herramientas integradas de búsqueda y de consulta del sistema de archivos de la documentación se anuncian como de solo lectura y no destructivas con las siguientes anotaciones:

* `readOnlyHint: true`: la herramienta no modifica ningún estado.
* `destructiveHint: false`: la herramienta no tiene efectos secundarios destructivos.
* `idempotentHint: true`: las llamadas repetidas con los mismos argumentos devuelven resultados equivalentes.
* `openWorldHint: false`: la herramienta opera sobre tu documentación indexada y no sobre la web abierta.

Los clientes MCP pueden usar estas anotaciones para mostrar a los usuarios información sobre la seguridad de las herramientas o para permitir que las herramientas de solo lectura se ejecuten sin aprobación explícita.

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

Si tu sitio requiere autenticación, tu servidor Search 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 sitio tiene autenticación parcial con páginas públicas y protegidas, dispones de dos endpoints del servidor Search 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.

<Note>
  Las credenciales de cliente de MCP son distintas de las [claves de API de Mintlify](/es/api/introduction). Las claves de API de administración y del asistente autentican solicitudes a la API REST de Mintlify y no pueden usarse para autenticarse en tu servidor MCP. Para llamar a tu servidor MCP de forma programática, crea una credencial de cliente en la [página del servidor MCP](https://dashboard.mintlify.com/products/mcp) e intercámbiala por un token de acceso siguiendo los pasos a continuación.
</Note>

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

    <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 (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 (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 (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 (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 del repositorio de tu proyecto. 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.

Para los sitios que requieren 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).

Para los sitios 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 contenido 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 sitio.

    | 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="Codex">
    <Steps>
      <Step title="Obtén la URL de tu servidor MCP">
        Ve a tu [dashboard](https://app.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 la CLI de Codex.

        En `~/.codex/config.toml`, añade:

        ```toml theme={null}
        [mcp_servers.<your-mcp-server-name>]
        url = "<your-mcp-server-url>"
        ```
      </Step>
    </Steps>

    Consulta la [Codex MCP documentation](https://developers.openai.com/codex/mcp) 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="Codex">
    Para conectar el servidor MCP de Mintlify a la CLI de Codex, añádelo a tu archivo de configuración en `~/.codex/config.toml`:

    ```toml theme={null}
    [mcp_servers.mintlify]
    url = "https://mintlify.com/docs/mcp"
    ```

    Prueba la conexión iniciando una sesión de Codex y preguntando:

    ```text theme={null}
    What tools do you have available?
    ```

    Codex debería listar el servidor MCP de Mintlify como una herramienta disponible.

    Consulta la [Codex MCP documentation](https://developers.openai.com/codex/mcp) 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.