DeepSeek LangChain Integration: Python, TypeScript, RAG, Tools, and Structured Output

Quick answer: DeepSeek can be used with LangChain through ChatDeepSeek in Python and TypeScript. For new LangChain apps, use the current DeepSeek V4 API model IDs: deepseek-v4-flash for fast and economical workflows, and deepseek-v4-pro for harder reasoning, coding, long-context analysis, and agentic workflows.

The older names deepseek-chat and deepseek-reasoner are now legacy compatibility aliases. They should appear only in migration notes, not as the primary model names for new LangChain examples.

Independent guide: Chat-Deep.ai is an independent DeepSeek guide and browser access site. It is not affiliated with DeepSeek, DeepSeek.com, the official DeepSeek app, the official DeepSeek developer platform, LangChain, LangSmith, OpenAI, Anthropic, Ollama, vLLM, or any model/runtime provider.

Last verified: April 24, 2026.

Current DeepSeek API snapshot

Current API model IDs: deepseek-v4-flash and deepseek-v4-pro

Current API generation: DeepSeek-V4 Preview

Base URL for OpenAI-compatible requests: https://api.deepseek.com

Context length: 1M tokens

Maximum output: 384K tokens

Thinking mode: supported on both current V4 API models

Non-thinking mode: supported on both current V4 API models

JSON Output: supported on both current V4 API models

Tool Calls: supported on both current V4 API models

FIM Completion: supported in non-thinking mode only

Legacy aliases: deepseek-chat and deepseek-reasoner currently route to deepseek-v4-flash non-thinking and thinking modes

Legacy alias retirement: DeepSeek says deepseek-chat and deepseek-reasoner will be retired after July 24, 2026, 15:59 UTC

This page is updated to stay consistent with the current Chat-Deep.ai homepage, DeepSeek API guide, DeepSeek API pricing guide, OpenAI SDK with DeepSeek guide, DeepSeek Python SDK guide, DeepSeek Node.js TypeScript guide, Thinking Mode guide, Tool Calls guide, and Token Usage guide.

Quick answer: DeepSeek with LangChain

For most developers, a current DeepSeek LangChain integration starts with these steps:

Install langchain-deepseek for Python or @langchain/deepseek for JavaScript/TypeScript.
Set DEEPSEEK_API_KEY as a server-side environment variable.
Import ChatDeepSeek.
Use model="deepseek-v4-flash" for fast, economical workflows.
Use model="deepseek-v4-pro" for harder reasoning, coding, long-context, and agentic workflows.
Use a separate embedding model and vector store for RAG.
Test your exact LangChain package version before relying on advanced structured-output, tool-calling, or thinking-mode flows.

For simple one-call API usage, direct DeepSeek API calls may be easier than LangChain. For orchestration, RAG, tools, agents, memory, reusable chains, and tracing, LangChain can be useful.

Critical update: do not use old V3.2 wording as current

Older examples across the web, and even some older LangChain examples, may still show deepseek-chat and deepseek-reasoner. That wording is now migration-only. The current official DeepSeek API model IDs are deepseek-v4-flash and deepseek-v4-pro.

Old wording	Current status	New recommended wording
`deepseek-chat` as starter model	Legacy compatibility alias	Use `deepseek-v4-flash` for fast and economical LangChain workflows
`deepseek-reasoner` as reasoning model	Legacy compatibility alias	Use `deepseek-v4-pro` for harder reasoning, tool planning, coding, and agentic workflows
DeepSeek-V3.2 as current hosted API family	Outdated for the current hosted API	Use DeepSeek-V4 Preview as the current API generation
128K context as current hosted API limit	Outdated for current V4 API docs	Use 1M context and 384K maximum output for current V4 API models
Old V3.2 pricing	Outdated	Use V4-Flash and V4-Pro pricing from the current pricing table

Keep the legacy names only in migration notes. Do not use them as the main examples in new LangChain content.

When you need LangChain

LangChain is useful when your DeepSeek application needs orchestration around the model call. Examples include prompts, chains, retrievers, tools, agents, memory, tracing, structured output, and RAG pipelines.

Use LangChain for RAG apps that combine retrieval, prompts, and model generation.
Use LangChain for tool routing and agent-style workflows.
Use LangChain when you want reusable chains, observability, or LangSmith tracing.
Use LangGraph when your workflow needs stateful multi-step control beyond a simple chain.
Use direct API calls when you only need one plain chat completion.

When you may not need LangChain

Not every DeepSeek API app needs LangChain. If your application only sends one prompt and receives one answer, the direct DeepSeek API or the OpenAI-compatible SDK setup is simpler and easier to debug.

Use direct DeepSeek API when…	Use LangChain when…
You need one chat completion call.	You need chains, tools, RAG, memory, tracing, or reusable orchestration.
You need exact control over DeepSeek-specific request fields such as `thinking` or beta endpoints.	You want a framework that composes prompts, retrievers, tools, and model calls.
You want the smallest possible dependency footprint.	Your app benefits from LangChain abstractions and integrations.
You are debugging provider-specific behavior.	You are building larger applications with multiple AI workflow components.

What DeepSeek + LangChain actually means

DeepSeek provides the model endpoint and developer API. LangChain provides orchestration around that model endpoint. A DeepSeek LangChain integration does not mean Chat-Deep.ai becomes official, and it does not mean the DeepSeek API behaves exactly like the official DeepSeek web chat or mobile app.

The integration covered here is for the official DeepSeek API. DeepSeek’s public API uses an OpenAI-compatible request format, which makes it easier to connect through clients and frameworks that already support chat-completions-style APIs.

LangChain’s role is different. It helps you connect DeepSeek model calls to prompts, retrievers, tools, agents, structured output parsers, memory, tracing, and multi-step application logic.

LangChain package names

LangChain documents a dedicated DeepSeek integration package for both Python and JavaScript/TypeScript.

Language	Package	Main import	Use case
Python	`langchain-deepseek`	`from langchain_deepseek import ChatDeepSeek`	Python LangChain apps, RAG, tools, structured output, agents
JavaScript / TypeScript	`@langchain/deepseek`	`import { ChatDeepSeek } from "@langchain/deepseek";`	Node.js, TypeScript, LangChain JS apps, tools, structured output, streaming

LangChain package docs can lag behind provider model launches. Use LangChain docs for the wrapper and package interface, but use official DeepSeek docs for current model IDs, prices, context limits, and deprecation dates.

Current V4 model selection

For new LangChain work, choose between deepseek-v4-flash and deepseek-v4-pro.

Model	Recommended LangChain use	Notes
`deepseek-v4-flash`	Default choice for most chat, RAG answers, summaries, extraction, JSON-style tasks, support bots, classification, lightweight coding help, and cost-sensitive workloads.	Fast and economical. Use it first unless the task clearly needs stronger reasoning.
`deepseek-v4-pro`	Hard reasoning, complex coding, long-context analysis, tool planning, agentic workflows, multi-step debugging, and higher-value production tasks.	Use when quality and reasoning matter more than lowest token cost.
`deepseek-chat`	Migration notes only	Legacy alias currently routing to `deepseek-v4-flash` non-thinking mode.
`deepseek-reasoner`	Migration notes only	Legacy alias currently routing to `deepseek-v4-flash` thinking mode.

Python setup

Install the Python DeepSeek integration package:

pip install -qU langchain-deepseek

Set your DeepSeek API key in a server-side environment variable:

export DEEPSEEK_API_KEY="<your_deepseek_api_key>"

For local notebooks or scripts, you can prompt for the key without hard-coding it:

import getpass
import os

if not os.getenv("DEEPSEEK_API_KEY"):
    os.environ["DEEPSEEK_API_KEY"] = getpass.getpass("Enter your DeepSeek API key: ")

Python example with `deepseek-v4-flash`

This is the recommended starting point for most LangChain Python workflows.

from langchain_deepseek import ChatDeepSeek

llm = ChatDeepSeek(
    model="deepseek-v4-flash",
    temperature=0,
    max_retries=2,
)

messages = [
    (
        "system",
        "You are a concise assistant that explains technical topics clearly.",
    ),
    (
        "human",
        "Explain DeepSeek LangChain integration in three bullet points.",
    ),
]

ai_msg = llm.invoke(messages)
print(ai_msg.content)

Use this pattern for ordinary chat, RAG generation, summaries, extraction, rewriting, classification, and most production workflows.

Python example with `deepseek-v4-pro`

Use V4-Pro when the task is reasoning-heavy or agentic.

from langchain_deepseek import ChatDeepSeek

llm = ChatDeepSeek(
    model="deepseek-v4-pro",
    max_retries=2,
)

messages = [
    (
        "system",
        "You are a senior software engineering assistant.",
    ),
    (
        "human",
        "Review the architecture tradeoffs in a RAG system that uses tools and retrieval.",
    ),
]

ai_msg = llm.invoke(messages)

reasoning = ai_msg.additional_kwargs.get("reasoning_content")
answer = ai_msg.content

print(answer)

LangChain message objects may expose provider-specific fields such as reasoning_content through additional_kwargs or response metadata. Do not assume your exact wrapper version exposes every DeepSeek field in the same place. Test your installed package version before relying on reasoning traces, tool loops, or structured-output behavior.

TypeScript / JavaScript setup

Install the LangChain DeepSeek package for JavaScript or TypeScript:

npm install @langchain/deepseek @langchain/core

Set the API key server-side:

export DEEPSEEK_API_KEY="<your_deepseek_api_key>"

TypeScript example with `deepseek-v4-flash`

import { ChatDeepSeek } from "@langchain/deepseek";

const llm = new ChatDeepSeek({
  model: "deepseek-v4-flash",
  temperature: 0,
  maxRetries: 2,
});

const aiMsg = await llm.invoke([
  [
    "system",
    "You are a concise assistant that explains technical topics clearly.",
  ],
  [
    "human",
    "Explain DeepSeek LangChain integration in three bullet points.",
  ],
]);

console.log(aiMsg.content);

TypeScript example with `deepseek-v4-pro`

import { ChatDeepSeek } from "@langchain/deepseek";

const llm = new ChatDeepSeek({
  model: "deepseek-v4-pro",
  maxRetries: 2,
});

const aiMsg = await llm.invoke([
  [
    "system",
    "You are a senior software engineering assistant.",
  ],
  [
    "human",
    "Review the tradeoffs of using retrieval plus tools in an AI support workflow.",
  ],
]);

console.log(aiMsg.content);
console.log(aiMsg.additional_kwargs?.reasoning_content);

Keep JavaScript and TypeScript examples server-side. Do not expose DEEPSEEK_API_KEY in browser JavaScript, static frontend code, public logs, mobile bundles, or client-visible error messages.

LangChain doc drift and wrapper compatibility

There are two layers to keep separate:

DeepSeek official API facts: model names, pricing, context length, feature support, legacy alias retirement, and API behavior.
LangChain wrapper behavior: how ChatDeepSeek forwards provider-specific fields, exposes metadata, supports structured output, and handles tools in your installed package version.

DeepSeek’s official API docs are the source of truth for current V4 model IDs. LangChain’s docs are the source for package installation and wrapper usage. If LangChain examples still show deepseek-chat or deepseek-reasoner, treat those examples as older wrapper examples or migration references, not as current DeepSeek model guidance.

Practical rule: use deepseek-v4-flash and deepseek-v4-pro in new examples, then test your exact langchain-deepseek or @langchain/deepseek version before relying on advanced tool, agent, structured-output, or thinking-mode behavior.

Thinking mode in LangChain

DeepSeek V4 supports both thinking and non-thinking modes. Thinking mode is useful for harder reasoning, complex coding, long-context analysis, tool planning, and agentic workflows. Non-thinking mode is better for fast, simple, low-cost flows.

LangChain wrapper support for provider-specific fields can vary by version. If you need exact control over thinking: {"type": "enabled"} or thinking: {"type": "disabled"}, test whether your wrapper forwards that field correctly. If it does not, use a direct DeepSeek API call through the OpenAI SDK for that route.

Goal	Recommended path	Why
Normal LangChain chat or RAG generation	`ChatDeepSeek(model="deepseek-v4-flash")`	Best starting point for cost-sensitive workflows.
Hard reasoning or agentic planning	`ChatDeepSeek(model="deepseek-v4-pro")`	Better fit for complex reasoning and long-context work.
Exact thinking toggle required	Use direct DeepSeek API / OpenAI SDK route, or test wrapper pass-through	Provider-specific parameters may depend on wrapper version.
Thinking + tool-call loop	Test minimal case before production	Reasoning and tool history handling can be wrapper-sensitive.

For API-level thinking details, read the DeepSeek Thinking Mode guide.

Structured output with DeepSeek and LangChain

Structured output means you want a predictable shape, often JSON. DeepSeek’s API-level JSON Output uses response_format={"type":"json_object"}, and the prompt should explicitly ask for JSON and include an example JSON shape. In LangChain, structured-output helpers may vary by wrapper and version.

Python structured-output pattern

from typing import Literal
from pydantic import BaseModel, Field
from langchain_deepseek import ChatDeepSeek

class ReviewIssue(BaseModel):
    """One actionable issue found in a code review."""
    severity: Literal["critical", "major", "minor"] = Field(description="Issue severity")
    file: str = Field(description="File path or unknown")
    issue: str = Field(description="What is wrong")
    suggested_fix: str = Field(description="Smallest safe fix")

class ReviewReport(BaseModel):
    """Structured code review report."""
    summary: str = Field(description="Short review summary")
    issues: list[ReviewIssue] = Field(description="Actionable issues")
    tests_to_add: list[str] = Field(description="Recommended tests")

llm = ChatDeepSeek(
    model="deepseek-v4-flash",
    temperature=0,
    max_retries=2,
)

structured_llm = llm.with_structured_output(ReviewReport)

report = structured_llm.invoke(
    "Return a json code review report for this diff: ..."
)

print(report)

TypeScript structured-output pattern

import { ChatDeepSeek } from "@langchain/deepseek";
import { z } from "zod";

const ReviewReport = z.object({
  summary: z.string(),
  severity: z.enum(["critical", "major", "minor"]),
  suggested_fix: z.string(),
});

const llm = new ChatDeepSeek({
  model: "deepseek-v4-flash",
  temperature: 0,
});

const structured = llm.withStructuredOutput(ReviewReport, {
  name: "ReviewReport",
});

const result = await structured.invoke(
  "Return a json review report for this change: ..."
);

console.log(result);

If with_structured_output or withStructuredOutput fails in your exact package version, use a simpler fallback: ask for valid JSON explicitly, use DeepSeek API-level JSON Output where your wrapper supports forwarding it, and validate the parsed result with your own schema.

For production, never treat structured model output as trusted just because it parses. Validate required keys, enum values, number ranges, nulls, and business rules.

Tool calling and agents

Tool calling is useful when the model needs to request an external action: checking an order, searching a database, calling a weather service, querying a CRM, inspecting repository metadata, or running a calculation. The model proposes the tool call; your application executes the real function and returns the result.

Python tool pattern

from langchain_deepseek import ChatDeepSeek
from langchain_core.tools import tool

@tool
def get_order_status(order_id: str) -> str:
    """Return the status of an order by ID."""
    # Replace this with your real database or API lookup.
    return "Order is currently processing."

llm = ChatDeepSeek(
    model="deepseek-v4-flash",
    temperature=0,
    max_retries=2,
)

llm_with_tools = llm.bind_tools([get_order_status])

response = llm_with_tools.invoke(
    "Check the status of order A123 and explain it briefly."
)

print(response)

TypeScript tool pattern

import { ChatDeepSeek } from "@langchain/deepseek";
import { tool } from "@langchain/core/tools";
import { z } from "zod";

const getOrderStatus = tool(
  async ({ order_id }) => {
    return `Order ${order_id} is currently processing.`;
  },
  {
    name: "get_order_status",
    description: "Return the status of an order by ID.",
    schema: z.object({
      order_id: z.string().describe("The order ID to look up."),
    }),
  }
);

const llm = new ChatDeepSeek({
  model: "deepseek-v4-flash",
  temperature: 0,
});

const llmWithTools = llm.bindTools([getOrderStatus]);

const response = await llmWithTools.invoke(
  "Check the status of order A123 and explain it briefly."
);

console.log(response);

Always validate tool arguments before execution. Do not allow arbitrary shell commands, database writes, payments, account changes, deletion actions, file-system actions, or outbound messages without strict controls and human approval.

Use deepseek-v4-flash for routine tool routing. Use deepseek-v4-pro when the tool workflow needs stronger reasoning, multi-step planning, difficult coding, or long-context interpretation.

RAG with DeepSeek and LangChain

RAG, or retrieval-augmented generation, is one of the most common LangChain use cases. DeepSeek can serve as the chat or generation model in a RAG pipeline. The retriever, embedding model, and vector database are separate pieces of the system.

Do not claim DeepSeek provides a first-party embeddings API unless an official DeepSeek source confirms it. A practical DeepSeek RAG architecture usually looks like this:

Load documents from files, websites, databases, or internal knowledge bases.
Split documents into chunks.
Embed those chunks with a separate embedding model.
Store the vectors and text chunks in a vector database.
Retrieve relevant chunks for each user question.
Pass the retrieved context to ChatDeepSeek.
Generate an answer with deepseek-v4-flash or deepseek-v4-pro.

Simplified Python RAG skeleton

from langchain_deepseek import ChatDeepSeek
from langchain_core.prompts import ChatPromptTemplate

llm = ChatDeepSeek(
    model="deepseek-v4-flash",
    temperature=0,
    max_retries=2,
)

prompt = ChatPromptTemplate.from_messages([
    (
        "system",
        "Answer using only the provided context. If the context is insufficient, say you do not know."
    ),
    (
        "human",
        "Context:\n{context}\n\nQuestion:\n{question}"
    ),
])

# Replace this with your own vector store retriever.
# retriever = your_vector_store.as_retriever()

question = "What does our refund policy say about unused balances?"
docs = retriever.invoke(question)

context = "\n\n".join(doc.page_content for doc in docs)
messages = prompt.format_messages(context=context, question=question)

answer = llm.invoke(messages)
print(answer.content)

For production RAG, measure retrieval quality separately from model quality. Poor chunking, weak embeddings, missing metadata, or an overly broad retriever can make any model produce weaker answers. Keep retrieved context concise, relevant, and easy for the model to use.

Streaming, usage, cost, and context caching

Streaming can improve perceived latency because users see output as it arrives instead of waiting for the full answer. LangChain supports streaming through chat model streaming APIs, but provider-specific chunk metadata can vary by wrapper version.

DeepSeek usage and cost are token-based. For current V4 pricing, track the model ID, prompt tokens, completion tokens, cache-hit input tokens, cache-miss input tokens, and reasoning tokens when available.

Model	Input cache hit	Input cache miss	Output	Best LangChain use
`deepseek-v4-flash`	$0.028 / 1M tokens	$0.14 / 1M tokens	$0.28 / 1M tokens	Default for cost-sensitive chains, RAG, summaries, extraction, and routine tools.
`deepseek-v4-pro`	$0.145 / 1M tokens	$1.74 / 1M tokens	$3.48 / 1M tokens	Hard reasoning, coding, long-context, and agentic workflows.

LangChain apps can make multiple model calls per user request. A single user answer may include retrieval, prompt formatting, tool loops, retries, re-ranking, structured output repair, and final generation. Track cost per final user-visible answer, not only cost per individual model call.

DeepSeek context caching is enabled by default. Repeated prompt prefixes can become cache hits, so stable system prompts, repeated document prefixes, few-shot examples, and consistent prompt layout can matter for cost. Track prompt_cache_hit_tokens and prompt_cache_miss_tokens when your wrapper exposes them.

For detailed accounting, read the DeepSeek Token Usage guide and the DeepSeek API Pricing guide.

Legacy aliases: `deepseek-chat` and `deepseek-reasoner`

The old names deepseek-chat and deepseek-reasoner are now compatibility aliases. They currently route to deepseek-v4-flash modes and are scheduled for retirement after July 24, 2026, 15:59 UTC.

Legacy alias	Current compatibility behavior	Recommended LangChain replacement
`deepseek-chat`	Routes to `deepseek-v4-flash` non-thinking mode	`ChatDeepSeek(model="deepseek-v4-flash")`
`deepseek-reasoner`	Routes to `deepseek-v4-flash` thinking mode	`ChatDeepSeek(model="deepseek-v4-pro")` for harder reasoning, or `deepseek-v4-flash` for lower-cost reasoning

Migration rule: replace older LangChain examples that use deepseek-chat with deepseek-v4-flash, and replace reasoning-heavy examples that use deepseek-reasoner with deepseek-v4-pro when quality matters more than lowest cost.

Common errors and fixes

When a DeepSeek LangChain integration fails, debug it in layers: package version, API key, billing, model name, wrapper behavior, request shape, tool schema, structured-output parser, and then application logic.

Issue	Likely cause	Fix
Old examples still use `deepseek-chat`	LangChain docs or older blog posts have not fully caught up with DeepSeek V4 naming	Use `deepseek-v4-flash` or `deepseek-v4-pro` in new code.
400 invalid request format	Invalid message structure, bad tool-loop handling, or unsupported provider-specific field	Test a minimal direct API call, then add LangChain layers back one at a time.
401 authentication failed	Wrong, missing, or malformed API key	Check `DEEPSEEK_API_KEY` and server environment loading.
402 insufficient balance	DeepSeek account balance issue	Check the official DeepSeek platform billing page.
422 invalid parameters	Unsupported parameter, invalid schema, or wrapper forwarding issue	Remove unsupported fields and compare against DeepSeek API docs.
429 rate limit reached	Too much concurrency or provider pressure	Reduce concurrency, add backoff, and use retry budgets.
500 / 503	Temporary server issue or overload	Retry after a brief wait and use graceful fallback.
Structured output fails	Schema too broad, parser mismatch, wrapper not forwarding JSON mode, or truncated output	Use a smaller schema, explicit JSON instructions, enough output budget, validation, and retry/repair logic.
Tool flow fails	Tool schema mismatch, missing tool result, missing tool call ID, or invalid argument parsing	Validate arguments and follow the model-proposes / app-executes / tool-result-returned loop.
Thinking output appears in metadata	Wrapper exposes `reasoning_content` separately from final `content`	Display final `content` by default and treat reasoning metadata as a technical field.

Production checklist

Use deepseek-v4-flash or deepseek-v4-pro in new LangChain examples.
Keep deepseek-chat and deepseek-reasoner only in migration notes.
Pin package versions for langchain-deepseek, @langchain/deepseek, langchain-core, and related packages.
Keep the DeepSeek API key server-side.
Use environment variables or a secrets manager for DEEPSEEK_API_KEY.
Use deepseek-v4-flash first for cost-sensitive RAG, summaries, extraction, and routine tools.
Use deepseek-v4-pro for hard reasoning, complex coding, long-context, and agentic workflows.
Do not rely on old V3.2 pricing, 128K context, or V3.2 model naming in current hosted API pages.
Validate JSON outputs before using them in automation.
Validate tool arguments before executing tools.
Use human approval for sensitive actions such as payments, account changes, deletion, or outbound messages.
Track token usage, cache hits, cache misses, model calls per user request, retries, latency, and tool-loop depth.
Test exact wrapper behavior for structured output, tool calls, streaming, reasoning fields, and provider-specific parameters.
Review official DeepSeek pricing before scaling traffic.
Review official privacy, terms, and data-handling requirements before sending sensitive data.
Use retry budgets and backoff, not unlimited retries.
Keep old screenshots out of the article if they still show V3.2, 128K, or old pricing.

Next step: choose your DeepSeek developer path

If you want to…	Go here
Try prompts quickly before building	Chat-Deep.ai browser chat
Build directly with the official API	DeepSeek API guide
Use Python without LangChain	DeepSeek Python SDK guide
Use Node.js or TypeScript without LangChain	DeepSeek Node.js TypeScript guide
Use the OpenAI SDK with DeepSeek	OpenAI SDK with DeepSeek guide
Return valid JSON from the API	DeepSeek JSON Output guide
Use tools and function calling	DeepSeek Tool Calls guide
Handle thinking-mode behavior	DeepSeek Thinking Mode guide
Track real token usage and cost	DeepSeek Token Usage guide
Check API prices	DeepSeek API pricing
Compare local vs API workflows	DeepSeek Local vs API guide
Check availability or API issues	DeepSeek status checker

FAQ

Does DeepSeek work with LangChain?

Yes. DeepSeek can be used through LangChain’s ChatDeepSeek integration. For Python, use langchain-deepseek. For JavaScript or TypeScript, use @langchain/deepseek.

Which LangChain package should I install for DeepSeek?

For Python, install langchain-deepseek. For JavaScript or TypeScript, install @langchain/deepseek and @langchain/core.

Which DeepSeek model should I use with LangChain now?

Use deepseek-v4-flash for most fast and economical LangChain workflows. Use deepseek-v4-pro for harder reasoning, complex coding, long-context analysis, and agentic workflows.

Should I still use `deepseek-chat` or `deepseek-reasoner`?

Not for new code. They are legacy compatibility aliases. deepseek-chat currently routes to deepseek-v4-flash non-thinking mode, and deepseek-reasoner currently routes to deepseek-v4-flash thinking mode.

Why do some LangChain examples still show old DeepSeek model names?

Some LangChain examples and wrapper notes may lag behind DeepSeek API releases. Use LangChain docs for package and wrapper usage, but use official DeepSeek docs for current model IDs, pricing, context limits, and deprecation dates.

Can I use DeepSeek for LangChain RAG?

Yes. DeepSeek can be the chat or generation model in a LangChain RAG system. Use a separate embedding model and vector store for retrieval, then pass retrieved context to ChatDeepSeek.

Does DeepSeek provide embeddings for LangChain?

Do not assume DeepSeek provides a first-party embeddings API unless official DeepSeek docs confirm it. For RAG, choose a separate embedding provider and vector database.

Does DeepSeek support tool calling in LangChain?

DeepSeek’s current API supports Tool Calls on current V4 models. LangChain wrapper behavior can vary by package version, so test your exact ChatDeepSeek version before relying on advanced tool or agent flows.

Does DeepSeek support structured output in LangChain?

DeepSeek supports API-level JSON Output, and LangChain provides structured-output helpers. In production, test the exact wrapper version, keep schemas small, and validate parsed output before using it.

Can I use `ChatOpenAI` with DeepSeek’s base URL instead of `ChatDeepSeek`?

For simple chat calls, a generic OpenAI-compatible wrapper may work. For DeepSeek-specific fields such as reasoning_content, cache usage, provider metadata, structured output, or tool behavior, use ChatDeepSeek or test that your wrapper preserves the fields you need.

How do I control DeepSeek API costs in LangChain?

Track model ID, input tokens, output tokens, cache-hit tokens, cache-miss tokens, retries, and the number of model calls per user request. Also check the official DeepSeek pricing page before production use.

Is Chat-Deep.ai the official DeepSeek website?

No. Chat-Deep.ai is an independent DeepSeek guide and browser access site. It is not affiliated with DeepSeek, DeepSeek.com, the official DeepSeek app, LangChain, or the official DeepSeek developer platform.

Conclusion

The current DeepSeek LangChain setup is straightforward: install the LangChain DeepSeek package, set DEEPSEEK_API_KEY, instantiate ChatDeepSeek, and use deepseek-v4-flash or deepseek-v4-pro as the model ID.

The main production work is not the first model call. It is validating wrapper support, managing conversation history, controlling tool execution, validating structured output, monitoring token usage, handling retries, and keeping all examples aligned with the current DeepSeek V4 API model names.

Use deepseek-v4-flash as the default for most LangChain apps. Use deepseek-v4-pro when the route truly needs stronger reasoning, long-context analysis, complex coding, or agentic planning. Keep deepseek-chat and deepseek-reasoner only as migration aliases.

Official sources and last verified

Last verified: April 24, 2026. DeepSeek model names, pricing, feature support, context limits, wrapper behavior, and deprecation dates can change. Use the official sources below before shipping production code.

Table of contents