# Conectar tu cliente

> Conecta Piqline desde Claude, ChatGPT, Codex, Cursor, VS Code, Gemini CLI, Zed, Mistral Le Chat, Copilot Studio, n8n, LangChain, el SDK de Vercel y cualquier otro cliente MCP: un bloque para copiar por cliente.

Source: https://piqline.com/es/docs/api/clients

Piqline tiene dos servidores MCP, ambos sobre Streamable HTTP:

| Servidor | URL | Autenticación |
| --- | --- | --- |
| Completo | `https://piqline.com/api/mcp` | Clave de API en la cabecera `Authorization: Bearer …` |
| Puerta abierta | `https://piqline.com/api/open/mcp` | ninguna: lo que Piqline sabe hacer y sus datos públicos |

Crea la clave en una cuenta gratuita, en Ajustes → API y MCP. Guárdala en una variable de entorno `PIQLINE_API_KEY` en lugar de en un archivo compartido.

| Cliente | Proveedor | Clave en una cabecera |
| --- | --- | --- |
| [Claude (claude.ai, Claude Desktop)](#claude-claude-ai-claude-desktop) | Anthropic | sí |
| [ChatGPT](#chatgpt) | OpenAI | no, solo puerta abierta |
| [Mistral Le Chat](#mistral-le-chat) | Mistral AI | sí |
| [Microsoft Copilot Studio](#microsoft-copilot-studio) | Microsoft | sí |
| [Claude Code](#claude-code) | Anthropic | sí |
| [Codex CLI](#codex-cli) | OpenAI | sí |
| [Gemini CLI](#gemini-cli) | Google | sí |
| [Cursor](#cursor) | Anysphere | sí |
| [VS Code (GitHub Copilot)](#vs-code-github-copilot) | Microsoft | sí |
| [Zed](#zed) | Zed Industries | sí |
| [Cline](#cline) | Cline | sí |
| [Roo Code](#roo-code) | Roo Code | sí |
| [Continue](#continue) | Continue | sí |
| [Windsurf](#windsurf) | Cognition | mediante el relé |
| [JetBrains AI Assistant](#jetbrains-ai-assistant) | JetBrains | mediante el relé |
| [Goose](#goose) | Block | mediante el relé |
| [Claude API (Messages)](#claude-api-messages) | Anthropic | sí |
| [OpenAI Responses API](#openai-responses-api) | OpenAI | sí |
| [OpenAI Agents SDK](#openai-agents-sdk) | OpenAI | sí |
| [Vercel AI SDK](#vercel-ai-sdk) | Vercel | sí |
| [LangChain / LangGraph](#langchain-langgraph) | LangChain | sí |
| [Google ADK](#google-adk) | Google | sí |
| [n8n](#n8n) | n8n | sí |
| [CrewAI](#crewai) | CrewAI | mediante el relé |
| [LlamaIndex](#llamaindex) | LlamaIndex | mediante el relé |
| [mcp-remote (any local client)](#mcp-remote-any-local-client) | Open source | sí |

## Asistentes y aplicaciones

### Claude (claude.ai, Claude Desktop)

**Dónde:** Ajustes › Conectores › Añadir conector personalizado

Pega la URL del servidor y, en «Request headers», añade `Authorization` con el valor `Bearer` seguido de tu clave. Sin clave, la URL de la puerta abierta funciona con «No sign in».

```text tab="URL"
https://piqline.com/api/mcp
```
```text tab="Header"
Authorization: Bearer piq_live_…
```

En los planes Team y Enterprise, una cabecera definida en el conector la comparten todos los miembros: crea una clave dedicada y con tope.

Fuente: [support.claude.com](https://support.claude.com/en/articles/11175166), consultada el 20 nov 2026 (bloque de la documentación oficial). Aún no probado aquí con una clave real.

### ChatGPT

**Dónde:** Ajustes › Apps › Modo desarrollador › Crear

ChatGPT no acepta una clave en una cabecera: solo OAuth o ninguna autenticación. Conecta hoy la puerta abierta, sin clave; el servidor completo llegará con el inicio de sesión mediante una cuenta de Piqline.

```text
https://piqline.com/api/open/mcp
```

Fuente: [developers.openai.com](https://developers.openai.com/apps-sdk/build/auth), consultada el 20 nov 2026 (bloque de la documentación oficial). Aún no probado aquí con una clave real.

### Mistral Le Chat

**Dónde:** Conectores › Añadir conector MCP (admin)

Pega la URL del servidor, elige la autenticación con token Bearer y pega tu clave.

```text
https://piqline.com/api/mcp
```

Fuente: [docs.mistral.ai](https://docs.mistral.ai/le-chat/knowledge-integrations/connectors/mcp-connectors), consultada el 20 nov 2026 (montado a partir de la documentación oficial). Aún no probado aquí con una clave real.

### Microsoft Copilot Studio

**Dónde:** Agente › Herramientas › Añadir una herramienta › Nueva herramienta › Model Context Protocol

Pega la URL del servidor, elige «Clave de API», ubicación «Header» y nombre `Authorization`. Al conectar, introduce `Bearer` seguido de tu clave.

```text
https://piqline.com/api/mcp
```

Fuente: [learn.microsoft.com](https://learn.microsoft.com/en-us/microsoft-copilot-studio/mcp-add-existing-server-to-agent), consultada el 20 nov 2026 (montado a partir de la documentación oficial). Aún no probado aquí con una clave real.

## Agentes de programación y editores

### Claude Code

**Dónde:** Terminal

Un solo comando. Añade `--scope project` para escribirlo en `.mcp.json` y compartirlo con el equipo.

```bash tab="CLI"
claude mcp add --transport http piqline https://piqline.com/api/mcp \
  --header "Authorization: Bearer $PIQLINE_API_KEY"
```
```json tab=".mcp.json"
{
  "mcpServers": {
    "piqline": {
      "type": "http",
      "url": "https://piqline.com/api/mcp",
      "headers": { "Authorization": "Bearer ${PIQLINE_API_KEY}" }
    }
  }
}
```

Fuente: [code.claude.com](https://code.claude.com/docs/en/mcp), consultada el 20 nov 2026 (bloque de la documentación oficial). Probado con una clave real el 2026-11-20.

### Codex CLI

**Dónde:** ~/.codex/config.toml

Codex lee la clave de una variable de entorno: exporta `PIQLINE_API_KEY` y añade el servidor a la configuración.

```toml
[mcp_servers.piqline]
url = "https://piqline.com/api/mcp"
bearer_token_env_var = "PIQLINE_API_KEY"
```

Fuente: [learn.chatgpt.com](https://learn.chatgpt.com/docs/extend/mcp?surface=cli), consultada el 20 nov 2026 (bloque de la documentación oficial). Aún no probado aquí con una clave real.

### Gemini CLI

**Dónde:** Terminal o ~/.gemini/settings.json

Un solo comando, o el bloque en `settings.json`. La clave `httpUrl` selecciona el transporte HTTP (`url` indicaría el SSE heredado).

```bash tab="CLI"
gemini mcp add --transport http \
  --header "Authorization: Bearer $PIQLINE_API_KEY" piqline https://piqline.com/api/mcp
```
```json tab="settings.json"
{
  "mcpServers": {
    "piqline": {
      "httpUrl": "https://piqline.com/api/mcp",
      "headers": { "Authorization": "Bearer piq_live_…" }
    }
  }
}
```

Fuente: [geminicli.com](https://geminicli.com/docs/tools/mcp-server/), consultada el 20 nov 2026 (bloque de la documentación oficial). Probado con una clave real el 2026-11-20.

### Cursor

**Dónde:** ~/.cursor/mcp.json o .cursor/mcp.json

El bloque lee la clave de una variable de entorno.

```json
{
  "mcpServers": {
    "piqline": {
      "url": "https://piqline.com/api/mcp",
      "headers": { "Authorization": "Bearer ${env:PIQLINE_API_KEY}" }
    }
  }
}
```

Fuente: [cursor.com](https://cursor.com/docs/context/mcp), consultada el 20 nov 2026 (bloque de la documentación oficial). Aún no probado aquí con una clave real.

### VS Code (GitHub Copilot)

**Dónde:** .vscode/mcp.json

VS Code pide la clave en la primera conexión y la guarda en su almacén de secretos. Está anunciado que el formato de `.vscode/mcp.json` será sustituido en febrero de 2027 por un `.mcp.json` en la raíz, con el formato de Claude Code.

```json
{
  "inputs": [
    { "type": "promptString", "id": "piqline-key", "description": "Piqline API key", "password": true }
  ],
  "servers": {
    "piqline": {
      "type": "http",
      "url": "https://piqline.com/api/mcp",
      "headers": { "Authorization": "Bearer ${input:piqline-key}" }
    }
  }
}
```

Fuente: [code.visualstudio.com](https://code.visualstudio.com/docs/agents/reference/mcp-configuration), consultada el 20 nov 2026 (montado a partir de la documentación oficial). Aún no probado aquí con una clave real.

### Zed

**Dónde:** settings.json de Zed

Añade el servidor en `context_servers`.

```json
{
  "context_servers": {
    "piqline": {
      "url": "https://piqline.com/api/mcp",
      "headers": { "Authorization": "Bearer piq_live_…" }
    }
  }
}
```

Fuente: [zed.dev](https://zed.dev/docs/ai/mcp), consultada el 20 nov 2026 (bloque de la documentación oficial). Aún no probado aquí con una clave real.

### Cline

**Dónde:** cline_mcp_settings.json

El campo `type` es obligatorio: sin él, Cline recurre al SSE heredado.

```json
{
  "mcpServers": {
    "piqline": {
      "type": "streamableHttp",
      "url": "https://piqline.com/api/mcp",
      "headers": { "Authorization": "Bearer piq_live_…" }
    }
  }
}
```

Fuente: [docs.cline.bot](https://docs.cline.bot/mcp/configuring-mcp-servers), consultada el 20 nov 2026 (bloque de la documentación oficial). Aún no probado aquí con una clave real.

### Roo Code

**Dónde:** .roo/mcp.json

Añade el servidor al archivo del proyecto.

```json
{
  "mcpServers": {
    "piqline": {
      "type": "streamable-http",
      "url": "https://piqline.com/api/mcp",
      "headers": { "Authorization": "Bearer piq_live_…" }
    }
  }
}
```

Fuente: [roocodeinc.github.io](https://roocodeinc.github.io/Roo-Code/features/mcp/using-mcp-in-roo), consultada el 20 nov 2026 (bloque de la documentación oficial). Aún no probado aquí con una clave real.

### Continue

**Dónde:** config.yaml de Continue

La clave permanece en los secretos de Continue.

```yaml
mcpServers:
  - name: piqline
    type: streamable-http
    url: https://piqline.com/api/mcp
    requestOptions:
      headers:
        Authorization: "Bearer ${{ secrets.PIQLINE_API_KEY }}"
```

Fuente: [docs.continue.dev](https://docs.continue.dev/reference), consultada el 20 nov 2026 (montado a partir de la documentación oficial). Aún no probado aquí con una clave real.

### Windsurf

**Dónde:** ~/.codeium/windsurf/mcp_config.json

Windsurf acepta el transporte HTTP y las cabeceras. Si tu versión rechaza este bloque, usa el relé mcp-remote que se describe más abajo.

```json
{
  "mcpServers": {
    "piqline": {
      "serverUrl": "https://piqline.com/api/mcp",
      "headers": { "Authorization": "Bearer piq_live_…" }
    }
  }
}
```

Fuente: [docs.devin.ai](https://docs.devin.ai/desktop/cascade/mcp), consultada el 20 nov 2026 (cabeceras sin documentar, se recomienda el relé). Aún no probado aquí con una clave real.

### JetBrains AI Assistant

**Dónde:** Ajustes › Herramientas › AI Assistant › Model Context Protocol

La documentación no muestra ninguna cabecera para un servidor remoto: usa el relé mcp-remote que se describe más abajo.

Consulta el relé [mcp-remote](#mcp-remote-any-local-client).

Fuente: [www.jetbrains.com](https://www.jetbrains.com/help/ai-assistant/mcp.html), consultada el 20 nov 2026 (cabeceras sin documentar, se recomienda el relé). Aún no probado aquí con una clave real.

### Goose

**Dónde:** goose configure › Add extension › Remote

Añade una extensión HTTP remota con la URL del servidor y la cabecera `Authorization`. Si no, usa el relé mcp-remote que se describe más abajo.

```text
https://piqline.com/api/mcp
```

Fuente: [goose-docs.ai](https://goose-docs.ai/docs/getting-started/using-extensions), consultada el 20 nov 2026 (cabeceras sin documentar, se recomienda el relé). Aún no probado aquí con una clave real.

## APIs y frameworks de agentes

### Claude API (Messages)

**Dónde:** Petición a la Messages API

El conector MCP de la API llama a Piqline en nombre del modelo. La clave va en `authorization_token`. Consulta la página de la fuente para ver la cabecera beta vigente.

```json
{
  "mcp_servers": [
    { "type": "url", "url": "https://piqline.com/api/mcp", "name": "piqline", "authorization_token": "piq_live_…" }
  ]
}
```

Fuente: [platform.claude.com](https://platform.claude.com/docs/en/agents-and-tools/mcp-connector), consultada el 20 nov 2026 (bloque de la documentación oficial). Aún no probado aquí con una clave real.

### OpenAI Responses API

**Dónde:** Herramienta `mcp` de una petición Responses

La clave va en `headers`.

```json
{
  "type": "mcp",
  "server_label": "piqline",
  "server_url": "https://piqline.com/api/mcp",
  "headers": { "Authorization": "Bearer piq_live_…" },
  "require_approval": "never"
}
```

Fuente: [developers.openai.com](https://developers.openai.com/api/reference/resources/responses/methods/create), consultada el 20 nov 2026 (bloque de la documentación oficial). Aún no probado aquí con una clave real.

### OpenAI Agents SDK

**Dónde:** Python

Un servidor Streamable HTTP con la cabecera.

```python
import os
from agents.mcp import MCPServerStreamableHttp

piqline = MCPServerStreamableHttp(params={
    "url": "https://piqline.com/api/mcp",
    "headers": {"Authorization": f"Bearer {os.environ['PIQLINE_API_KEY']}"},
})
```

Fuente: [openai.github.io](https://openai.github.io/openai-agents-python/mcp/), consultada el 20 nov 2026 (bloque de la documentación oficial). Probado con una clave real el 2026-11-20.

### Vercel AI SDK

**Dónde:** TypeScript

El cliente MCP entrega las herramientas a `generateText` o `streamText`.

```typescript
import { createMCPClient } from "@ai-sdk/mcp";

const piqline = await createMCPClient({
  transport: {
    type: "http",
    url: "https://piqline.com/api/mcp",
    headers: { Authorization: `Bearer ${process.env.PIQLINE_API_KEY}` },
  },
});
const tools = await piqline.tools();
```

Fuente: [ai-sdk.dev](https://ai-sdk.dev/docs/ai-sdk-core/mcp-tools), consultada el 20 nov 2026 (bloque de la documentación oficial). Probado con una clave real el 2026-11-20.

### LangChain / LangGraph

**Dónde:** Python

Las herramientas de Piqline se convierten en herramientas de LangChain.

```python
import os
from langchain_mcp_adapters.client import MultiServerMCPClient

client = MultiServerMCPClient({
    "piqline": {
        "transport": "http",
        "url": "https://piqline.com/api/mcp",
        "headers": {"Authorization": f"Bearer {os.environ['PIQLINE_API_KEY']}"},
    }
})
tools = await client.get_tools()
```

Fuente: [github.com](https://github.com/langchain-ai/langchain-mcp-adapters), consultada el 20 nov 2026 (bloque de la documentación oficial). Probado con una clave real el 2026-11-20.

### Google ADK

**Dónde:** Python

Un toolset MCP para un agente de ADK.

```python
import os
from google.adk.tools.mcp_tool import McpToolset, StreamableHTTPConnectionParams

piqline = McpToolset(connection_params=StreamableHTTPConnectionParams(
    url="https://piqline.com/api/mcp",
    headers={"Authorization": f"Bearer {os.environ['PIQLINE_API_KEY']}"},
))
```

Fuente: [adk.dev](https://adk.dev/tools-custom/mcp-tools/), consultada el 20 nov 2026 (montado a partir de la documentación oficial). Aún no probado aquí con una clave real.

### n8n

**Dónde:** Nodo «MCP Client Tool» de un agente de IA

Pega la URL del servidor, elige el transporte HTTP y la autenticación «Bearer», y pega tu clave.

```text
https://piqline.com/api/mcp
```

Fuente: [docs.n8n.io](https://docs.n8n.io/integrations/builtin/cluster-nodes/sub-nodes/n8n-nodes-langchain.toolmcp/), consultada el 20 nov 2026 (montado a partir de la documentación oficial). Aún no probado aquí con una clave real.

### CrewAI

**Dónde:** Python

CrewAI se conecta por Streamable HTTP; su documentación no muestra ninguna cabecera. Usa el relé mcp-remote o LangChain.

Consulta el relé [mcp-remote](#mcp-remote-any-local-client).

Fuente: [docs.crewai.com](https://docs.crewai.com/en/mcp/streamable-http), consultada el 20 nov 2026 (cabeceras sin documentar, se recomienda el relé). Aún no probado aquí con una clave real.

### LlamaIndex

**Dónde:** Python

LlamaIndex se conecta a un servidor HTTP; su documentación no muestra ninguna cabecera. Usa el relé mcp-remote.

Consulta el relé [mcp-remote](#mcp-remote-any-local-client).

Fuente: [developers.llamaindex.ai](https://developers.llamaindex.ai/python/framework/module_guides/mcp/llamaindex_mcp/), consultada el 20 nov 2026 (cabeceras sin documentar, se recomienda el relé). Aún no probado aquí con una clave real.

## Cualquier otro cliente

### mcp-remote (any local client)

**Dónde:** El archivo de configuración MCP de tu cliente

Para un cliente que solo habla con un proceso local (stdio): `mcp-remote` retransmite el servidor HTTP. El valor de la cabecera va en `env`, sin espacios en los argumentos (algunos clientes dividen por espacios).

```json
{
  "mcpServers": {
    "piqline": {
      "command": "npx",
      "args": ["mcp-remote", "https://piqline.com/api/mcp", "--transport", "http-only", "--header", "Authorization:${AUTH_HEADER}"],
      "env": { "AUTH_HEADER": "Bearer piq_live_…" }
    }
  }
}
```

Fuente: [github.com](https://github.com/geelen/mcp-remote), consultada el 20 nov 2026 (montado a partir de la documentación oficial). Probado con una clave real el 2026-11-20.
