Power your agent
The publisher's own command. Not a PlugMCP endpoint.
Host a copy with our keys and logs.
npx -y @arikusi/[email protected]Claude Code has no install link for a local command. Copy the command below and run it in a terminal.
DEEPSEEK_API_KEY=<secret> claude mcp add io.github.arikusi-deepseek -- npx -y @arikusi/deepseek-mcp-server@2.4.0Run in a terminal.
{ "mcpServers": { "io.github.arikusi-deepseek": { "command": "npx", "args": [ "-y", "@arikusi/[email protected]" ], "env": { "DEEPSEEK_API_KEY": "<secret>" } } }}claude_desktop_config.json
Remote URL or a command on your machine? How the two installs differ
Run on PlugMCP
A new server you create. It is not this listing's official endpoint. Use the publisher install when you want their URL and their credentials.
LaunchFrom the publisher
Use the hosted endpoint directly — no npm install, no Node.js required. Bring your own DeepSeek API key:
Claude Code:
claude mcp add --transport http deepseek \
https://deepseek-mcp.tahirl.com/mcp \
--header "Authorization: Bearer YOUR_DEEPSEEK_API_KEY"
MCP server for DeepSeek AI with chat, reasoning, sessions, function calling, and cost tracking
Cursor / Windsurf / VS Code:
{
"mcpServers": {
"deepseek": {
"url": "https://deepseek-mcp.tahirl.com/mcp",
"headers": {
"Authorization": "Bearer ${DEEPSEEK_API_KEY}"
}
}
}
}
Claude Code:
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
Scope options (Claude Code):
-s user: Available in all your projects (recommended)-s local: Only in current project (default)-s project: Project-specific .mcp.json fileGet your API key: https://platform.deepseek.com
deepseek-v4-flash and deepseek-v4-pro, both with 1M context and optional chain-of-thought thinking modesession_id parameterdeepseek://models, deepseek://config, deepseek://usage — query model info, config, and usage statsthinking: {type: "enabled"}json_mode: trueresponse_schema and the server validates the output against it, with bounded repair retries and a ReDoS guard on schema patternsdeepseek_fim tooldeepseek_sessions toolENABLE_MULTIMODAL=true)deepseek-mcp.tahirl.com/mcp — BYOK (Bring Your Own Key), no install neededTRANSPORT=httpIf you prefer to install manually:
npm install -g @arikusi/deepseek-mcp-server
git clone https://github.com/arikusi/deepseek-mcp-server.git
cd deepseek-mcp-server
npm install
npm run build
Once configured, your MCP client will have access to deepseek_chat, deepseek_fim, and deepseek_sessions tools, plus 3 MCP resources.
Example prompts:
"Use DeepSeek to explain quantum computing"
"Ask DeepSeek Reasoner to solve: If I have 10 apples and buy 5 more..."
Your MCP client will automatically call the deepseek_chat tool.
If your MCP client doesn't support the add command, manually add to your config file:
{
"mcpServers": {
"deepseek": {
"command": "npx",
"args": ["@arikusi/deepseek-mcp-server"],
"env": {
"DEEPSEEK_API_KEY": "your-api-key-here"
}
}
}
}
Config file locations:
~/.claude.json (add to projects["your-project-path"].mcpServers section)deepseek_chatChat with DeepSeek AI models with automatic cost tracking and function calling support.
Parameters:
messages (required): Array of conversation messages
role: "system" | "user" | "assistant" | "tool"content: Message texttool_call_id (optional): Required for tool role messagesmodel (optional): "deepseek-v4-flash" (default) or "deepseek-v4-pro". The deprecated "deepseek-chat" and "deepseek-reasoner" aliases are still accepted and resolve to v4-flash (non-thinking / thinking); prefer the V4 names.temperature (optional): 0-2, controls randomness (default: 1.0). Ignored when thinking mode is enabled.max_tokens (optional): Maximum tokens to generate (V4 models support up to 384000)stream (optional): Enable streaming mode (default: false)tools (optional): Array of tool definitions for function calling (max 128)tool_choice (optional): "auto" | "none" | "required" | {type: "function", function: {name: "..."}}thinking (optional): Toggle thinking mode, {type: "enabled"} to reason or {type: "disabled"} for a fast answer (non-thinking is the default)reasoning_effort (optional): "high" (default) or "max", applies only while thinking mode is activejson_mode (optional): Enable JSON output mode (supported by both models)response_schema (optional): A JSON Schema to validate the model output against. Implies JSON output. The server validates the parsed result and, on failure, issues up to RESPONSE_SCHEMA_MAX_RETRIES repair retries (default 2, set 0 to disable) that feed the validation error back to the model. Schema regex patterns are screened for ReDoS and an unsafe pattern is rejected up front.session_id (optional): Session ID for multi-turn conversations. Previous context is automatically prepended.Response includes:
structuredContent.request: a self-contained per-request usage and cost summary (token counts, cache hit/miss, cost_usd), aggregated across any repair retriesstructuredContent.effective and fallback: what was actually sent after alias/thinking resolution, and any silent model fallback that firedstructuredContent.schema: when response_schema is used, {valid, attempts, error?}; json_parse_error when JSON output could not be recoveredExample:
{
"messages": [
{
"role": "user",
"content": "Explain the theory of relativity in simple terms"
}
],
"model": "deepseek-v4-flash",
"temperature": 0.7,
"max_tokens": 1000
}
Reasoning Example (v4-flash with thinking enabled):
{
"messages": [
{
"role": "user",
"content": "If I have 10 apples and eat 3, then buy 5 more, how many do I have?"
}
],
"model": "deepseek-v4-flash",
"thinking": { "type": "enabled" }
}
Thinking mode returns the chain-of-thought in <thinking> tags followed by the final answer.
DeepSeek V4 Pro Example (hardest tasks):
{
"messages": [
{
"role": "user",
"content": "Prove that the square root of 2 is irrational."
}
],
"model": "deepseek-v4-pro",
"thinking": { "type": "enabled" }
}
Function Calling Example:
{
"messages": [
{
"role": "user",
"content": "What's the weather in Istanbul?"
}
],
"tools": [
{
"type": "function",
"function": {
"name": "get_weather",
"description": "Get current weather for a location",
"parameters": {
"type": "object",
"properties": {
"location": {
"type": "string",
"description": "City name"
}
},
"required": ["location"]
}
}
}
],
"tool_choice": "auto"
}
When the model decides to call a function, the response includes tool_calls with the function name and arguments. You can then send the result back using a tool role message with the matching tool_call_id.
Thinking Mode Example:
{
"messages": [
{
"role": "user",
"content": "Analyze the time complexity of quicksort"
}
],
"model": "deepseek-v4-flash",
"thinking": { "type": "enabled" }
}
When thinking mode is enabled, temperature and top_p are automatically ignored.
JSON Output Mode Example:
{
"messages": [
{
"role": "user",
"content": "Return a json object with name, age, and city fields for a sample user"
}
],
"model": "deepseek-v4-flash",
"json_mode": true
}
JSON mode ensures the model outputs valid JSON. Include the word "json" in your prompt for best results. Supported by all models.
Schema-Validated JSON Example:
{
"messages": [
{
"role": "user",
"content": "Classify this review sentiment as json: \"Absolutely loved it\""
}
],
"model": "deepseek-v4-flash",
"response_schema": {
"type": "object",
"properties": {
"sentiment": { "type": "string", "enum": ["positive", "negative", "neutral"] },
"confidence": { "type": "number", "minimum": 0, "maximum": 1 }
},
"required": ["sentiment", "confidence"],
"additionalProperties": false
}
}
The server validates the parsed output against the schema. If it does not match, it retries up to RESPONSE_SCHEMA_MAX_RETRIES times (default 2), feeding the validation error back to the model, and returns the first schema-valid object. A persistent mismatch is surfaced as structuredContent.schema.valid = false rather than a silently coerced answer. Regex patterns in the schema are screened for catastrophic backtracking (ReDoS); an unsafe pattern is rejected up front as an invalid schema.
Multi-Turn Session Example:
{
"messages": [
{
"role": "user",
"content": "What is the capital of France?"
}
],
"session_id": "my-session-1"
}
Use the same session_id across requests to maintain conversation context. Messages are stored in memory and prepended automatically. In HTTP transport each connected MCP session has its own isolated session store — a session_id created by one HTTP client is not visible to another (see HTTP Transport below).
deepseek_fimFill-in-the-Middle completion. You give a prompt (the prefix) and an optional suffix, and the model completes the text in between. It is built for code completion and content infilling rather than conversation. FIM runs on DeepSeek's Beta endpoint in non-thinking mode, and the API caps output at 4096 tokens.
Parameters:
prompt (required): The prefix text before the gap. For code completion, this is the code up to the cursor.suffix (optional): The text after the gap. The model fills the space between prompt and suffix.model (optional): "deepseek-v4-flash" (default) or "deepseek-v4-pro". The deprecated "deepseek-chat" and "deepseek-reasoner" aliases are still accepted and resolve to v4-flash (FIM has no thinking mode).max_tokens (optional): Maximum tokens to generate, up to 4096.temperature (optional): 0-2, controls randomness (default: 1.0).stop (optional): A stop string or an array of up to 16 stop strings.Response includes:
text, usage, finish_reason, and cost_usd fieldsExample (code completion):
{
"prompt": "def fib(n):\n if n < 2:\n return n\n return ",
"suffix": "\n\nprint(fib(10))",
"model": "deepseek-v4-flash",
"max_tokens": 64
}
The model returns the missing middle, e.g. fib(n-1) + fib(n-2), using both the prefix and the suffix as context. Available on both the npm/stdio server and the hosted worker endpoint.
deepseek_sessionsManage conversation sessions.
Parameters:
action (required): "list" | "clear" | "delete"session_id (optional): Required when action is "delete"Examples:
{"action": "list"}
{"action": "delete", "session_id": "my-session-1"}
{"action": "clear"}
MCP Resources provide read-only data about the server:
When a model fails with a retryable error (429, 503, timeout), the server automatically falls back to the other model:
deepseek-v4-flash fails → tries deepseek-v4-prodeepseek-v4-pro fails → tries deepseek-v4-flashThe deprecated aliases (which resolve to v4-flash) fall back to deepseek-v4-pro.
The circuit breaker protects against cascading failures:
CIRCUIT_BREAKER_THRESHOLD consecutive failures (default: 5), the circuit opens (fast-fail mode)CIRCUIT_BREAKER_RESET_TIMEOUT ms (default: 30000), it enters half-open state and sends a probe requestFallback can be disabled with FALLBACK_ENABLED=false.
Prompt templates (12 total):
Each prompt is optimized for thinking mode (v4-flash with thinking: {type: "enabled"}) to provide detailed reasoning.
Both V4 models have a 1M-token context window, up to 384K output tokens, and support function calling, JSON mode, and optional chain-of-thought thinking. They are non-thinking by default here for fast responses; enable reasoning with thinking: {type: "enabled"}.
deepseek-chat and deepseek-reasoner are deprecated. They are still accepted and resolve to deepseek-v4-flash (chat = non-thinking, reasoner = thinking), so existing configs keep working, but they will be removed in the next major release. The DeepSeek API itself retired those two names on 2026-07-24; this server keeps translating them to V4 for you in the meantime. New setups should use deepseek-v4-flash or deepseek-v4-pro directly.
The server is configured via environment variables. All settings except DEEPSEEK_API_KEY are optional.
Example with custom config:
claude mcp add -s user deepseek npx @arikusi/deepseek-mcp-server \
-e DEEPSEEK_API_KEY=your-key \
-e SHOW_COST_INFO=false \
-e REQUEST_TIMEOUT=30000
deepseek-mcp-server/
├── worker/ # Cloudflare Worker (remote BYOK endpoint)
│ ├── src/index.ts # Worker entry point
│ ├── wrangler.toml # Cloudflare config
│ └── package.json
├── src/
│ ├── index.ts # Entry point, bootstrap
│ ├── server.ts # McpServer factory (auto-version)
│ ├── deepseek-client.ts # DeepSeek API wrapper (circuit breaker + fallback)
│ ├── config.ts # Centralized config with Zod validation
│ ├── cost.ts # Cost calculation and formatting
│ ├── schemas.ts # Zod input validation schemas
│ ├── types.ts # TypeScript types + type guards
│ ├── errors.ts # Custom error classes
│ ├── session.ts # In-memory session store (multi-turn)
│ ├── circuit-breaker.ts # Circuit breaker pattern
│ ├── usage-tracker.ts # Usage statistics tracker
│ ├── transport-http.ts # Streamable HTTP transport (Express)
│ ├── tools/
│ │ ├── deepseek-chat.ts # deepseek_chat tool (sessions + fallback)
│ │ ├── deepseek-fim.ts # deepseek_fim tool (fill-in-the-middle)
│ │ ├── deepseek-sessions.ts # deepseek_sessions tool
│ │ └── index.ts # Tool registration aggregator
│ ├── resources/
│ │ ├── models.ts # deepseek://models resource
│ │ ├── config.ts # deepseek://config resource
│ │ ├── usage.ts # deepseek://usage resource
│ │ └── index.ts # Resource registration aggregator
│ └── prompts/
│ ├── core.ts # 5 core reasoning prompts
│ ├── advanced.ts # 5 advanced prompts
│ ├── function-calling.ts # 2 function calling prompts
│ └── index.ts # Prompt registration aggregator
├── dist/ # Compiled JavaScript
├── llms.txt # AI discoverability index
├── llms-full.txt # Full docs for LLM context
├── vitest.config.ts # Test configuration
├── package.json
├── tsconfig.json
└── README.md
npm run build
npm run watch
# Run all tests
npm test
# Watch mode
npm run test:watch
# With coverage report
npm run test:coverage
# Set API key
export DEEPSEEK_API_KEY="your-key"
# Run the server
npm start
The server will start and wait for MCP client connections via stdio.
A hosted BYOK (Bring Your Own Key) endpoint is available at:
https://deepseek-mcp.tahirl.com/mcp
Send your DeepSeek API key as Authorization: Bearer <key>. No server-side API key stored — your key is used directly per request. Powered by Cloudflare Workers (global edge, zero cold start).
Note: Thinking mode may take over 30 seconds for complex queries. Some MCP clients (e.g. Claude Code) have built-in tool call timeouts that may interrupt long-running requests. When latency matters, the default non-thinking mode is recommended.
# Test health
curl https://deepseek-mcp.tahirl.com/health
# Test MCP (requires auth)
curl -X POST https://deepseek-mcp.tahirl.com/mcp \
-H "Content-Type: application/json" \
-H "Authorization: Bearer YOUR_KEY" \
-d '{"jsonrpc":"2.0","method":"initialize","params":{"capabilities":{}},"id":1}'
Run your own HTTP endpoint:
TRANSPORT=http HTTP_PORT=3000 DEEPSEEK_API_KEY=your-key node dist/index.js
Test the health endpoint:
curl http://localhost:3000/health
The MCP endpoint is available at POST /mcp (Streamable HTTP protocol).
Securing the endpoint (read before exposing it). In self-hosted HTTP mode the
server holds your DEEPSEEK_API_KEY and uses it for every deepseek_chat call.
Anyone who can reach POST /mcp can invoke tools and spend that key, so the
endpoint must not sit open on a public interface. The defaults are built around
this:
HTTP_HOST defaults to 127.0.0.1, so a plain run only listens on loopback and the SDK's DNS rebinding protection is active. Nothing off the machine can reach it.HTTP_HOST=0.0.0.0 and either HTTP_AUTH_TOKEN (so /mcp requires Authorization: Bearer <token>) or HTTP_ALLOWED_HOSTS. Binding 0.0.0.0 with neither turns the SDK's Host-header check off entirely, which leaves /mcp open to DNS rebinding from any web page you visit, so the server refuses to start rather than warn. HTTP_ALLOW_UNPROTECTED_BIND=true overrides the refusal if you really want an open endpoint.HTTP_ALLOWED_HOSTS to your real hostname(s).# Exposed deployment with a bearer token
TRANSPORT=http HTTP_HOST=0.0.0.0 HTTP_PORT=3000 \
HTTP_AUTH_TOKEN=$(openssl rand -hex 32) \
HTTP_ALLOWED_HOSTS=mcp.example.com \
DEEPSEEK_API_KEY=your-key node dist/index.js
# Calling it
curl -X POST http://mcp.example.com:3000/mcp \
-H "Authorization: Bearer YOUR_TOKEN" \
-H "Content-Type: application/json" \
-H "Accept: application/json, text/event-stream" \
-d '{"jsonrpc":"2.0","method":"initialize","params":{"capabilities":{}},"id":1}'
HTTP_AUTH_TOKEN is a static gateway token for the self-hosted endpoint and is
unrelated to your DeepSeek key. It is separate from the hosted BYOK endpoint
above, where clients pass their own DeepSeek key as the bearer.
Session isolation (1.7.0+): In HTTP transport each connected MCP session
gets its own McpServer instance and its own SessionStore. Conversation
history, session listings, and deletions are scoped to the MCP session that
created them, so one client cannot read, enumerate, or wipe another client's
sessions. STDIO transport is single-tenant by nature and unaffected.
# Build
docker build -t deepseek-mcp-server .
# Run, reachable only from the host's loopback, with a bearer token
docker run -d -p 127.0.0.1:3000:3000 \
-e DEEPSEEK_API_KEY=your-key \
-e HTTP_AUTH_TOKEN=your-token \
deepseek-mcp-server
# Or use docker-compose
DEEPSEEK_API_KEY=your-key HTTP_AUTH_TOKEN=your-token docker compose up -d
The image runs HTTP transport on port 3000 with a health check. Inside the
container it binds 0.0.0.0 (required for the port mapping to work), so control
exposure at the publish layer: the example above and the bundled
docker-compose.yml publish to 127.0.0.1 only.
Publishing on loopback is not on its own enough, because DNS rebinding targets
the loopback address your own browser can already reach. The image therefore
ships HTTP_ALLOWED_HOSTS=localhost,127.0.0.1,[::1], which keeps the Host
check installed. Publishing under a real hostname? Add it to that list, or every
request carrying it gets a 403. Publishing on a public interface? Set
HTTP_AUTH_TOKEN as well.
Option 1: Use the correct installation command
# Make sure to include -e flag with your API key
claude mcp add deepseek npx @arikusi/deepseek-mcp-server -e DEEPSEEK_API_KEY=your-key-here
Option 2: Manually edit the config file
If you already installed without the API key, edit your config file:
~/.claude.json (Windows: C:\Users\USERNAME\.claude.json)"mcpServers" section under your project pathenv field with your API key:"deepseek": {
"type": "stdio",
"command": "npx",
"args": ["@arikusi/deepseek-mcp-server"],
"env": {
"DEEPSEEK_API_KEY": "your-api-key-here"
}
}
dist/index.js is correctnpm run buildMake the file executable:
chmod +x dist/index.js
To share this MCP server with others:
npm loginnpm publish --access publicUsers can then install with:
npm install -g @arikusi/deepseek-mcp-server
Contributions are welcome! Please read our Contributing Guidelines before submitting PRs.
Found a bug or have a feature request? Please open an issue using our templates.
# Clone the repo
git clone https://github.com/arikusi/deepseek-mcp-server.git
cd deepseek-mcp-server
# Install dependencies
npm install
# Build in watch mode
npm run watch
# Run tests
npm test
# Lint
npm run lint
See CHANGELOG.md for version history and updates.
MIT License - see LICENSE file for details
Made by @arikusi
An independent, community-maintained MCP server for the DeepSeek API.
© 2026 MCP Directory.
MCP server for DeepSeek AI with chat, reasoning, sessions, function calling, and cost tracking
{ "mcpServers": { "io.github.arikusi-deepseek": { "command": "npx", "args": [ "-y", "@arikusi/[email protected]" ], "env": { "DEEPSEEK_API_KEY": "<secret>" } } }}Tools
No tool list yet. Remote servers get one after the first health check.
FAQ
Copy the stdio config for Cursor, Claude Desktop, Claude Code, or VS Code on this page. It uses the publisher's install, not a PlugMCP proxy.
The publisher lists these environment variables: DEEPSEEK_API_KEY.
Deepseek runs locally over stdio.
Last checked 2026-11-09. MCP server for DeepSeek AI with chat, reasoning, sessions, function calling, and cost tracking