Endpoint des serveurs MCP

QAnswer sert les serveurs MCP distants qui y sont configurés comme des endpoints MCP standard, en Streamable HTTP. Tout client MCP — Claude Code, Cursor, VS Code, un SDK MCP — peut alors utiliser les outils d'un serveur avec une clé API QAnswer : QAnswer vérifie la clé et transmet chaque appel au serveur.

C'est l'équivalent MCP de l'endpoint Chat Completions, qui fait de même pour les fournisseurs de LLM.

Endpoint

Chaque serveur a sa propre URL, qui se termine par l'identifiant du serveur. L'onglet API du serveur dans QAnswer l'affiche, prête à copier.

POST https://app.qanswer.ai/backend/api/v1/mcp/YOUR_SERVER_UID

Authentification

Envoyez une clé API QAnswer avec chaque requête, dans l'un de ces en-têtes :

Authorization: Bearer <clé> — l'en-tête qu'envoient les clients MCP par défaut.
QAnswer-Api-Key: <clé>

Créez une clé sur la page API Access. Votre offre doit inclure l'accès à l'API.

La clé reste dans QAnswer : elle n'est jamais envoyée au serveur MCP.

Les serveurs qu'une clé atteint

Une clé d'utilisateur, d'équipe ou d'organisation atteint tous les serveurs MCP que son propriétaire peut utiliser dans QAnswer.
Une clé liée à un serveur MCP n'atteint que ce serveur. Une telle clé se crée par l'API, avec POST /api/api-key/resource/mcp/{id}, par quelqu'un qui peut au moins lire le serveur.
Une clé liée à un assistant IA ou à un fournisseur LM est refusée.
Seuls les serveurs dont l'authentification est réglée sur None sont servis : un serveur réglé sur API Key ou OAuth répond 400.
Les serveurs intégrés de QAnswer — Web, Image Generation, Code Execution, Document Search, Assistants et Zimbra — fonctionnent à l'intérieur de QAnswer et ne sont jamais servis ici.

Connecter un client

Remplacez l'URL par celle de l'onglet API du serveur, et YOUR_API_KEY par votre clé.

Dans claude_desktop_config.json (Settings → Developer → Edit Config), via mcp-remote, qui tourne sur votre machine et relaie vers l'endpoint. Il faut Node.js 18 ou plus récent ; redémarrez Claude Desktop après l'enregistrement :

{
  "mcpServers": {
    "qanswer-my-server": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "https://app.qanswer.ai/backend/api/v1/mcp/YOUR_SERVER_UID",
        "--header",
        "Authorization:${AUTH_HEADER}"
      ],
      "env": { "AUTH_HEADER": "Bearer YOUR_API_KEY" }
    }
  }
}

Dans un terminal. Ajoutez --scope user pour utiliser le serveur dans tous les projets :

claude mcp add --transport http qanswer-my-server "https://app.qanswer.ai/backend/api/v1/mcp/YOUR_SERVER_UID" \
  --header "Authorization: Bearer YOUR_API_KEY"

Dans ~/.cursor/mcp.json, ou .cursor/mcp.json dans un projet ; redémarrez Cursor après l'enregistrement :

{
  "mcpServers": {
    "qanswer-my-server": {
      "url": "https://app.qanswer.ai/backend/api/v1/mcp/YOUR_SERVER_UID",
      "headers": { "Authorization": "Bearer YOUR_API_KEY" }
    }
  }
}

Pour GitHub Copilot dans VS Code, dans ~/.copilot/mcp-config.json, ou .mcp.json à la racine de l'espace de travail :

{
  "mcpServers": {
    "qanswer-my-server": {
      "type": "http",
      "url": "https://app.qanswer.ai/backend/api/v1/mcp/YOUR_SERVER_UID",
      "headers": { "Authorization": "Bearer YOUR_API_KEY" },
      "tools": ["*"]
    }
  }
}

Dans un terminal. -s user ajoute le serveur à ~/.gemini/settings.json, pour tous les projets :

gemini mcp add -s user --transport http \
  --header "Authorization: Bearer YOUR_API_KEY" qanswer-my-server "https://app.qanswer.ai/backend/api/v1/mcp/YOUR_SERVER_UID"

Avec la version 2 du package officiel mcp :

# pip install "mcp>=2"
import asyncio

import httpx2
from mcp import Client
from mcp.client.streamable_http import streamable_http_client

URL = "https://app.qanswer.ai/backend/api/v1/mcp/YOUR_SERVER_UID"
HEADERS = {"Authorization": "Bearer YOUR_API_KEY"}


async def main() -> None:
    async with httpx2.AsyncClient(
        headers=HEADERS, timeout=httpx2.Timeout(30.0, read=300.0)
    ) as http:
        async with Client(streamable_http_client(URL, http_client=http)) as client:
            result = await client.list_tools()
            for tool in result.tools:
                print(tool.name, "-", tool.description)
            # result = await client.call_tool("TOOL_NAME", {"argument": "value"})


asyncio.run(main())

Avec la version 2 du SDK TypeScript officiel de MCP, sous Node.js :

// npm install @modelcontextprotocol/client
// an ES module: save as client.mjs, then run node client.mjs
import {
  Client,
  StreamableHTTPClientTransport,
} from '@modelcontextprotocol/client'

const transport = new StreamableHTTPClientTransport(new URL('https://app.qanswer.ai/backend/api/v1/mcp/YOUR_SERVER_UID'), {
  requestInit: { headers: { Authorization: 'Bearer YOUR_API_KEY' } },
})
const client = new Client({ name: 'my-app', version: '1.0.0' })

await client.connect(transport)
const { tools } = await client.listTools()
for (const tool of tools) console.log(tool.name, '-', tool.description)
// const result = await client.callTool({ name: 'TOOL_NAME', arguments: { argument: 'value' } })
await client.close()

curl -X POST "https://app.qanswer.ai/backend/api/v1/mcp/YOUR_SERVER_UID" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc": "2.0", "id": 1, "method": "tools/list"}'

curl -X POST "https://app.qanswer.ai/backend/api/v1/mcp/YOUR_SERVER_UID" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc": "2.0", "id": 2, "method": "tools/call", "params": {"name": "TOOL_NAME", "arguments": {}}}'

Limites

Uniquement des outils : les ressources, les prompts et les complétions ne sont pas proposés.
Les outils proposés sont ceux synchronisés dans QAnswer et activés par le propriétaire du serveur, avec les descriptions définies dans QAnswer.
L'endpoint est sans état et répond en JSON : pas de session, pas de flux d'événements, pas de notifications de progression. Un appel d'outil répond une fois que le serveur MCP a répondu.
Le réglage de demande de confirmation de QAnswer ne s'applique qu'à son propre chat ; l'approbation des appels d'outils revient à votre client.
Les appels d'outils ne consomment pas de crédits.
Les clients qui ne se connectent aux serveurs distants qu'avec OAuth, comme ChatGPT, ne peuvent pas utiliser l'endpoint, qui attend une clé API statique.

Erreurs

Les problèmes liés à la requête sont des erreurs HTTP. Les problèmes d'un appel isolé reviennent dans une réponse 200 normale, pour que le client garde sa connexion.

401 / 403 — pas de clé, une clé invalide ou expirée, une clé liée à une autre ressource, ou pas d'accès au serveur
404 — aucun serveur avec cet identifiant
400 — un serveur intégré, un serveur qui exige une authentification, un corps qui n'est pas un unique message JSON-RPC, ou un en-tête MCP-Protocol-Version non pris en charge
200, JSON-RPC -32601 — une méthode autre que initialize, ping, tools/list et tools/call
200, JSON-RPC -32602 — des paramètres invalides, ou un outil que le serveur ne propose pas
200, isError — l'outil a échoué, ou le serveur MCP est injoignable

Endpoint des serveurs MCP#

Endpoint#

Authentification#

Les serveurs qu'une clé atteint#

Connecter un client#

Limites#

Erreurs#