Serveur MCP | DEUNA Docs

Sur cette page

Point de terminaison
Connectez-vous en deux minutes
Claude Code
Claude Desktop et claude.ai
Curseur
VS Code (copilote GitHub)
Planche à voile
CLI du Codex
CLI Gémeaux
Autres agents
Vérifier le serveur
Dépannage

DEUNA Docs expose une télécommande Protocole de contexte de modèle serveur. Ajoutez-le à votre agent et il pourra rechercher et lire cette documentation pendant qu'il écrit votre intégration.

Point de terminaison#

MCP endpointPlain text

https://docs.deuna.com/api/mcp

Transports : HTTP diffusable (POST seulement, apatride).
Authentification : aucun. Le serveur lit uniquement la documentation publique.
Outils : search_docs classe les pages de documentation ; get_doc renvoie la source Markdown d’une page ; search_api_reference recherche dans l’inventaire complet des endpoints publics ; get_api_endpoint renvoie le contrat publié pour une méthode HTTP et un chemin précis ; et search_provider_capabilities recherche dans le catalogue généré des fournisseurs.

L'URL ci-dessus est créée à partir de l'hôte que vous parcourez, elle correspond donc toujours à l'environnement qui dessert cette page.

Connectez-vous en deux minutes#

Copiez l’endpoint affiché ci-dessus.
Ajoutez-le à votre client IA en tant que serveur HTTP Streamable distant nommé deuna-docs.
Activez les cinq outils de documentation DEUNA en lecture seule lorsque votre client demande votre approbation.
Posez une question sur la documentation, par exemple « Comment créer une commande ? ». Votre client doit appeler search_docs ou search_api_reference avant de répondre.

Vous n’avez besoin ni d’une API key DEUNA ni d’un token ATHIA. Le serveur MCP expose uniquement le corpus de documentation publié et n’accepte jamais les identifiants d’un client MCP.

Claude Code#

Exécutez ceci une fois. Ajouter --scope user pour le rendre disponible dans chaque projet, ou --scope project pour le partager à travers .mcp.json.

TerminalShell

claude mcp add --transport http deuna-docs https://docs.deuna.com/api/mcp

Courir claude mcp list pour confirmer que le serveur est connecté.

Claude Desktop et claude.ai#

Ouvrez Paramètres › Connecteurs.
Sélectionnez Ajouter un connecteur personnalisé.
Nommez-le DEUNA Docs et collez l'URL :

Remote MCP server URLPlain text

https://docs.deuna.com/api/mcp

Curseur#

Ajoutez le serveur à ~/.cursor/mcp.json pour chaque projet, ou pour .cursor/mcp.json dans un seul référentiel.

~/.cursor/mcp.jsonJSON

{
  "mcpServers": {
    "deuna-docs": {
      "url": "https://docs.deuna.com/api/mcp"
    }
  }
}

Puis ouvrez Paramètres › MCP et vérifie ça deuna-docs est activé.

VS Code (copilote GitHub)#

Ajoutez le serveur à .vscode/mcp.json dans votre espace de travail, ou enregistrez-le depuis le terminal.

{
  "servers": {
    "deuna-docs": {
      "type": "http",
      "url": "https://docs.deuna.com/api/mcp"
    }
  }
}

code --add-mcp '{"name":"deuna-docs","type":"http","url":"https://docs.deuna.com/api/mcp"}'

Utilisez les outils de Copilot Chat dans Agent mode.

Planche à voile#

Ajoutez le serveur à ~/.codeium/windsurf/mcp_config.json, puis actualisez la liste MCP dans Cascade.

~/.codeium/windsurf/mcp_config.jsonJSON

{
  "mcpServers": {
    "deuna-docs": {
      "serverUrl": "https://docs.deuna.com/api/mcp"
    }
  }
}

CLI du Codex#

Enregistrez le serveur depuis le terminal ou ajoutez-le à ~/.codex/config.toml.

codex mcp add deuna-docs --url https://docs.deuna.com/api/mcp

[mcp_servers.deuna-docs]
url = "https://docs.deuna.com/api/mcp"

CLI Gémeaux#

Enregistrez le serveur depuis le terminal ou ajoutez-le à ~/.gemini/settings.json.

gemini mcp add --transport http deuna-docs https://docs.deuna.com/api/mcp

{
  "mcpServers": {
    "deuna-docs": {
      "httpUrl": "https://docs.deuna.com/api/mcp"
    }
  }
}

Courir /mcp dans Gemini CLI pour confirmer que les outils sont chargés.

Autres agents#

Tout client prenant en charge les serveurs MCP distants via Streamable HTTP peut se connecter à l'URL du point de terminaison. Les clients qui prennent uniquement en charge les serveurs locaux (stdio) peuvent utiliser mcp-remote comme pont : npx mcp-remote <endpoint>.

Vérifier le serveur#

Répertoriez les outils disponibles avec une requête JSON-RPC brute :

curl -X POST https://docs.deuna.com/api/mcp \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'

const response = await fetch("https://docs.deuna.com/api/mcp", {
  method: "POST",
  headers: {
    "Content-Type": "application/json",
    "Accept": "application/json, text/event-stream"
  },
  body: JSON.stringify({
    "jsonrpc": "2.0",
    "id": 1,
    "method": "tools/list"
  })
});

if (!response.ok) throw new Error(`Request failed: ${response.status}`);
const data = await response.json();

import requests

response = requests.request(
    "POST",
    "https://docs.deuna.com/api/mcp",
    headers={
        "Content-Type": "application/json",
        "Accept": "application/json, text/event-stream"
    },
    json={
          "jsonrpc": "2.0",
          "id": 1,
          "method": "tools/list"
        },
)
response.raise_for_status()
data = response.json()

<?php
$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://docs.deuna.com/api/mcp",
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_HTTPHEADER => [
    "Content-Type: application/json",
    "Accept: application/json, text/event-stream"
  ],
  CURLOPT_POSTFIELDS => json_encode([
      "jsonrpc" => "2.0",
      "id" => 1,
      "method" => "tools/list"
    ])
]);

$response = curl_exec($curl);
curl_close($curl);

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Example {
  public static void main(String[] args) throws Exception {
    HttpRequest request = HttpRequest.newBuilder()
      .uri(URI.create("https://docs.deuna.com/api/mcp"))
      .header("Content-Type", "application/json")
      .header("Accept", "application/json, text/event-stream")
      .method("POST", HttpRequest.BodyPublishers.ofString("{\"jsonrpc\":\"2.0\",\"id\":1,\"method\":\"tools/list\"}"))
      .build();

    HttpResponse<String> response = HttpClient.newHttpClient().send(
      request, HttpResponse.BodyHandlers.ofString()
    );
    System.out.println(response.body());
  }
}

package main

import (
  "fmt"
  "io"
  "net/http"
  "strings"
)

func main() {
  request, err := http.NewRequest("POST", "https://docs.deuna.com/api/mcp", strings.NewReader("{\"jsonrpc\":\"2.0\",\"id\":1,\"method\":\"tools/list\"}"))
  if err != nil { panic(err) }
  request.Header.Set("Content-Type", "application/json")
  request.Header.Set("Accept", "application/json, text/event-stream")

  response, err := http.DefaultClient.Do(request)
  if err != nil { panic(err) }
  defer response.Body.Close()

  body, _ := io.ReadAll(response.Body)
  fmt.Println(string(body))
}

Un serveur opérationnel renvoie les cinq outils en lecture seule pour la documentation, la référence API et les capacités des fournisseurs dans result.tools.

Dépannage#

Un onglet de navigateur affiche method_not_allowed: c’est le comportement attendu, car la navigation du navigateur utilise GET. Configurez l’URL dans un client MCP ou utilisez la POST requête de vérification ci-dessus.
Le client ne peut pas se connecter localement : exécutez npm run api avec le serveur de développement Docusaurus. Les pages locales dirigent volontairement les clients MCP vers http://localhost:3001/api/mcp.
Le client déployé signale une erreur de connexion : vérifiez que l’URL se termine par /api/mcp, utilise un accès HTTPS public et est accessible depuis le réseau du client. Le serveur est sans état ; aucun identifiant de session ne doit donc être conservé.
Le serveur répond, mais une question reste sans réponse : vérifiez que le client a activé les outils renvoyés. Le serveur indique volontairement que l’information n’est pas documentée au lieu de répondre à partir des connaissances générales du modèle.