Which integrations are available for this server?

Allows using Google Gemini models as the backend for the MCP server tools by setting the DEEPSEEK_BASE_URL to the Gemini API endpoint. Allows using local models served by Ollama as the backend for the MCP server tools by setting the DEEPSEEK_BASE_URL to the Ollama API endpoint.

How do I use deepseek-mcp?

1. Click on "Install Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@deepseek-mcp Classify README.md, pyproject.toml, and server.py as doc, code, or config in JSON." That's it! The server will respond to your query, and you can continue using it as needed. Here is a step-by-step guide with screenshots.

deepseek-mcp

by arizen-dev

Overview Schema Related Servers Score Discussions

Python

Remote

deepseek-mcp

MIT License Python 3.10+ test

Use DeepSeek from Claude Code, Codex, or any MCP-compatible client as a small, cheap supervised worker.

deepseek-mcp is a tiny stdio MCP server with two tools:

deepseek(prompt, system?)     — fast, cheap, non-thinking (flash)
advise(prompt, system?, effort?) — deep reasoning (pro + thinking)

It is built for bounded tasks where another model can reduce mechanical load:

classify inboxes, tickets, logs, notes, or docs;
summarize packets;
turn messy text into JSON or tables;
populate templates;
generate first-pass mechanical edits;
produce reviewable candidate output for a human or primary agent.

It is not built for autonomous architecture, security policy, final client prose, or decisions where the hard part is judgment.

Quickstart

1. Install

Zero-install with uvx:

DEEPSEEK_API_KEY="sk-..." uvx deepseek-mcp-server

Or install persistently:

pip install "git+https://github.com/arizen-dev/deepseek-mcp.git"

Or clone and install locally:

git clone https://github.com/arizen-dev/deepseek-mcp.git
cd deepseek-mcp
pip install -e .

2. Add your DeepSeek key

Create an API key at:

https://platform.deepseek.com/api_keys

Then export it:

export DEEPSEEK_API_KEY="sk-..."

For Claude Code, the lowest-friction setup is to put the key in your global settings:

{
  "env": {
    "DEEPSEEK_API_KEY": "sk-..."
  }
}

Path:

~/.claude/settings.json

MCP servers are started when the client launches, so restart Claude Code or Codex after changing env/config.

3. Configure MCP

If you installed via pip (or uvx), use the installed command directly:

{
  "mcpServers": {
    "deepseek": {
      "command": "deepseek-mcp-server",
      "args": [],
      "env": {
        "DEEPSEEK_API_KEY": "${DEEPSEEK_API_KEY}"
      }
    }
  }
}

If you cloned the repo, point to the script directly:

{
  "mcpServers": {
    "deepseek": {
      "command": "python3",
      "args": ["/absolute/path/to/deepseek-mcp/deepseek_mcp_server.py"],
      "env": {
        "DEEPSEEK_API_KEY": "${DEEPSEEK_API_KEY}"
      }
    }
  }
}

After restart, /mcp should show a deepseek server.

In Claude Code, the tool names are:

mcp__deepseek__deepseek     — flash (fast, mechanical)
mcp__deepseek__advise       — pro  (deep reasoning)

Related MCP server: DeepSeek MCP Server

Codex

For Codex, add a global MCP server in ~/.codex/config.toml:

[mcp_servers.deepseekWorker]
command = "deepseek-mcp-server"
args = []

[mcp_servers.deepseekWorker.env]
DEEPSEEK_API_KEY = "sk-..."

Codex TOML does not expand "${DEEPSEEK_API_KEY}" in the same way Claude project MCP configs do. Put the key directly in the TOML env block or use whatever secret mechanism your Codex environment supports.

Demo

Prompt:

Classify these files into doc / code / config. Return JSON only:
- README.md
- pyproject.toml
- src/deepseek_mcp/server.py

Example output:

[
  {"file": "README.md", "type": "doc"},
  {"file": "pyproject.toml", "type": "config"},
  {"file": "src/deepseek_mcp/server.py", "type": "code"}
]

The server appends lightweight metadata:

---
_deepseek · model=deepseek-v4-flash  latency=18.42s  tokens=52+74  cost=$0.0001_

Latency depends heavily on prompt size, model, network, and API load. Treat benchmark numbers as directional, not a guarantee.

CLI

After installing, you can use the CLI for smoke tests and one-shot calls:

# Validate setup
python -m deepseek_mcp check

# One-shot flash call
python -m deepseek_mcp run "Classify: urgent / later — 'Server down in prod'"

# Advisor call with deep reasoning
python -m deepseek_mcp advise "Should we build or buy analytics?" --effort max

Exit codes: 0 = success, 1 = API error, 2 = missing key.

Models

Tool	Model	Mode	Best for
`deepseek`	deepseek-v4-flash	Non-thinking	Classification, extraction, formatting, mechanical edits
`advise`	deepseek-v4-pro	Thinking (effort: medium/high/max)	Architecture, tradeoffs, second opinions, ambiguity

Cost

Per-call cost depends on token count and model. Pricing per api.deepseek.com (checked 2026-04-30).

Model	Input (miss)	Input (cache hit)	Output
`deepseek-v4-flash`	$0.14/1M	$0.0028/1M	$0.28/1M
`deepseek-v4-pro`	$0.435/1M¹	$0.0036/1M¹	$0.87/1M¹

¹ Pro pricing is 75% off until 2026-05-31. Non-discounted: $1.74/$0.0145/$3.48.

Typical per-call cost (cache miss):

Task	Flash	Pro
Small (~1K in + ~0.5K out)	~$0.0003	~$0.0009
Medium (~4K in + ~2K out)	~$0.001	~$0.003

Each response footer includes an estimated cost=$... based on token usage.

Environment variables

Variable	Default	Description
`DEEPSEEK_API_KEY`	—	Required. Your DeepSeek API key.
`DEEPSEEK_BASE_URL`	`https://api.deepseek.com`	API base URL (change for proxy/compatible providers).
`DEEPSEEK_MCP_LOG`	(unset)	Set to `1` to log call metadata to `~/.deepseek-mcp/calls.jsonl` (no prompts logged).

When to use it

Good:

"Classify these 200 filenames. Mark uncertainty."
"Turn this rough note into a CSV table."
"Extract all TODOs and group them by owner."
"Create candidate JSON from this messy list. Use null for missing values."
"Summarize this packet for review; do not make decisions."

Bad:

"Design my architecture."
"Write the final client email."
"Decide whether this is secure."
"Resolve this ambiguous business rule."
"Publish this reply directly."

Use it like a fast junior analyst whose work you will review, not like an owner.

How it works

The server:

reads JSON-RPC messages from stdin;
exposes two MCP tools: deepseek (flash, non-thinking) and advise (pro, thinking);
sends your prompt to DeepSeek's OpenAI-compatible chat completions API;
streams the response;
returns the text plus model, latency, token, and cost metadata.

There is no database, no background daemon, no local web server, and no file-system access beyond the MCP client starting the process.

Smoke test

After installing:

echo '{"jsonrpc":"2.0","id":1,"method":"tools/list"}' \
  | DEEPSEEK_API_KEY="sk-..." deepseek-mcp-server

You should see a JSON response with two tools (deepseek + advise).

Then test a real call:

echo '{"jsonrpc":"2.0","id":2,"method":"tools/call",\
  "params":{"name":"deepseek","arguments":{"prompt":"Return exactly: ok"}}}' \
  | DEEPSEEK_API_KEY="sk-..." deepseek-mcp-server

Examples

See examples/ for real prompt templates:

flash_classify.md — inbox triage
advise_architecture.md — architecture decision
advise_tradeoff.md — build vs buy

Benchmark

See docs/benchmark.md for validation observations and usage guidance.

Development

pip install -e ".[dev]"
pip install -r requirements-dev.txt  # alternative
python -m pytest

Compatible endpoints

deepseek-mcp works with any OpenAI-compatible API. Set DEEPSEEK_BASE_URL to point elsewhere:

Provider	`DEEPSEEK_BASE_URL`	Notes
DeepSeek	`https://api.deepseek.com`	Default
Google Gemini	`https://generativelanguage.googleapis.com/v1beta/openai/`	Requires Gemini API key; models like `gemini-2.5-flash`
Ollama (local)	`http://localhost:11434/v1`	Run any local model; e.g. `llama3`, `qwen2.5`
vLLM (self-hosted)	`http://localhost:8000/v1`	For self-hosted open-weight models
Mistral API	`https://api.mistral.ai/v1`	Requires Mistral API key

Security notes

The worker returns text only. It cannot call tools, write files, or access your repo. Output lands in the primary model's context — you review before anything is used.
Do not commit API keys.
Prefer client/global env injection over hardcoding keys in project repos.
Treat model output as untrusted candidate text.
Do not give the tool access to secrets you would not paste into DeepSeek directly.
Review output before it reaches users, customers, production systems, or public channels.

License

MIT

Available Tools

2 tools

adviseDeepSeek AdvisorA

Read-only

Deep reasoning via DeepSeek V4 Pro with thinking mode enabled. Use when deepseek is not sufficient: judgment under ambiguity, architectural tradeoffs, second opinions on consequential decisions, complex multi-factor analysis, or anything where being wrong has real cost. Defaults to effort=max — exhaustive reasoning. Returns structured response: CONCLUSION / REASONING / WATCH OUT. More expensive (~6x flash) and slower (60-120s). Use effort=medium or high only when you need a quicker lighter read.

ParametersJSON Schema

Name	Required	Description	Default
`prompt`	Yes	Question or problem to reason about
`system`	No	Optional additional context or constraints for the advisor.
`effort`	No	Reasoning depth. max (default): exhaustive, for the hardest decisions (~90-120s). high: full chain-of-thought + alternatives (~60s). medium: lighter thinking, quicker (~30s).	max
`show_reasoning`	No	If true, prepend a <reasoning>...</reasoning> block with the model's chain-of-thought. Off by default to keep responses compact — reasoning_content can be large.

TDQS

A5/5.0

Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

The description discloses that the tool returns a structured response with CONCLUSION/REASONING/WATCH OUT, that it is more expensive (~6x flash) and slower (60-120s), and that show_reasoning prepends a reasoning block. These details go beyond the readOnlyHint=true annotation, providing rich behavioral context.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is concise yet packed with essential information. It front-loads the purpose, then provides usage guidelines, defaults, cost, and speed. Every sentence adds value, and the structure is logical. No unnecessary filler.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool has 4 parameters, 1 required, and no output schema, the description fully compensates by describing the output format (CONCLUSION/REASONING/WATCH OUT) and providing cost and speed. The agent has all necessary context to select and invoke the tool correctly.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters5/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema covers all 4 parameters (100% coverage). The description adds extra meaning: it explains the effort levels in detail (exhaustive, full chain-of-thought, lighter thinking) and clarifies that show_reasoning adds a reasoning block. This adds significant value beyond the schema's descriptions.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool is for deep reasoning via DeepSeek V4 Pro with thinking mode. It differentiates from the sibling 'deepseek' by specifying when to use it: when deepseek is not sufficient, such as for judgment under ambiguity, architectural tradeoffs, etc. The verb 'reason' and resource 'DeepSeek V4 Pro' are specific.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Explicitly says 'Use when deepseek is not sufficient' and lists scenarios. It also provides guidance on effort levels: defaults to effort=max for exhaustive reasoning, and suggests effort=medium or high for quicker reads. This clearly tells the agent when to use this tool versus alternatives.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

deepseekDeepSeekA

Read-onlyIdempotent

Fast, cheap task execution via DeepSeek V4 Flash (non-thinking mode). Best for: classification, summarization, JSON edits, table generation, template population, pattern-copy refactors, inbox triage. Not for: architecture decisions, judgment under ambiguity, security policy, client-facing final prose. Typical latency: 2-5s. Use advise when you need deeper reasoning.

ParametersJSON Schema

Name	Required	Description	Default
`prompt`	Yes	Task prompt
`system`	No	Optional additional system instructions. Appended after the built-in epistemic honesty guard.

TDQS

A4.6/5.0

Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Description adds context beyond annotations (readOnlyHint, idempotentHint) by specifying 'non-thinking mode' and typical latency 2-5s. No contradictions; aligns well with annotations.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Extremely concise with no wasted words. Front-loaded with key facts: speed, mode, latency. Lists are clear and organized.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Missing explicit mention of return format or output structure, which would be helpful since no output schema is provided. Otherwise, context is sufficient for a simple, read-only tool.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100%, so baseline 3 is appropriate. The description does not add parameter-specific meaning beyond what the schema provides, but the schema itself is adequate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

Clearly states the tool's purpose: 'Fast, cheap task execution via DeepSeek V4 Flash (non-thinking mode)'. Lists specific use cases and distinguishes from the sibling 'advise' by noting it is for deeper reasoning.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Explicitly provides 'Best for:' and 'Not for:' lists, gives typical latency, and directs to 'advise' for scenarios needing deeper reasoning, offering clear guidance on when to use this tool versus alternatives.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.

2 tool updatesv0.5.1May 28, 2026
- First observedadvise
- First observeddeepseek

Install Server

RayrunBuild, deploy, and operate MCP servers without becoming an infrastructure team.ray.runAd

TDQS

A4.6/5.0

Disambiguation5/5

The two tools have clearly distinct purposes: 'deepseek' for fast, cheap tasks and 'advise' for deep reasoning. Descriptions explicitly state when to use each, leaving no ambiguity.

Naming Consistency2/5

The tool names follow no consistent pattern: 'deepseek' is a product name, while 'advise' is an imperative verb. They do not share a common structure, which could confuse agents expecting a uniform naming convention.

Tool Count5/5

With only 2 tools, the server is well-scoped for its purpose of providing two complementary reasoning modes. The count is appropriate and not excessive or insufficient.

Completeness5/5

The server covers the full spectrum of reasoning needs: fast execution via 'deepseek' and deep reasoning via 'advise'. There are no obvious gaps in the tool surface for the stated domain.

Maintenance

ActivityInactive

ResponsivenessSyncing

Resources

GitHub Repository

Need Help?

Related Servers

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Related MCP Connectors

QuallaaOAuth
com.quallaa
Talk to your public-facing AI from any MCP client — Claude, ChatGPT, Cursor, Cline, Windsurf.
AI & Machine Learning Communication
2
supportsheep
io.github.pooriaarab
Remote MCP server for supportsheep: run AI interviews and manage support content for your blog.
Customer Support Content Management Systems Marketing
1
SandBase
io.github.sandbaseai
Connect MCP clients to 2,000+ AI models without managing provider API keys.
AI & Machine Learning Agent Orchestration
1116
anotherai
dev.anotherai
MCP server for building and testing AI agents with multi-model experimentation and insights.
Agent Orchestration Autonomous Agents Testing & QA Tools
2

Related MCP Servers

DeepSeek MCP Server
Autonomous Agents Language Translation
DMontgomery40
A
license
A
quality
A
maintenance
Enables integration of DeepSeek's language models with MCP-compatible applications, offering features like chat completion, custom model selection, and parameter control for enhancing language-based interactions.
Updated 18 days ago (2026-08-19 04:08 UTC)
7
495
351
MIT
DeepSeek MCP Server
Agent Orchestration Autonomous Agents Code Execution
liuchongchong1995
A
license
D
quality
D
maintenance
Allows seamless integration of DeepSeek's language models with MCP-compatible applications like Claude Desktop, supporting features such as model selection, temperature control, and multi-turn conversations with automatic model fallback.
Updated a year ago (2025-03-27 06:20 UTC)
2
495
2
MIT
Deepseek MCP Server
Code Analysis Coding Agents Developer Tools
arikusi
A
license
A
quality
A
maintenance
MCP server for DeepSeek AI models (Chat + Reasoner). Supports multi-turn sessions, model fallback with circuit breaker, function calling, thinking mode, JSON output, multimodal input, and cost tracking.
Updated 13 days ago (2026-08-24 03:09 UTC)
3
517
17
MIT
DeepSeek MCP Server
AI & Machine Learning Developer Tools
deepzhun
A
license
Not graded
quality
B
maintenance
Connects MCP clients to DeepSeek API, including DeepSeek-R1 reasoning with visible chain-of-thought. Provides four tools: generate, chat, reason, and list models.
Updated 2 months ago (2026-07-14 06:26 UTC)
1
MIT

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/arizen-dev/deepseek-mcp'

If you have feedback or need assistance with the MCP directory API, please join our Discord server

deepseek-mcp

Quickstart

1. Install

2. Add your DeepSeek key

3. Configure MCP

Codex

Demo

CLI

Models

Cost

Environment variables

When to use it

How it works

Smoke test

Examples

Benchmark

Development

Compatible endpoints

Security notes

License

Available Tools

TDQS

TDQS

Tool Schema Changelog

TDQS

Maintenance

Resources

Looking for Admin?

Related MCP Connectors

Related MCP Servers

DeepSeek MCP Server

DeepSeek MCP Server

Deepseek MCP Server

DeepSeek MCP Server

Latest Blog Posts

MCP directory API