# Connecter votre client

> Brancher Piqline depuis Claude, ChatGPT, Codex, Cursor, VS Code, Gemini CLI, Zed, Mistral Le Chat, Copilot Studio, n8n, LangChain, le SDK Vercel et tout autre client MCP : un bloc à copier par client.

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

Piqline a deux serveurs MCP, tous deux en Streamable HTTP :

| Serveur | Adresse | Authentification |
| --- | --- | --- |
| Complet | `https://piqline.com/api/mcp` | clé API en en-tête `Authorization: Bearer …` |
| Porte ouverte | `https://piqline.com/api/open/mcp` | aucune : ce que Piqline peut faire, et ses données publiques |

La clé se crée dans un compte gratuit, Réglages → API et MCP. Gardez-la dans une variable d’environnement `PIQLINE_API_KEY` plutôt que dans un fichier partagé.

| Client | Éditeur | Clé en en-tête |
| --- | --- | --- |
| [Claude (claude.ai, Claude Desktop)](#claude-claude-ai-claude-desktop) | Anthropic | oui |
| [ChatGPT](#chatgpt) | OpenAI | non, porte ouverte seulement |
| [Mistral Le Chat](#mistral-le-chat) | Mistral AI | oui |
| [Microsoft Copilot Studio](#microsoft-copilot-studio) | Microsoft | oui |
| [Claude Code](#claude-code) | Anthropic | oui |
| [Codex CLI](#codex-cli) | OpenAI | oui |
| [Gemini CLI](#gemini-cli) | Google | oui |
| [Cursor](#cursor) | Anysphere | oui |
| [VS Code (GitHub Copilot)](#vs-code-github-copilot) | Microsoft | oui |
| [Zed](#zed) | Zed Industries | oui |
| [Cline](#cline) | Cline | oui |
| [Roo Code](#roo-code) | Roo Code | oui |
| [Continue](#continue) | Continue | oui |
| [Windsurf](#windsurf) | Cognition | par le relais |
| [JetBrains AI Assistant](#jetbrains-ai-assistant) | JetBrains | par le relais |
| [Goose](#goose) | Block | par le relais |
| [Claude API (Messages)](#claude-api-messages) | Anthropic | oui |
| [OpenAI Responses API](#openai-responses-api) | OpenAI | oui |
| [OpenAI Agents SDK](#openai-agents-sdk) | OpenAI | oui |
| [Vercel AI SDK](#vercel-ai-sdk) | Vercel | oui |
| [LangChain / LangGraph](#langchain-langgraph) | LangChain | oui |
| [Google ADK](#google-adk) | Google | oui |
| [n8n](#n8n) | n8n | oui |
| [CrewAI](#crewai) | CrewAI | par le relais |
| [LlamaIndex](#llamaindex) | LlamaIndex | par le relais |
| [mcp-remote (any local client)](#mcp-remote-any-local-client) | Open source | oui |

## Assistants et applications

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

**Où** : Réglages › Connecteurs › Ajouter un connecteur personnalisé

Collez l’adresse du serveur, puis dans « En-têtes de requête » ajoutez `Authorization` avec la valeur `Bearer` suivie de votre clé. Sans clé, l’adresse de la porte ouverte marche avec « Pas de connexion ».

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

Sur les offres Team et Enterprise, un en-tête posé sur le connecteur vaut pour tous les membres : créez une clé dédiée, plafonnée.

Source : [support.claude.com](https://support.claude.com/en/articles/11175166), lue le 20 nov. 2026 (bloc de la documentation officielle). Pas encore essayé ici avec une vraie clé.

### ChatGPT

**Où** : Réglages › Applications › Mode développeur › Créer

ChatGPT n’accepte pas de clé en en-tête : seulement OAuth ou aucune authentification. Branchez aujourd’hui la porte ouverte, sans clé ; le serveur complet arrive avec la connexion par compte Piqline.

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

Source : [developers.openai.com](https://developers.openai.com/apps-sdk/build/auth), lue le 20 nov. 2026 (bloc de la documentation officielle). Pas encore essayé ici avec une vraie clé.

### Mistral Le Chat

**Où** : Connecteurs › Ajouter un connecteur MCP (administrateur)

Collez l’adresse du serveur et choisissez l’authentification par jeton Bearer, puis collez votre clé.

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

Source : [docs.mistral.ai](https://docs.mistral.ai/le-chat/knowledge-integrations/connectors/mcp-connectors), lue le 20 nov. 2026 (assemblé depuis la documentation officielle). Pas encore essayé ici avec une vraie clé.

### Microsoft Copilot Studio

**Où** : Agent › Outils › Ajouter un outil › Nouvel outil › Model Context Protocol

Collez l’adresse du serveur, choisissez « Clé API », emplacement « En-tête », nom `Authorization`. À la connexion, saisissez `Bearer` suivi de votre clé.

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

Source : [learn.microsoft.com](https://learn.microsoft.com/en-us/microsoft-copilot-studio/mcp-add-existing-server-to-agent), lue le 20 nov. 2026 (assemblé depuis la documentation officielle). Pas encore essayé ici avec une vraie clé.

## Agents de code et éditeurs

### Claude Code

**Où** : Terminal

Une commande. Ajoutez `--scope project` pour l’écrire dans `.mcp.json` et la partager avec l’équipe.

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

Source : [code.claude.com](https://code.claude.com/docs/en/mcp), lue le 20 nov. 2026 (bloc de la documentation officielle). Essayé avec une vraie clé le 2026-11-20.

### Codex CLI

**Où** : ~/.codex/config.toml

Codex lit la clé dans une variable d’environnement : exportez `PIQLINE_API_KEY`, puis ajoutez le serveur à la configuration.

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

Source : [learn.chatgpt.com](https://learn.chatgpt.com/docs/extend/mcp?surface=cli), lue le 20 nov. 2026 (bloc de la documentation officielle). Pas encore essayé ici avec une vraie clé.

### Gemini CLI

**Où** : Terminal ou ~/.gemini/settings.json

Une commande, ou le bloc dans `settings.json`. La clé `httpUrl` désigne le transport HTTP (`url` désignerait l’ancien SSE).

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

Source : [geminicli.com](https://geminicli.com/docs/tools/mcp-server/), lue le 20 nov. 2026 (bloc de la documentation officielle). Essayé avec une vraie clé le 2026-11-20.

### Cursor

**Où** : ~/.cursor/mcp.json ou .cursor/mcp.json

Le bloc lit la clé dans une variable d’environnement.

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

Source : [cursor.com](https://cursor.com/docs/context/mcp), lue le 20 nov. 2026 (bloc de la documentation officielle). Pas encore essayé ici avec une vraie clé.

### VS Code (GitHub Copilot)

**Où** : .vscode/mcp.json

VS Code demande la clé à la première connexion et la garde dans son coffre. Le format `.vscode/mcp.json` est annoncé comme remplacé en février 2027 par un `.mcp.json` à la racine, au format 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}" }
    }
  }
}
```

Source : [code.visualstudio.com](https://code.visualstudio.com/docs/agents/reference/mcp-configuration), lue le 20 nov. 2026 (assemblé depuis la documentation officielle). Pas encore essayé ici avec une vraie clé.

### Zed

**Où** : settings.json de Zed

Ajoutez le serveur dans `context_servers`.

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

Source : [zed.dev](https://zed.dev/docs/ai/mcp), lue le 20 nov. 2026 (bloc de la documentation officielle). Pas encore essayé ici avec une vraie clé.

### Cline

**Où** : cline_mcp_settings.json

Le champ `type` est obligatoire : sans lui, Cline retombe sur l’ancien SSE.

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

Source : [docs.cline.bot](https://docs.cline.bot/mcp/configuring-mcp-servers), lue le 20 nov. 2026 (bloc de la documentation officielle). Pas encore essayé ici avec une vraie clé.

### Roo Code

**Où** : .roo/mcp.json

Ajoutez le serveur au fichier du projet.

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

Source : [roocodeinc.github.io](https://roocodeinc.github.io/Roo-Code/features/mcp/using-mcp-in-roo), lue le 20 nov. 2026 (bloc de la documentation officielle). Pas encore essayé ici avec une vraie clé.

### Continue

**Où** : config.yaml de Continue

La clé reste dans les secrets de Continue.

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

Source : [docs.continue.dev](https://docs.continue.dev/reference), lue le 20 nov. 2026 (assemblé depuis la documentation officielle). Pas encore essayé ici avec une vraie clé.

### Windsurf

**Où** : ~/.codeium/windsurf/mcp_config.json

Windsurf accepte le transport HTTP et des en-têtes. Si votre version refuse ce bloc, utilisez le relais mcp-remote plus bas.

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

Source : [docs.devin.ai](https://docs.devin.ai/desktop/cascade/mcp), lue le 20 nov. 2026 (en-têtes non documentés, relais conseillé). Pas encore essayé ici avec une vraie clé.

### JetBrains AI Assistant

**Où** : Réglages › Outils › AI Assistant › Model Context Protocol

La documentation ne montre pas d’en-tête pour un serveur distant : passez par le relais mcp-remote plus bas.

Voir le relais [mcp-remote](#mcp-remote-any-local-client).

Source : [www.jetbrains.com](https://www.jetbrains.com/help/ai-assistant/mcp.html), lue le 20 nov. 2026 (en-têtes non documentés, relais conseillé). Pas encore essayé ici avec une vraie clé.

### Goose

**Où** : goose configure › Ajouter une extension › Distante

Ajoutez une extension distante en HTTP avec l’adresse du serveur et l’en-tête `Authorization`. Sinon, le relais mcp-remote plus bas.

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

Source : [goose-docs.ai](https://goose-docs.ai/docs/getting-started/using-extensions), lue le 20 nov. 2026 (en-têtes non documentés, relais conseillé). Pas encore essayé ici avec une vraie clé.

## API et cadres d’agents

### Claude API (Messages)

**Où** : Requête à l’API Messages

Le connecteur MCP de l’API appelle Piqline pour le modèle. La clé passe dans `authorization_token`. Reportez-vous à la page source pour l’en-tête bêta en vigueur.

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

Source : [platform.claude.com](https://platform.claude.com/docs/en/agents-and-tools/mcp-connector), lue le 20 nov. 2026 (bloc de la documentation officielle). Pas encore essayé ici avec une vraie clé.

### OpenAI Responses API

**Où** : Outil `mcp` d’une requête Responses

La clé passe dans `headers`.

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

Source : [developers.openai.com](https://developers.openai.com/api/reference/resources/responses/methods/create), lue le 20 nov. 2026 (bloc de la documentation officielle). Pas encore essayé ici avec une vraie clé.

### OpenAI Agents SDK

**Où** : Python

Un serveur Streamable HTTP avec l’en-tête.

```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']}"},
})
```

Source : [openai.github.io](https://openai.github.io/openai-agents-python/mcp/), lue le 20 nov. 2026 (bloc de la documentation officielle). Essayé avec une vraie clé le 2026-11-20.

### Vercel AI SDK

**Où** : TypeScript

Le client MCP donne les outils à `generateText` ou `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();
```

Source : [ai-sdk.dev](https://ai-sdk.dev/docs/ai-sdk-core/mcp-tools), lue le 20 nov. 2026 (bloc de la documentation officielle). Essayé avec une vraie clé le 2026-11-20.

### LangChain / LangGraph

**Où** : Python

Les outils Piqline deviennent des outils 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()
```

Source : [github.com](https://github.com/langchain-ai/langchain-mcp-adapters), lue le 20 nov. 2026 (bloc de la documentation officielle). Essayé avec une vraie clé le 2026-11-20.

### Google ADK

**Où** : Python

Un jeu d’outils MCP pour un agent 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']}"},
))
```

Source : [adk.dev](https://adk.dev/tools-custom/mcp-tools/), lue le 20 nov. 2026 (assemblé depuis la documentation officielle). Pas encore essayé ici avec une vraie clé.

### n8n

**Où** : Nœud « MCP Client Tool » d’un agent IA

Collez l’adresse du serveur, transport HTTP, authentification « Bearer », puis votre clé.

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

Source : [docs.n8n.io](https://docs.n8n.io/integrations/builtin/cluster-nodes/sub-nodes/n8n-nodes-langchain.toolmcp/), lue le 20 nov. 2026 (assemblé depuis la documentation officielle). Pas encore essayé ici avec une vraie clé.

### CrewAI

**Où** : Python

CrewAI se branche en Streamable HTTP ; la documentation ne montre pas d’en-tête. Passez par le relais mcp-remote, ou par LangChain.

Voir le relais [mcp-remote](#mcp-remote-any-local-client).

Source : [docs.crewai.com](https://docs.crewai.com/en/mcp/streamable-http), lue le 20 nov. 2026 (en-têtes non documentés, relais conseillé). Pas encore essayé ici avec une vraie clé.

### LlamaIndex

**Où** : Python

LlamaIndex se branche sur un serveur HTTP ; la documentation ne montre pas d’en-tête. Passez par le relais mcp-remote.

Voir le relais [mcp-remote](#mcp-remote-any-local-client).

Source : [developers.llamaindex.ai](https://developers.llamaindex.ai/python/framework/module_guides/mcp/llamaindex_mcp/), lue le 20 nov. 2026 (en-têtes non documentés, relais conseillé). Pas encore essayé ici avec une vraie clé.

## Tout autre client

### mcp-remote (any local client)

**Où** : Le fichier de configuration MCP de votre client

Pour un client qui ne parle qu’à un processus local (stdio) : `mcp-remote` relaie le serveur HTTP. La valeur de l’en-tête est dans `env`, sans espace dans les arguments (certains clients coupent sur les espaces).

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

Source : [github.com](https://github.com/geelen/mcp-remote), lue le 20 nov. 2026 (assemblé depuis la documentation officielle). Essayé avec une vraie clé le 2026-11-20.
