Skip to main content
Glama
deepseek-mcp-server

deepseek-mcp-server

DeepSeek code assistant

deepseek_code

Pass inline code or file paths with a task to generate, review, refactor, test, debug, explain, document, optimize, or convert code; routes each task to a suitable DeepSeek model.

Instructions

Task-oriented coding helper. Pick a task (generate, review, refactor, explain, test, debug, document, optimize, convert) and pass code inline and/or as file paths. Routes to deepseek-reasoner for debug/review/optimize and deepseek-chat otherwise, unless you override model.

Tool call template

Replace each placeholder with a value matching the input schema. Only required parameters are included; add optional parameters as needed.

{
  "id": 1,
  "jsonrpc": "2.0",
  "method": "tools/call",
  "params": {
    "arguments": {
      "task": "<task>"
    },
    "name": "deepseek_code"
  }
}

Input Schema

NameRequiredDescriptionDefault
codeNoSource code, inline.
stopNoUp to 16 stop sequences. A single string is also accepted.
taskYesWhat to do with the code.
errorNoError message, stack trace or failing test output, for `debug`.
extraNoArbitrary extra request-body fields, merged last so they override everything else. The escape hatch for any API parameter this server does not model yet.
modelNoOverride the model id for this call.
pathsNoFiles, directories or globs to read and include as context.
toolsNoFunction-calling definitions, passed to the API verbatim. Each item is { type: 'function', function: { name, description, parameters } }.
top_pNoNucleus sampling, 0-1. Ignored by deepseek-reasoner.
streamNoStream from the API and return the assembled result. Useful for very long outputs that would otherwise hit an idle timeout.
languageNoLanguage or framework hint.
logprobsNoReturn log probabilities. deepseek-chat only.
json_modeNoShorthand for response_format { type: 'json_object' }. Your prompt must mention JSON and should show an example.
max_tokensNoMaximum output tokens. Omit for the server-side maximum (8192 for deepseek-chat, 65536 for deepseek-reasoner). No client-side cap is applied.
session_idNoConversation key. Prior turns under this id are prepended automatically and this turn is appended, giving true multi-turn memory across tool calls.
timeout_msNoPer-call timeout override in milliseconds.
temperatureNo0.0-2.0. DeepSeek's own guidance: 0.0 for code and maths, 1.0 for general conversation and data analysis, 1.3 for creative writing. Ignored by deepseek-reasoner.
tool_choiceNo'auto', 'none', 'required', or { type: 'function', function: { name } }.
instructionsNoWhat you want, in plain language. Required for `generate` and `convert`.
raw_responseNoReturn the complete unmodified API JSON instead of formatted text.
top_logprobsNo0-20, requires logprobs. deepseek-chat only.
include_usageNoAppend the token-usage and cache-hit footer. Default true.
target_languageNoDestination language for `convert`.
presence_penaltyNo-2.0 to 2.0. Ignored by deepseek-reasoner.
frequency_penaltyNo-2.0 to 2.0. Ignored by deepseek-reasoner.
include_reasoningNoInclude the chain-of-thought block in the result. Default true for deepseek-reasoner.

Schema Changelog

Changes observed during successful MCP inspections.

  1. First observedv1.0.0

TDQS

A3.6/5.0
Behavior3/5

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

No annotations are supplied, so the description carries the whole burden. It discloses the meaningful behavior an agent could not otherwise predict: automatic model routing by task and the `model` override. It omits other traits of a 26-parameter remote-API wrapper, such as cost/latency implications, local versus server-side file reading, and any limits on the paths globs.

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

Conciseness4/5

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

Two tight sentences with the purpose front-loaded, then the task list, then the routing rule — no filler. It is arguably under-sized for a 26-parameter tool, but nothing in the text is wasted.

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

Completeness3/5

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

With 26 parameters, no annotations and no output schema, the description does cover the main invocation path and model routing. It leaves the agent without any picture of what a call returns (formatted text versus raw JSON), how session memory and file context interact, or what happens when both `code` and `paths` are given, which the parameter documentation alone only partially resolves.

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 description coverage is 100%, so every parameter already has an inline description and the baseline is 3. The description adds only partial framing (inline code and/or paths; the `model` override interacts with the routing rule) and does not clarify the 25 optional parameters beyond what the schema states.

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

Purpose4/5

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

"Task-oriented coding helper" plus an enumerated task list (generate, review, refactor, explain, test, debug, document, optimize, convert) states a concrete verb and resource, and the word "coding" scopes it away from a general chat tool. It stops short of naming a sibling as the alternative, and "Routes to deepseek-reasoner" risks momentary confusion with the sibling tool deepseek_reason.

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

Usage Guidelines4/5

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

It tells the agent how to drive the tool: pick a task, then supply code inline and/or as file paths. The routing rule (reasoner for debug/review/optimize, chat otherwise, overridable via `model`) gives useful selection context, but there is no explicit when-not or recommendation against a sibling like deepseek_chat.

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