DeepSeek connector for AI agents

Tools your research agent reaches for on DeepSeek, scoped per user.

CALL ANY TOOL

11 tools for LLM API calls in DeepSeek: create chat, beta chat, fill-in-the-middle, and Responses-format completions, search the web, fetch pages as Markdown, list models, check balance, and manage uploaded files.

deepseek_create_beta_chat_completion

Create beta chat completion

Generate an assistant message through DeepSeek's beta chat endpoint (non-streaming), which adds chat prefix completion and strict-mode function calling to the regular chat API. Returns the same chat completion object: choices with content, reasoning_content, tool_calls and finish_reason, plus token usage. Use this when the reply must continue from an assistant prefix (last message has "prefix": true) or when tool arguments must match their JSON Schema exactly ("strict": true on each function). Otherwise use deepseek_create_chat_completion.

Parameters

Name

Type

Required

Description

messages

array

Required

Conversation so far as a JSON array of message objects. Each has a role (system, user, assistant, or tool) and content. User content can also be an array of content parts, for example text plus an image_url part (images work with deepseek-flash only). Assistant messages that requested tools carry tool_calls, and each tool result is a tool message with the matching tool_call_id. When tools are used in thinking mode, pass every earlier assistant message back unchanged, including its reasoning_content, or the API returns 400. For chat prefix completion, make the last message an assistant message with "prefix": true; the model continues from its content. Example: [{"role":"user","content":"Write quick sort in Python"},{"role":"assistant","content":"```python\n","prefix":true}]

model

string

Required

DeepSeek model to use: deepseek-flash (DeepSeek-V4.1-Flash, fast and cheap, accepts image input) or deepseek-v4-pro (DeepSeek-V4-Pro, stronger, text only). One of: `deepseek-flash`, `deepseek-v4-pro`.

logprobs

boolean

Optional

When true, return the log probability of each output token.

max_tokens

integer

Optional

Maximum number of tokens to generate, from 1 to 393216 (384K). Defaults to 8K in non-thinking mode and 64K in thinking mode (128K with reasoning_effort max). Example: 4096

reasoning_effort

string

Optional

How hard the model thinks in thinking mode: low, high (the default), or max. none turns thinking mode off. Example: max. One of: `none`, `low`, `high`, `max`.

response_format

string

Optional

Output format: text (default) or json_object for JSON Output, which guarantees the reply is valid JSON. With json_object, also ask for JSON in a system or user message (ideally with an example of the shape) and set max_tokens high enough, or the reply can be empty or cut off. One of: `text`, `json_object`.

stop

array

Optional

Up to 16 stop sequences as a JSON array of strings; generation stops before any of them. Example: ["```"]

temperature

number

Optional

Sampling temperature from 0 to 2; lower is more deterministic. Only applies in non-thinking mode. Example: 0.2

thinking

string

Optional

Turns thinking (reasoning) mode on or off. Thinking mode is on by default: the model writes its chain of thought to reasoning_content before the final answer. disabled gives faster, cheaper replies and is required for tool_choice required or a named function. One of: `enabled`, `disabled`.

tool_choice

string

Optional

Which tool the model may call: none (no tool), auto (model decides; the default when tools are given), required (must call at least one tool), or the name of one function to force that call. required and a function name only work with thinking disabled. Example: get_weather

tools

array

Optional

Functions the model may call, as a JSON array (up to 128 entries is typical). Each entry is {"type":"function","function":{...}} where the function has a name (letters, digits, underscores and dashes, up to 128 characters), a description, and parameters as a JSON Schema object. This tool supports strict mode: set "strict": true on every function to force arguments that match its schema. Example: [{"type":"function","function":{"name":"get_weather","description":"Get the weather for a city","parameters":{"type":"object","properties":{"city":{"type":"string"}},"required":["city"]}}}]

top_logprobs

integer

Optional

Number of most likely alternative tokens (0 to 20) to return at each position. Needs logprobs true. Example: 5

top_p

number

Optional

Nucleus sampling cutoff, greater than 0 and at most 1. How it applies depends on the model and thinking mode (for deepseek-flash it only applies in thinking mode, with values below 0.95 raised to 0.95). Example: 0.95

user_id

string

Optional

Your own identifier for the end user (letters, digits, - and _, up to 512 characters). DeepSeek uses it for content safety review, KV cache isolation and per-user scheduling. Do not put personal data in it. Example: customer_8421

deepseek_create_chat_completion

Create chat completion

Generate the next assistant message for a conversation with a DeepSeek model (non-streaming), with optional thinking mode, JSON output and function calling. Returns choices with the message content, reasoning_content (thinking mode), any tool_calls and finish_reason, plus token usage including cache hits and reasoning tokens. Use this for chat, reasoning, structured JSON and tool-calling agents. Use deepseek_create_beta_chat_completion to force the reply to start with a prefix or for strict-mode tool schemas, deepseek_create_fim_completion to fill in code between a prefix and a suffix, and deepseek_create_response for the OpenAI Responses API format.

Parameters

Name

Type

Required

Description

messages

array

Required

Conversation so far as a JSON array of message objects. Each has a role (system, user, assistant, or tool) and content. User content can also be an array of content parts, for example text plus an image_url part (images work with deepseek-flash only). Assistant messages that requested tools carry tool_calls, and each tool result is a tool message with the matching tool_call_id. When tools are used in thinking mode, pass every earlier assistant message back unchanged, including its reasoning_content, or the API returns 400. Example: [{"role":"system","content":"You are concise."},{"role":"user","content":"Hello"}]

model

string

Required

logprobs

boolean

Optional

When true, return the log probability of each output token.

max_tokens

integer

Optional

Maximum number of tokens to generate, from 1 to 393216 (384K). Defaults to 8K in non-thinking mode and 64K in thinking mode (128K with reasoning_effort max). Example: 4096

reasoning_effort

string

Optional

How hard the model thinks in thinking mode: low, high (the default), or max. none turns thinking mode off. Example: max. One of: `none`, `low`, `high`, `max`.

response_format

string

Optional

stop

array

Optional

Up to 16 stop sequences as a JSON array of strings; generation stops before any of them. Example: ["```"]

temperature

number

Optional

Sampling temperature from 0 to 2; lower is more deterministic. Only applies in non-thinking mode. Example: 0.2

thinking

string

Optional

tool_choice

string

Optional

tools

array

Optional

Functions the model may call, as a JSON array (up to 128 entries is typical). Each entry is {"type":"function","function":{...}} where the function has a name (letters, digits, underscores and dashes, up to 128 characters), a description, and parameters as a JSON Schema object. Example: [{"type":"function","function":{"name":"get_weather","description":"Get the weather for a city","parameters":{"type":"object","properties":{"city":{"type":"string"}},"required":["city"]}}}]

top_logprobs

integer

Optional

Number of most likely alternative tokens (0 to 20) to return at each position. Needs logprobs true. Example: 5

top_p

number

Optional

user_id

string

Optional

deepseek_create_fim_completion

Create fim completion

deepseek_create_response

Create response

Generate a model response in the OpenAI Responses API format (stateless, non-streaming), with optional thinking, JSON or JSON Schema output, function tools and server-side web search (deepseek-v4-pro). Returns a response object with status, an output array of reasoning, message, function_call and web_search_call items, and token usage. Use this when your agent already speaks the Responses format or needs json_schema output or built-in web search. Use deepseek_create_chat_completion for the Chat Completions format. Nothing is stored, so send the full history in input_items each turn.

Parameters

Name

Type

Required

Description

model

string

Required

input

string

Optional

Plain-text input, treated as one user message. Use input_items instead for a multi-turn history, images or tool results. Provide input, input_items or instructions. Example: Explain what a vector database is.

input_items

array

Optional

The full conversation as a JSON array of input items. The API is stateless, so send the whole history each time. Item types are message ({"role":"user","content":"..."}, roles user, assistant, system or developer), function_call, function_call_output (with the matching call_id), reasoning and web_search_call. User messages can include input_image parts (deepseek-flash only). Overrides input when both are set. Example: [{"role":"user","content":"What is 2+2?"}]

instructions

string

Optional

System-level instruction inserted as the first system message. Example: Answer in one short paragraph.

json_schema

object

Optional

JSON Schema object the output must match. Required when text_format is json_schema. Example: {"type":"object","properties":{"city":{"type":"string"},"population":{"type":"integer"}},"required":["city","population"]}

json_schema_name

string

Optional

Name of the output schema. Required when text_format is json_schema. Example: city_facts

max_output_tokens

integer

Optional

Upper bound on generated tokens, counting both visible output and reasoning tokens. Example: 4096

reasoning_effort

string

Optional

Thinking mode and effort: none turns thinking off; low, high or max turn it on at that effort. If unset, the model's default applies (thinking on, effort high). One of: `none`, `low`, `high`, `max`.

temperature

number

Optional

Sampling temperature from 0 to 2. Only applies in non-thinking mode. Example: 0.2

text_format

string

Optional

Output format: text (default), json_object for JSON mode, or json_schema for output that matches json_schema (also set json_schema_name). One of: `text`, `json_object`, `json_schema`.

tool_choice

string

Optional

Which tool the model may call: none, auto (default), required, or the name of one function to force that call. Example: get_weather

tools

array

Optional

Tools the model may call, as a JSON array. Function tools look like {"type":"function","name":"get_weather","description":"...","parameters":{JSON Schema}}. {"type":"web_search"} lets deepseek-v4-pro search the web on the server; it is ignored with deepseek-flash.

top_logprobs

integer

Optional

Number of most likely tokens (0 to 20) to return with log probabilities at each position. Example: 5

top_p

number

Optional

Nucleus sampling cutoff, greater than 0 and at most 1. Only applies in thinking mode, where values below 0.95 are raised to 0.95. Example: 0.95

user

string

Optional

Your own identifier for the end user (letters, digits, - and _, up to 512 characters), used for content safety review, KV cache isolation and scheduling. No personal data. Example: customer_8421

deepseek_delete_file

Delete file

deepseek_fetch_url

Fetch url

deepseek_get_file

Get file

deepseek_get_user_balance

Get user balance

deepseek_list_files

List files

deepseek_list_models

List models

deepseek_search_web

Search web

Build your Agent

Same auth pattern across LangChain, OpenAI, Anthropic, and Google ADK.

import { ScalekitClient } from "@scalekit-sdk/node";
import { createReactAgent } from "@langchain/langgraph/prebuilt";

const sk = new ScalekitClient(env.SCALEKIT_ENV_URL, env.SCALEKIT_CLIENT_ID, env.SCALEKIT_CLIENT_SECRET);

// DeepSeek tools scoped to this user
const { tools } = await sk.tools.listScopedTools("user_123", {
  filter: { connectionNames: ["deepseek"], toolNames: [
    "deepseek_search_web",
    "deepseek_fetch_url",
    "deepseek_create_chat_completion"] },
  pageSize: 100,
});

const agent = createReactAgent({ llm, tools });
await agent.invoke({ messages: [{ role: "user", content: "Search the web for the latest Postgres release notes and summarize them" }] });

import OpenAI from "openai";
import { ScalekitClient } from "@scalekit-sdk/node";

const sk = new ScalekitClient(env.SCALEKIT_ENV_URL, env.SCALEKIT_CLIENT_ID, env.SCALEKIT_CLIENT_SECRET);
const openai = new OpenAI();

const { tools } = await sk.tools.listScopedTools("user_123", {
  filter: { connectionNames: ["deepseek"] }, pageSize: 100,
});

const res = await openai.chat.completions.create({
  model: "gpt-5",
  messages: [{ role: "user", content: "Search the web for the latest Postgres release notes and summarize them" }],
  tools,
});

// Execute the tool call with the user's vaulted DeepSeek access token
await sk.tools.executeTool(res.choices[0].message.tool_calls[0], "user_123");

import Anthropic from "@anthropic-ai/sdk";
import { ScalekitClient } from "@scalekit-sdk/node";

const sk = new ScalekitClient(env.SCALEKIT_ENV_URL, env.SCALEKIT_CLIENT_ID, env.SCALEKIT_CLIENT_SECRET);
const anthropic = new Anthropic();

const { tools } = await sk.tools.listScopedTools("user_123", {
  filter: { connectionNames: ["deepseek"] }, pageSize: 100,
});

const msg = await anthropic.messages.create({
  model: "claude-sonnet-5",
  max_tokens: 1024,
  messages: [{ role: "user", content: "Search the web for the latest Postgres release notes and summarize them" }],
  tools,
});

// Tool call runs with the user's vaulted DeepSeek access token
await sk.tools.executeTool(msg.content, "user_123");

import { Agent } from "@google/adk/agents";
import { ScalekitClient } from "@scalekit-sdk/node";

const sk = new ScalekitClient(env.SCALEKIT_ENV_URL, env.SCALEKIT_CLIENT_ID, env.SCALEKIT_CLIENT_SECRET);

const { tools } = await sk.tools.listScopedTools("user_123", {
  filter: { connectionNames: ["deepseek"] }, pageSize: 100,
});

const agent = new Agent({
  name: "research_agent",
  model: "gemini-2.5-pro",
  instruction: "DeepSeek tools scoped to this user",
  tools,
});

await agent.run("Search the web for the latest Postgres release notes and summarize them");

Try these prompts

Copy any prompt into your agent. Each maps directly to a DeepSeek tool. Click to copy, paste into your agent, done.

Completions

Copy the prompt

Copied

Explain this stack trace with thinking mode on.

Copy the prompt

Copied

Fill in the body of this Python function between the signature and the return.

Copy the prompt

Copied

Return this invoice text as JSON with vendor, total, and due date.

Web

Copy the prompt

Copied

Search the web for recent reviews of our product and list the top 5.

Copy the prompt

Copied

Fetch this documentation page as Markdown.

Copy the prompt

Copied

Search for news about our competitor's latest funding round.

Account and files

Copy the prompt

Copied

What is our DeepSeek balance in USD?

Copy the prompt

Copied

List the DeepSeek models we can use and their context windows.

Copy the prompt

Copied

Delete the image files we uploaded last week.

SEE HOW AUTH WORKS

Each user connects their own DeepSeek access token once, and Scalekit sends it with every call. Access tokens stay vaulted, every call is scope checked, and every action is logged.

Authorize

Your user connects

DeepSeek

once. We tie it to their identity and the meetings they approved — no shared bot account, no org-wide access

Who:

user ‘A’

when:

Once per user

access:

Limited to user

Store

Their

DeepSeek

token lives in a vault scoped to them. User A's meetings are never reachable by an agent acting for user B, even on the same connection

vault:

encrypted

scope:

per-user

tokens:

auto-refreshed

Resolve

When your agent calls a

DeepSeek

tool, we fetch the right token server-side. It never touches your agent, never appears in the LLM context, never shows up in your logs

speed:

~40ms

check:

before every call

seen by:

nobody

Audit

Every

DeepSeek

tool call is logged — who triggered it, which meeting was fetched, what came back. 90 days of history, tied to the user who authorized it

history:

90 days

export:

SIEM-ready

logged:

every call

Test other agents

See the same per-user auth pattern across other AI and LLM connectors.

GTM and RevOps Teams

Competitive intelligence briefing agent

Scans Gong calls for competitor mentions, matches each one to its Notion battlecard, and DMs every affected rep a single Slack digest per cycle. Every call runs as the PMM who owns the briefing, never a shared bot.

Engineering Teams

Slack triage

Polls Slack for new messages, classifies bugs and support requests with a LangGraph router, files GitHub issues or Zendesk tickets, and confirms in the thread.

Why Scalekit

Secure your agent's access. Connectors ship in minutes

01.

Shared tokens break per-user analytics

A shared DeepSeek access token looks fine in a demo. In production every completion request looks like one service account, and you cannot tell which user triggered it. Scalekit resolves the credential of the actual user who triggered the agent, never a shared bot.

// shared key
audit → bot_service_account

// scalekit
audit → user_abc ✓

02.

Authentication is not authorization

03.

Multi-tenancy is architectural

04.

DeepSeek today. Ten connectors tomorrow.

“Our agents act across Salesforce, Gong, Google Drive, and more, on behalf of every customer. Scalekit behind the scenes meant we can keep adding tools without ever rebuilding how credentials or tool calling work.”

Venu Madhav Kattagoni

Head of Engineering / Von

FAQs

Frequently Asked Questions

Does the agent access DeepSeek as the user or through a shared access token?

As the user. Each user connects their own DeepSeek access token once, and Scalekit sends it with every call. Audit logs attribute every completion and search to that user, not a shared service account.

Where is the DeepSeek access token stored?

In Scalekit's managed AES-256 token vault, namespaced per tenant. To rotate it, the user reconnects with a new access token. Revocation is a single dashboard action. Credentials never appear in prompts, logs, or LLM context.

Can I limit what the agent does in DeepSeek?

Yes. Filter by tool name in listScopedTools to expose only what you want, for example completions and web search without deepseek_delete_file, which permanently deletes an uploaded file. Scalekit also enforces scope checks before every API call.

What happens when a user revokes DeepSeek access?

The connection is invalidated on the next tool call. Subsequent requests for that user fail closed with a clear error. Other users in the tenant remain unaffected. The event is logged for audit.

Can the agent check whether the account can pay for calls?

Yes. deepseek_get_user_balance returns whether the balance covers API calls and the total per currency, CNY or USD. deepseek_list_models shows each model's context window and max output tokens.