# Client verbinden

> Piqline aus Claude, ChatGPT, Codex, Cursor, VS Code, Gemini CLI, Zed, Mistral Le Chat, Copilot Studio, n8n, LangChain, dem Vercel SDK und jedem anderen MCP-Client verbinden: ein Block zum Kopieren pro Client.

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

Piqline hat zwei MCP-Server, beide über Streamable HTTP:

| Server | URL | Authentifizierung |
| --- | --- | --- |
| Vollständig | `https://piqline.com/api/mcp` | API-Schlüssel im Header `Authorization: Bearer …` |
| Offene Tür | `https://piqline.com/api/open/mcp` | keine: was Piqline kann und seine öffentlichen Daten |

Erstellen Sie den Schlüssel in einem kostenlosen Konto unter Einstellungen → API und MCP. Bewahren Sie ihn in der Umgebungsvariable `PIQLINE_API_KEY` auf statt in einer gemeinsam genutzten Datei.

| Client | Anbieter | Schlüssel im Header |
| --- | --- | --- |
| [Claude (claude.ai, Claude Desktop)](#claude-claude-ai-claude-desktop) | Anthropic | ja |
| [ChatGPT](#chatgpt) | OpenAI | nein, nur offene Tür |
| [Mistral Le Chat](#mistral-le-chat) | Mistral AI | ja |
| [Microsoft Copilot Studio](#microsoft-copilot-studio) | Microsoft | ja |
| [Claude Code](#claude-code) | Anthropic | ja |
| [Codex CLI](#codex-cli) | OpenAI | ja |
| [Gemini CLI](#gemini-cli) | Google | ja |
| [Cursor](#cursor) | Anysphere | ja |
| [VS Code (GitHub Copilot)](#vs-code-github-copilot) | Microsoft | ja |
| [Zed](#zed) | Zed Industries | ja |
| [Cline](#cline) | Cline | ja |
| [Roo Code](#roo-code) | Roo Code | ja |
| [Continue](#continue) | Continue | ja |
| [Windsurf](#windsurf) | Cognition | über das Relay |
| [JetBrains AI Assistant](#jetbrains-ai-assistant) | JetBrains | über das Relay |
| [Goose](#goose) | Block | über das Relay |
| [Claude API (Messages)](#claude-api-messages) | Anthropic | ja |
| [OpenAI Responses API](#openai-responses-api) | OpenAI | ja |
| [OpenAI Agents SDK](#openai-agents-sdk) | OpenAI | ja |
| [Vercel AI SDK](#vercel-ai-sdk) | Vercel | ja |
| [LangChain / LangGraph](#langchain-langgraph) | LangChain | ja |
| [Google ADK](#google-adk) | Google | ja |
| [n8n](#n8n) | n8n | ja |
| [CrewAI](#crewai) | CrewAI | über das Relay |
| [LlamaIndex](#llamaindex) | LlamaIndex | über das Relay |
| [mcp-remote (any local client)](#mcp-remote-any-local-client) | Open source | ja |

## Assistenten und Apps

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

**Wo:** Einstellungen › Konnektoren › Benutzerdefinierten Konnektor hinzufügen

Fügen Sie die Server-URL ein und ergänzen Sie unter „Request headers“ `Authorization` mit dem Wert `Bearer` gefolgt von Ihrem Schlüssel. Ohne Schlüssel funktioniert die URL der offenen Tür mit „No sign in“.

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

In den Tarifen Team und Enterprise wird ein am Konnektor gesetzter Header von allen Mitgliedern geteilt: Erstellen Sie einen eigenen, begrenzten Schlüssel.

Quelle: [support.claude.com](https://support.claude.com/en/articles/11175166), gelesen am 20. Nov. 2026 (Block aus der offiziellen Dokumentation). Hier noch nicht mit einem echten Schlüssel getestet.

### ChatGPT

**Wo:** Einstellungen › Apps › Entwicklermodus › Erstellen

ChatGPT akzeptiert keinen Schlüssel in einem Header: nur OAuth oder keine Authentifizierung. Verbinden Sie heute die offene Tür ohne Schlüssel; der vollständige Server kommt mit der Anmeldung über ein Piqline-Konto.

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

Quelle: [developers.openai.com](https://developers.openai.com/apps-sdk/build/auth), gelesen am 20. Nov. 2026 (Block aus der offiziellen Dokumentation). Hier noch nicht mit einem echten Schlüssel getestet.

### Mistral Le Chat

**Wo:** Konnektoren › MCP-Konnektor hinzufügen (Admin)

Fügen Sie die Server-URL ein, wählen Sie die Authentifizierung per Bearer-Token und fügen Sie dann Ihren Schlüssel ein.

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

Quelle: [docs.mistral.ai](https://docs.mistral.ai/le-chat/knowledge-integrations/connectors/mcp-connectors), gelesen am 20. Nov. 2026 (aus der offiziellen Dokumentation zusammengesetzt). Hier noch nicht mit einem echten Schlüssel getestet.

### Microsoft Copilot Studio

**Wo:** Agent › Tools › Tool hinzufügen › Neues Tool › Model Context Protocol

Fügen Sie die Server-URL ein, wählen Sie „API key“, Ort „Header“, Name `Authorization`. Geben Sie beim Verbinden `Bearer` gefolgt von Ihrem Schlüssel ein.

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

Quelle: [learn.microsoft.com](https://learn.microsoft.com/en-us/microsoft-copilot-studio/mcp-add-existing-server-to-agent), gelesen am 20. Nov. 2026 (aus der offiziellen Dokumentation zusammengesetzt). Hier noch nicht mit einem echten Schlüssel getestet.

## Coding-Agenten und Editoren

### Claude Code

**Wo:** Terminal

Ein Befehl. Mit `--scope project` wird er in `.mcp.json` geschrieben und mit dem Team geteilt.

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

Quelle: [code.claude.com](https://code.claude.com/docs/en/mcp), gelesen am 20. Nov. 2026 (Block aus der offiziellen Dokumentation). Am 2026-11-20 mit einem echten Schlüssel getestet.

### Codex CLI

**Wo:** ~/.codex/config.toml

Codex liest den Schlüssel aus einer Umgebungsvariable: Exportieren Sie `PIQLINE_API_KEY` und fügen Sie dann den Server zur Konfiguration hinzu.

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

Quelle: [learn.chatgpt.com](https://learn.chatgpt.com/docs/extend/mcp?surface=cli), gelesen am 20. Nov. 2026 (Block aus der offiziellen Dokumentation). Hier noch nicht mit einem echten Schlüssel getestet.

### Gemini CLI

**Wo:** Terminal oder ~/.gemini/settings.json

Ein Befehl oder der Block in `settings.json`. Der Schlüssel `httpUrl` wählt den HTTP-Transport (`url` würde das veraltete SSE bedeuten).

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

Quelle: [geminicli.com](https://geminicli.com/docs/tools/mcp-server/), gelesen am 20. Nov. 2026 (Block aus der offiziellen Dokumentation). Am 2026-11-20 mit einem echten Schlüssel getestet.

### Cursor

**Wo:** ~/.cursor/mcp.json oder .cursor/mcp.json

Der Block liest den Schlüssel aus einer Umgebungsvariable.

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

Quelle: [cursor.com](https://cursor.com/docs/context/mcp), gelesen am 20. Nov. 2026 (Block aus der offiziellen Dokumentation). Hier noch nicht mit einem echten Schlüssel getestet.

### VS Code (GitHub Copilot)

**Wo:** .vscode/mcp.json

VS Code fragt beim ersten Verbinden nach dem Schlüssel und legt ihn in seinem Secret-Speicher ab. Das Format `.vscode/mcp.json` soll im Februar 2027 durch eine `.mcp.json` im Stammverzeichnis im Format von Claude Code ersetzt werden.

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

Quelle: [code.visualstudio.com](https://code.visualstudio.com/docs/agents/reference/mcp-configuration), gelesen am 20. Nov. 2026 (aus der offiziellen Dokumentation zusammengesetzt). Hier noch nicht mit einem echten Schlüssel getestet.

### Zed

**Wo:** Zed settings.json

Fügen Sie den Server unter `context_servers` hinzu.

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

Quelle: [zed.dev](https://zed.dev/docs/ai/mcp), gelesen am 20. Nov. 2026 (Block aus der offiziellen Dokumentation). Hier noch nicht mit einem echten Schlüssel getestet.

### Cline

**Wo:** cline_mcp_settings.json

Das Feld `type` ist erforderlich: Ohne es fällt Cline auf das veraltete SSE zurück.

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

Quelle: [docs.cline.bot](https://docs.cline.bot/mcp/configuring-mcp-servers), gelesen am 20. Nov. 2026 (Block aus der offiziellen Dokumentation). Hier noch nicht mit einem echten Schlüssel getestet.

### Roo Code

**Wo:** .roo/mcp.json

Fügen Sie den Server zur Projektdatei hinzu.

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

Quelle: [roocodeinc.github.io](https://roocodeinc.github.io/Roo-Code/features/mcp/using-mcp-in-roo), gelesen am 20. Nov. 2026 (Block aus der offiziellen Dokumentation). Hier noch nicht mit einem echten Schlüssel getestet.

### Continue

**Wo:** Continue config.yaml

Der Schlüssel bleibt in den Secrets von Continue.

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

Quelle: [docs.continue.dev](https://docs.continue.dev/reference), gelesen am 20. Nov. 2026 (aus der offiziellen Dokumentation zusammengesetzt). Hier noch nicht mit einem echten Schlüssel getestet.

### Windsurf

**Wo:** ~/.codeium/windsurf/mcp_config.json

Windsurf akzeptiert den HTTP-Transport und Header. Lehnt Ihre Version diesen Block ab, nutzen Sie das Relay mcp-remote weiter unten.

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

Quelle: [docs.devin.ai](https://docs.devin.ai/desktop/cascade/mcp), gelesen am 20. Nov. 2026 (Header nicht dokumentiert, Relay empfohlen). Hier noch nicht mit einem echten Schlüssel getestet.

### JetBrains AI Assistant

**Wo:** Einstellungen › Tools › AI Assistant › Model Context Protocol

Die Dokumentation zeigt keinen Header für einen Remote-Server: Nutzen Sie das Relay mcp-remote weiter unten.

Siehe das Relay [mcp-remote](#mcp-remote-any-local-client).

Quelle: [www.jetbrains.com](https://www.jetbrains.com/help/ai-assistant/mcp.html), gelesen am 20. Nov. 2026 (Header nicht dokumentiert, Relay empfohlen). Hier noch nicht mit einem echten Schlüssel getestet.

### Goose

**Wo:** goose configure › Add extension › Remote

Fügen Sie eine HTTP-Remote-Extension mit der Server-URL und dem Header `Authorization` hinzu. Andernfalls nutzen Sie das Relay mcp-remote weiter unten.

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

Quelle: [goose-docs.ai](https://goose-docs.ai/docs/getting-started/using-extensions), gelesen am 20. Nov. 2026 (Header nicht dokumentiert, Relay empfohlen). Hier noch nicht mit einem echten Schlüssel getestet.

## APIs und Agenten-Frameworks

### Claude API (Messages)

**Wo:** Anfrage an die Messages API

Der MCP-Konnektor der API ruft Piqline für das Modell auf. Der Schlüssel kommt in `authorization_token`. Den aktuellen Beta-Header finden Sie auf der Quellseite.

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

Quelle: [platform.claude.com](https://platform.claude.com/docs/en/agents-and-tools/mcp-connector), gelesen am 20. Nov. 2026 (Block aus der offiziellen Dokumentation). Hier noch nicht mit einem echten Schlüssel getestet.

### OpenAI Responses API

**Wo:** Tool `mcp` einer Responses-Anfrage

Der Schlüssel kommt in `headers`.

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

Quelle: [developers.openai.com](https://developers.openai.com/api/reference/resources/responses/methods/create), gelesen am 20. Nov. 2026 (Block aus der offiziellen Dokumentation). Hier noch nicht mit einem echten Schlüssel getestet.

### OpenAI Agents SDK

**Wo:** Python

Ein Streamable-HTTP-Server mit dem Header.

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

Quelle: [openai.github.io](https://openai.github.io/openai-agents-python/mcp/), gelesen am 20. Nov. 2026 (Block aus der offiziellen Dokumentation). Am 2026-11-20 mit einem echten Schlüssel getestet.

### Vercel AI SDK

**Wo:** TypeScript

Der MCP-Client übergibt die Tools an `generateText` oder `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();
```

Quelle: [ai-sdk.dev](https://ai-sdk.dev/docs/ai-sdk-core/mcp-tools), gelesen am 20. Nov. 2026 (Block aus der offiziellen Dokumentation). Am 2026-11-20 mit einem echten Schlüssel getestet.

### LangChain / LangGraph

**Wo:** Python

Piqline-Tools werden zu LangChain-Tools.

```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()
```

Quelle: [github.com](https://github.com/langchain-ai/langchain-mcp-adapters), gelesen am 20. Nov. 2026 (Block aus der offiziellen Dokumentation). Am 2026-11-20 mit einem echten Schlüssel getestet.

### Google ADK

**Wo:** Python

Ein MCP-Toolset für einen ADK-Agenten.

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

Quelle: [adk.dev](https://adk.dev/tools-custom/mcp-tools/), gelesen am 20. Nov. 2026 (aus der offiziellen Dokumentation zusammengesetzt). Hier noch nicht mit einem echten Schlüssel getestet.

### n8n

**Wo:** Node „MCP Client Tool“ eines KI-Agenten

Fügen Sie die Server-URL ein, wählen Sie den HTTP-Transport und die Authentifizierung „Bearer“ und fügen Sie dann Ihren Schlüssel ein.

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

Quelle: [docs.n8n.io](https://docs.n8n.io/integrations/builtin/cluster-nodes/sub-nodes/n8n-nodes-langchain.toolmcp/), gelesen am 20. Nov. 2026 (aus der offiziellen Dokumentation zusammengesetzt). Hier noch nicht mit einem echten Schlüssel getestet.

### CrewAI

**Wo:** Python

CrewAI verbindet sich über Streamable HTTP; seine Dokumentation zeigt keinen Header. Nutzen Sie das Relay mcp-remote oder LangChain.

Siehe das Relay [mcp-remote](#mcp-remote-any-local-client).

Quelle: [docs.crewai.com](https://docs.crewai.com/en/mcp/streamable-http), gelesen am 20. Nov. 2026 (Header nicht dokumentiert, Relay empfohlen). Hier noch nicht mit einem echten Schlüssel getestet.

### LlamaIndex

**Wo:** Python

LlamaIndex verbindet sich mit einem HTTP-Server; seine Dokumentation zeigt keinen Header. Nutzen Sie das Relay mcp-remote.

Siehe das Relay [mcp-remote](#mcp-remote-any-local-client).

Quelle: [developers.llamaindex.ai](https://developers.llamaindex.ai/python/framework/module_guides/mcp/llamaindex_mcp/), gelesen am 20. Nov. 2026 (Header nicht dokumentiert, Relay empfohlen). Hier noch nicht mit einem echten Schlüssel getestet.

## Jeder andere Client

### mcp-remote (any local client)

**Wo:** Die MCP-Konfigurationsdatei Ihres Clients

Für einen Client, der nur mit einem lokalen Prozess (stdio) spricht: `mcp-remote` leitet an den HTTP-Server weiter. Der Wert des Headers steht in `env`, ohne Leerzeichen in den Argumenten (manche Clients trennen an Leerzeichen).

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

Quelle: [github.com](https://github.com/geelen/mcp-remote), gelesen am 20. Nov. 2026 (aus der offiziellen Dokumentation zusammengesetzt). Am 2026-11-20 mit einem echten Schlüssel getestet.
