MCP server | DEUNA Docs

On this page

Endpoint
Connect in two minutes
Claude Code
Claude Desktop and claude.ai
Cursor
VS Code (GitHub Copilot)
Windsurf
Codex CLI
Gemini CLI
Other agents
Verify the server
Troubleshooting

DEUNA Docs exposes a remote Model Context Protocol server. Add it to your agent and it can search and read this documentation while it writes your integration.

Endpoint#

MCP endpointPlain text

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

Transport: Streamable HTTP (POST only, stateless).
Authentication: none. The server only reads public documentation.
Tools: search_docs ranks documentation pages; get_doc returns a page’s Markdown source; search_api_reference searches the complete public endpoint inventory; get_api_endpoint returns the published contract for one exact HTTP method and path; and search_provider_capabilities searches the generated provider catalog.

The URL above is built from the host you are browsing, so it always matches the environment that serves this page.

Connect in two minutes#

Copy the endpoint shown above.
Add it to your AI client as a remote Streamable HTTP server named deuna-docs.
Enable the five read-only DEUNA documentation tools when your client asks for approval.
Ask a documentation question, such as “How do I create an order?” Your client should call search_docs or search_api_reference before answering.

You do not need a DEUNA API key or an ATHIA token. The MCP server exposes only the published documentation corpus and never accepts credentials from an MCP client.

Claude Code#

Run this once. Add --scope user to make it available in every project, or --scope project to share it through .mcp.json.

TerminalShell

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

Run claude mcp list to confirm the server is connected.

Claude Desktop and claude.ai#

Open Settings › Connectors.
Select Add custom connector.
Name it DEUNA Docs and paste the URL:

Remote MCP server URLPlain text

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

Cursor#

Add the server to ~/.cursor/mcp.json for every project, or to .cursor/mcp.json in a single repository.

~/.cursor/mcp.jsonJSON

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

Then open Settings › MCP and check that deuna-docs is enabled.

VS Code (GitHub Copilot)#

Add the server to .vscode/mcp.json in your workspace, or register it from the 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"}'

Use the tools from Copilot Chat in Agent mode.

Windsurf#

Add the server to ~/.codeium/windsurf/mcp_config.json, then refresh the MCP list in Cascade.

~/.codeium/windsurf/mcp_config.jsonJSON

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

Codex CLI#

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

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

Gemini CLI#

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

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

Run /mcp inside Gemini CLI to confirm the tools are loaded.

Other agents#

Any client that supports remote MCP servers over Streamable HTTP can connect with the endpoint URL. Clients that only support local (stdio) servers can use mcp-remote as a bridge: npx mcp-remote <endpoint>.

Verify the server#

List the available tools with a raw JSON-RPC request:

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))
}

A healthy server returns all five read-only documentation, API-reference, and provider-capability tools in result.tools.

Troubleshooting#

A browser tab shows method_not_allowed: this is expected because a browser navigation uses GET. Configure the URL in an MCP client or use the POST verification request above.
The client cannot connect locally: run npm run api alongside the Docusaurus development server. Local pages intentionally point MCP clients to http://localhost:3001/api/mcp.
The deployed client reports a connection error: verify that the URL ends in /api/mcp, uses public HTTPS, and is reachable from the client’s network. The server is stateless, so no session identifier needs to be preserved.
The server responds but a question has no answer: confirm the client enabled the returned tools. The server intentionally reports that information is not documented instead of answering from general model knowledge.