MCP Server

Easiest path (UI): Open Claude Desktop → Settings → Connectors → Add custom connector. Name it AlgoVault. URL: https://api.algovault.com/mcp?src=docs. Add Authorization: Bearer av_live_… as a custom header (paid tier). Save and restart Claude Desktop.

JSON path: Edit ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) or %APPDATA%\Claude\claude_desktop_config.json (Windows):

{
  "mcpServers": {
    "algovault": {
      "command": "npx",
      "args": ["-y", "mcp-remote", "https://api.algovault.com/mcp?src=docs",
               "--header", "Authorization: Bearer ${AV_API_KEY}",
               "--header", "X-AlgoVault-Track-Token:chan-docs"]
    }
  }
}

Set AV_API_KEY in the env block or your shell. Free tier: drop the Authorization header, but keep the X-AlgoVault-Track-Token header.

Verify: ask Claude "Get me a trade call for BTC on the 1h timeframe". Tool indicator appears bottom-right of the input box.

Edit ~/.cursor/mcp.json (global, all projects) or .cursor/mcp.json in the project root (per-project, commit-friendly):

{
  "mcpServers": {
    "algovault": {
      "url": "https://api.algovault.com/mcp?src=docs",
      "headers": {
        "Authorization": "Bearer ${env:AV_API_KEY}",
        "X-AlgoVault-Track-Token": "chan-docs"
      }
    }
  }
}

Set AV_API_KEY in your shell. Restart Cursor. The Cursor agent now has AlgoVault tools available while editing strategy code.

Open the Cline panel in VSCode → MCP Servers → Remote Servers tab → Add server. Or edit cline_mcp_settings.json (path varies by OS; access via Configure MCP Servers):

{
  "mcpServers": {
    "algovault": {
      "type": "streamableHttp",
      "url": "https://api.algovault.com/mcp?src=docs",
      "headers": {
        "Authorization": "Bearer ${env:AV_API_KEY}",
        "X-AlgoVault-Track-Token": "chan-docs"
      },
      "disabled": false,
      "autoApprove": []
    }
  }
}

type: "streamableHttp" is the modern transport (recommended). The legacy "sse" type still works but is being deprecated upstream.

One-liner (recommended):

claude mcp add --transport http --scope project algovault https://api.algovault.com/mcp?src=docs \
  --header "Authorization: Bearer $AV_API_KEY" \
  --header "X-AlgoVault-Track-Token:chan-docs"

This writes a .mcp.json in your repo root which you can commit so every teammate gets the same MCP config:

{
  "mcpServers": {
    "algovault": {
      "type": "http",
      "url": "https://api.algovault.com/mcp?src=docs",
      "headers": {
        "Authorization": "Bearer ${AV_API_KEY}",
        "X-AlgoVault-Track-Token": "chan-docs"
      }
    }
  }
}

Verify: in Claude Code, run /mcp to list connected servers; AlgoVault should appear with its tools.

The Smithery CLI installs and configures the MCP server in your client of choice automatically:

# Pick one — replace <client> with: claude, cursor, cline, claude-code
npx -y @smithery/cli install crypto-quant-signal-mcp --client <client>

The CLI writes the right config file for your client and prompts for any required env vars (like AV_API_KEY for paid-tier access). Easiest path if you're new to MCP. Browse the AlgoVault listing at smithery.ai.

For non-MCP integrations (bots, scripts, services), call the JSON-RPC endpoint directly. The transport is stateless, so a single POST of tools/call works: no initialize, no session id. See Testing with raw HTTP / curl for the one-shot call, the two Accept types you must send, and the optional session handshake.

One-shot smoke (free tier, no auth):

curl -sS https://api.algovault.com/health

Returns {"status":"ok","version":"1.10.3","stripe":true}.

Codex reads MCP servers from ~/.codex/config.toml. Add a table for AlgoVault:

[mcp_servers.algovault]
url = "https://api.algovault.com/mcp?src=docs"
bearer_token_env_var = "AV_API_KEY"

[mcp_servers.algovault.http_headers]
"X-AlgoVault-Track-Token" = "chan-docs"

Set AV_API_KEY in your shell for paid tier; drop bearer_token_env_var for free tier. Note that codex mcp add covers local stdio servers only, so remote HTTP servers are configured in the file.

IDE extension: open settings, choose MCP servers, add a server, pick Streamable HTTP and paste the same URL.

Verify: ask Codex "Get me a trade call for BTC on the 1h timeframe".

Edit ~/.kimi-code/mcp.json (user level) or .kimi-code/mcp.json (project level). An entry carrying a url and no transport is an HTTP server:

{
  "mcpServers": {
    "algovault": {
      "url": "https://api.algovault.com/mcp?src=docs",
      "bearerTokenEnvVar": "AV_API_KEY",
      "headers": {
        "X-AlgoVault-Track-Token": "chan-docs"
      }
    }
  }
}

Prefer the guided path? Run /mcp-config in the TUI to add, edit or delete servers without touching the JSON.

Verify: ask Kimi "Get me a trade call for BTC on the 1h timeframe".

Open Settings → MCP Servers, then click New MCP Server at the top right. Choose HTTP as the type and enter:

https://api.algovault.com/mcp?src=docs

For paid tier, expand Headers (optional) and add Authorization: Bearer av_live_…. Free tier needs no header.

ZCode also accepts a pasted config block under Full configuration, in either the {"mcpServers": {…}} or the bare {"server-name": {…}} shape.

Verify: ask ZCode "Get me a trade call for BTC on the 1h timeframe".

Two steps: add the plugin, then patch the profile. pnpm must be on PATH — the CLI forwards to it.

dsh plugin --profile <name> add @deepseek-ai/[email protected]

The version is pinned on purpose. npm’s latest tag still points at 0.0.1-rc.1, which is BSD-3-Clause; MIT starts at 0.1.0-rc.2.

Then edit ~/.dsh/profiles/<name>/cordis.patch.yml, or ~/.dsh/cordis.patch.yml for every profile:

- insert:
    - id: mcp-algovault
      name: '@deepseek-ai/dsh-mcp-client'
      config:
        serverName: algovault
        transport: streamable-http
        url: https://api.algovault.com/mcp?src=deepseek_harness
        headers:
          X-AlgoVault-Track-Token: int-deepseek-harness

The - insert: wrapper is required. Without it the entry is an id-targeted override, and it is skipped with a warning.

Paid tier adds one more line to that headers block: Authorization: Bearer av_live_…. The free tier needs no key.

The tools arrive server-qualified — mcp__algovault__get_trade_call, mcp__algovault__scan_trade_calls, and the rest.

DSH bridges tools only. MCP resources and prompts are deferred upstream, so read the track record at algovault.com/track-record instead.

Verify: ask dsh "Get me a trade call for BTC on the 1h timeframe".

Verified against @deepseek-ai/dsh-mcp-client 0.1.1-rc.2 on 2026-08-28. DSH ships prereleases only; expect compatibility-breaking changes.

Z.ai dials the MCP server itself, so there is nothing to install locally. Declare AlgoVault as a tool on the request:

{
  "model": "glm-4.6",
  "messages": [{"role": "user", "content": "Trade call for BTC on the 1h timeframe"}],
  "tools": [{
    "type": "mcp",
    "mcp": {
      "server_label": "algovault",
      "server_url": "https://api.algovault.com/mcp?src=docs",
      "headers": {"X-AlgoVault-Track-Token": "chan-docs"}
    }
  }]
}

server_label is required. transport_type is optional and already defaults to streamable-http, so it is omitted above. Add allowed_tools to narrow the tool set.

DeepSeek’s own harness connects to AlgoVault directly — see the DeepSeek Harness tutorial. This row is the other path: keep the harness you already run and swap the model behind it. The DeepSeek API itself still exposes no MCP parameter, so the harness carries the tools.

export ANTHROPIC_BASE_URL="https://api.deepseek.com/anthropic"
export ANTHROPIC_AUTH_TOKEN="$DEEPSEEK_API_KEY"

claude mcp add --transport http --scope project algovault \
  https://api.algovault.com/mcp?src=docs \
  --header "X-AlgoVault-Track-Token:chan-docs"

Claude Code then runs against DeepSeek while AlgoVault stays connected exactly as it would otherwise. Verdicts are unchanged: they are computed on our side and handed back as JSON.

Harnesses that speak the OpenAI protocol instead use the plain https://api.deepseek.com base, not the /anthropic one shown here.