← Back to directory
D

DeepSeek MCP Server

Community
Community MCP server for DeepSeek V4 with chat, reasoning, function calling, and cost tracking.
Category
Dev Tools #74 of 438
Stars
★ 26 Popular
Transport
stdio (local process) · Streamable HTTP
Runtime
Node.js 20+ · Docker · Hosted (no local runtime)
Credentials
API key / credential required
License
MIT
Last commit
Tools
3
63FMRS · C

A feature-rich, well-documented community MCP server for DeepSeek with dual V4 models, session management, schema-validated JSON, cost tracking, and circuit-breaker fallback, backed by ~89% test coverage. Ideal for developers integrating DeepSeek into MCP workflows, though note it is unofficial and self-hosted HTTP mode requires careful endpoint security.

Strongest · Documentation 17/20 Weakest · Reliability 9/20

Reliability
9/20
Security and permissions
13/20
Maintenance
11/20
Documentation
17/20
Setup experience
13/20
Why each score
Reliability 9/20
The README's described tool set (deepseek_chat/deepseek_fim/deepseek_sessions), resources (deepseek://models/config/usage), and file layout are internally consistent, and error-handling design (circuit breaker, model fallback, retries, schema-repair retries) is described in reasonable detail. However, this is a purely static review — no actual CI workflow file or test source was provided, so the claimed '280 tests, ~89% coverage' and CI badge are unverified self-reported claims, and the real MCP init/tool-list handshake cannot be confirmed to work. Per the calibration rule, without verifiable execution evidence reliability is capped at 12; scored 9 given the claims are plausible but entirely unproven.
Security and permissions 13/20
Credential handling looks reasonable: DEEPSEEK_API_KEY is marked required/secret, self-hosted HTTP mode defaults to loopback binding, and the docs require HTTP_AUTH_TOKEN plus HTTP_ALLOWED_HOSTS (DNS-rebinding protection) before exposing 0.0.0.0, with Docker examples also publishing to localhost only — a least-privilege-oriented default. No destructive operations, unconfirmed remote command execution, or hardcoded real secrets were found. Deduction: the manifest's hosted remote endpoint (deepseek-mcp.tahirl.com) requires users to send their DeepSeek API key as a Bearer token to a third-party-operated Cloudflare Worker; the README's claim of 'no server-side key storage' is an unverifiable, self-reported assertion with no way to confirm the third party's actual data handling, logging, or forwarding behavior. Session isolation and ReDoS-guard claims are likewise unverifiable from static material. This falls short of a red line but represents a real, unproven trust/data-boundary dependency, so a high score is not warranted.
Maintenance 11/20
MIT licensed, not archived, manifest shows version 2.3.0, and the README references a CHANGELOG.md and CONTRIBUTING.md, indicating some versioning and contribution process. However, with only 17 stars against 10 open issues, the issue density is relatively high, and there is no verifiable evidence of recent commit cadence, release frequency, or a security-response channel; the project appears to be maintained by a single individual (@arikusi) with thin governance. Lack of verifiable ongoing-maintenance evidence caps this at a middling score.
Documentation 17/20
Documentation is comprehensive: install paths (local/remote/Docker), auth methods, per-tool parameters and response shapes, limits (e.g., FIM's 4096-token output cap, message length limits), a cost/pricing table, a troubleshooting section, and multi-client config examples are all present, along with disclosure of deprecated aliases, HTTP session-isolation scope, and ReDoS mitigation. Deduction: some security/quality claims ('no key stored on remote endpoint,' '89% coverage') are self-reported assertions rather than independently verifiable evidence, even though they are disclosed.
Setup experience 13/20
Multiple clear installation paths are offered — local stdio via npx, a no-install remote BYOK endpoint, manual config, and Docker — with concrete command examples for Claude Code, Gemini CLI, Cursor/Windsurf/VS Code, and clearly stated prerequisites (Node 20+). Per the static-review calibration rule, without verifiable CI/test evidence that these install paths are automatically validated, setup ease is capped at 15; scored 13 reflecting strong documented clarity offset by the lack of proof these paths actually work end-to-end.

Static review · not runListed 2026-09-07

Read the FMRS scoring method →

Fit and risk

What it can accessUses the network

Best for

  • Developers using MCP clients such as Claude Code, Gemini CLI, Cursor, or Windsurf
  • Users who want DeepSeek V4 models inside their local agent tooling
  • Teams that need cost tracking and usage statistics
  • Users wanting a hosted BYOK endpoint with no installation

Not for

  • Users seeking official DeepSeek support channels (this is community-maintained)
  • Users without a DeepSeek API key
  • Users needing other LLM providers such as OpenAI or Anthropic

Required permissions

  • DEEPSEEK_API_KEY environment variable (secret) is required
  • API usage costs billed via your DeepSeek API key
  • Self-hosted HTTP mode requires an open network port (binds 127.0.0.1 by default)

Risks and side effects

  • If the HTTP endpoint is exposed, anyone who can reach POST /mcp can spend your API key; set HTTP_AUTH_TOKEN when binding 0.0.0.0
  • Thinking mode can exceed 30 seconds and client tool-call timeouts may interrupt long requests
  • Costs accrue per request and grow with usage
  • Deprecated model aliases deepseek-chat/deepseek-reasoner will be removed in the next major release

Setup

Before you start

Runtime:Node.js 20+ · Docker · Hosted (no local runtime)

DEEPSEEK_API_KEY requiredsecret DeepSeek API key, required; get one at https://platform.deepseek.com.
HTTP_AUTH_TOKEN optionalsecret Static gateway token for the self-hosted HTTP endpoint; when set, POST /mcp requires Bearer auth.
Other optional settings (19)
DEEPSEEK_BASE_URL optional Custom DeepSeek API endpoint, defaults to https://api.deepseek.com.
DEFAULT_MODEL optional Default model for requests, defaults to deepseek-v4-flash.
SHOW_COST_INFO optional Whether to show cost info in responses, default true.
REQUEST_TIMEOUT optional Request timeout in milliseconds, default 60000.
MAX_RETRIES optional Maximum retries for failed requests, default 2.
SKIP_CONNECTION_TEST optional Skip the startup API connection test, default false.
MAX_MESSAGE_LENGTH optional Maximum message content length in characters, default 100000.
SESSION_TTL_MINUTES optional Session time-to-live in minutes, default 30.
MAX_SESSIONS optional Maximum number of concurrent sessions, default 100.
FALLBACK_ENABLED optional Enable automatic model fallback on errors, default true.
CIRCUIT_BREAKER_THRESHOLD optional Consecutive failures before the circuit opens, default 5.
CIRCUIT_BREAKER_RESET_TIMEOUT optional Milliseconds before the circuit half-opens, default 30000.
MAX_SESSION_MESSAGES optional Max messages per session (sliding window), default 200.
RESPONSE_SCHEMA_MAX_RETRIES optional Repair retries when response_schema validation fails, default 2, 0 disables.
ENABLE_MULTIMODAL optional Enable multimodal (image) input support, default false.
TRANSPORT optional Transport mode: stdio or http, default stdio.
HTTP_PORT optional HTTP server port when TRANSPORT=http, default 3000.
HTTP_HOST optional Bind address for HTTP transport, default 127.0.0.1.
HTTP_ALLOWED_HOSTS optional Comma-separated allowed Host headers for DNS rebinding protection when binding to 0.0.0.0.

Requires Node.js 20+ and a DeepSeek API key (from platform.deepseek.com). Claude Code local: claude mcp add -s user deepseek npx @arikusi/deepseek-mcp-server -e DEEPSEEK_API_KEY=your-key-here. Gemini CLI: gemini mcp add deepseek npx @arikusi/deepseek-mcp-server -e DEEPSEEK_API_KEY=your-key-here. Or use the hosted endpoint (no install): claude mcp add --transport http deepseek https://deepseek-mcp.tahirl.com/mcp --header "Authorization: Bearer YOUR_DEEPSEEK_API_KEY".

.mcp.json
{"mcpServers":{"deepseek":{"command":"npx","args":["@arikusi/deepseek-mcp-server"],"env":{"DEEPSEEK_API_KEY":"your-api-key-here"}}}}

Shown for Claude Code. Other clients may use a different file or key (VS Code uses "servers") — the configurator below converts it.

.vscode/mcp.json
{
  "servers": {
    "deepseek": {
      "command": "npx",
      "args": [
        "@arikusi/deepseek-mcp-server"
      ],
      "env": {
        "DEEPSEEK_API_KEY": "your-api-key-here"
      }
    }
  }
}

Goes in your project's .vscode/mcp.json (VS Code uses a "servers" key).

Terminal
claude mcp add deepseek -e DEEPSEEK_API_KEY=your-api-key-here -- npx @arikusi/deepseek-mcp-server

Run it in a terminal; replace any <…> placeholders with your own values first.

Check that it works

After install, the client's tool list should show deepseek_chat, deepseek_fim, and deepseek_sessions; asking a question answered by DeepSeek with token and cost info in the response confirms the connection works.

Troubleshooting

  1. DEEPSEEK_API_KEY not set: ensure the add command includes the -e flag or add the key in your config file's env section
  2. Failed to connect to DeepSeek API: check key validity, internet connection, and status.deepseek.com
  3. Server not appearing in your MCP client: verify the dist/index.js path, run npm run build, and fully restart the client
  4. Permission denied on macOS/Linux: run chmod +x dist/index.js

Things to try

Once connected, you can ask your AI assistant things like:

  • Use DeepSeek to explain quantum computing in simple terms
  • Use deepseek-v4-pro with thinking enabled to prove that the square root of 2 is irrational
  • Use deepseek_fim to fill in the missing middle of this Python code between my prefix and suffix
  • List all my DeepSeek sessions, then delete the session with session_id my-session-1

Tools 3

deepseek_chat read-only
Chat with DeepSeek models with function calling, thinking mode, JSON output, schema validation, multi-turn sessions, and automatic cost tracking.
deepseek_fim read-only
Fill-in-the-Middle completion: given a prefix and optional suffix, the model completes the text in between, built for code completion and content infilling.
deepseek_sessions writes
Manage conversation sessions: list, delete, or clear multi-turn sessions.

Use cases

Complex reasoning and math proofs with deepseek-v4-pro
Step-by-step debugging and code review with thinking mode
Schema-validated structured JSON output
Code completion via fill-in-the-middle
Multi-turn conversations with cost tracking

Supported clients

Claude Code
Gemini CLI
Cursor
Windsurf
VS Code

Listed from the project's documentation, not tested by this site.

Overview

DeepSeek MCP Server is a community-maintained, MIT-licensed MCP server for accessing DeepSeek V4 models (deepseek-v4-flash and deepseek-v4-pro), both with a 1M-token context window and optional chain-of-thought thinking mode. It provides multi-turn sessions, function calling (up to 128 tool definitions), JSON output with schema validation, fill-in-the-middle (FIM) completion, cache-aware cost tracking, automatic model fallback with circuit breaker protection, 12 prompt templates, and 3 MCP resources (models, config, usage). It runs via npm (stdio) or a hosted BYOK endpoint (Streamable HTTP), and works with Claude Code, Gemini CLI, Cursor, Windsurf, and other MCP clients. Note: this is an independent community project, not an official DeepSeek product.

Similar servers

Context7 80 · B

Upstash's official server providing up-to-date third-party library docs for AI coding assistants

★ 63.3k · Tools 2 Compare with this →

Source revision 1bac160857d5 Data synced 2026-10-19 Read the FMRS scoring method