Run DeepSeek in LM Studio: Models, Settings & Local API

Run DeepSeek models locally in LM Studio: choose a checkpoint and quantization, tune settings, start the local API, and secure server access. DeepSeek’s hosted catalog, Vision and Files contracts, official V4 weight links, and LM Studio requirements and endpoints were rechecked on August 25, 2026.

Important current-model note: DeepSeek’s hosted API catalog documents three IDs: the text models deepseek-v4-flash and deepseek-v4-pro, plus the experimental deepseek-v4-flash-vision-exp for image-and-text input with text output. All three support the native Responses API. The former deepseek-chat and deepseek-reasoner aliases passed their July 24, 2026 retirement deadline.

Hosted aliases and local weights are different contracts. DeepSeek publishes official open weights for DeepSeek-V4-Flash-0731 and DeepSeek-V4-Pro-0813, but LM Studio still needs a compatible local quantization and the exact model identifier it lists or returns from GET /v1/models. A hosted alias, hosted Vision release, or DeepSeek Files API file_id is not automatically a local LM Studio model or file.

LM Studio requirements rechecked August 25, 2026: LM Studio supports Apple Silicon with macOS 14 or later and recommends 16 GB RAM; Intel Macs are not supported. Windows x64 requires AVX2 and supports x64 or ARM, with 16 GB RAM and 4 GB dedicated VRAM recommended. Linux supports x64 and ARM64 and documents Ubuntu 20.04 or later. Model size, quantization, context length, and runtime overhead still determine whether a selected model fits.

This is an independent, unofficial Chat-Deep.ai guide. It is designed to help users of DeepSeek AI Chat understand the difference between hosted DeepSeek API usage and local DeepSeek checkpoints. For hosted API examples, see our DeepSeek API guide. For local deployment beyond LM Studio, see How to Install DeepSeek Locally and DeepSeek with vLLM.

Quick Answer: What This Page Covers

• Best local starting point: use a trusted DeepSeek R1-style distilled checkpoint, such as a 7B/8B model, before moving to 14B, 32B, 70B, or larger variants.
• Best baseline temperature: for DeepSeek R1-style reasoning models, start around 0.6. DeepSeek’s own R1 recommendations place temperature in the 0.5–0.7 range, with 0.6 recommended.
• Best local context approach: use the smallest context window that fits your task. Do not assume every local DeepSeek checkpoint should be run at its maximum context length.
• Best server endpoint: for most integrations, use LM Studio’s OpenAI-compatible endpoint at http://localhost:1234/v1/chat/completions or http://localhost:1234/v1/responses.
• Best privacy setting: keep the LM Studio server on localhost unless you intentionally need LAN access. Do not expose the server directly to the public internet.

DeepSeek in LM Studio vs DeepSeek API

LM Studio runs local model files on your own computer. The official DeepSeek API runs hosted models through DeepSeek’s platform. The two workflows are related, but the model names, performance profile, context limits, pricing, and operational responsibilities are different.

Workflow	Use this when	Model identifier	Key note
DeepSeek API for text	You want hosted V4 reasoning, agents, coding, or text generation without local hardware.	deepseek-v4-flash or deepseek-v4-pro	Hosted aliases at https://api.deepseek.com; they are not LM Studio model IDs.
DeepSeek API for images	You need hosted screenshot, chart, OCR, or image understanding.	deepseek-v4-flash-vision-exp	Experimental image-and-text input with text output. DeepSeek Files file_id values apply only to this hosted workflow.
LM Studio local model	You want local/offline inference, privacy, experimentation, or a private local server.	The exact local ID shown by LM Studio, such as a compatible R1 distill or V4 quantization.	Local capability depends on the downloaded checkpoint, quantization, prompt template, runtime, and hardware. See DeepSeek V4.

DeepSeek V4 is the current hosted family, with distinct release labels: the Flash API serves the public-beta DeepSeek-V4-Flash-0731 release, DeepSeek-V4-Pro-0813 is GA on App, Web, and API after the August 13 DeepSeek update, and the experimental deepseek-v4-flash-vision-exp was added for supported image-and-text input on August 21. All three hosted IDs support the native Responses API, but Vision is an API service—not a checkpoint bundled with LM Studio. This guide focuses mainly on local R1-style reasoning checkpoints because those are the practical DeepSeek options most users run on consumer or workstation hardware. Local availability depends on a compatible checkpoint, quantization, prompt template, and runtime.

Choosing a DeepSeek Model for LM Studio

For local use, most users should start with a distilled DeepSeek reasoning model rather than the full 671B-parameter R1 model. DeepSeek’s official R1 repository lists the full DeepSeek-R1 and DeepSeek-R1-Zero models as 671B total parameters with 37B activated parameters and 128K context length. That scale is not practical for ordinary laptops or desktops. The same official materials also list distilled 1.5B, 7B, 8B, 14B, 32B, and 70B models based on Qwen and Llama families, which are more realistic for local deployment.

A practical model-selection path looks like this:

• Low-memory laptop or CPU-first machine: try a 1.5B, 7B, or 8B quantized checkpoint.
• Modern consumer GPU or Apple Silicon with enough unified memory: try an 8B or 14B checkpoint first.
• High-end workstation: try 32B if RAM/VRAM allows it.
• Server-grade setup: consider 70B or larger models only if you understand memory, quantization, tensor parallelism, and runtime limitations.
• Full 671B R1/R1-0528: treat this as a research/server deployment, not a normal LM Studio desktop setup.

Recommended current local candidate: DeepSeek-R1-0528-Qwen3-8B is an official DeepSeek model card describing a distilled 8B model based on Qwen3 8B and post-trained using chain-of-thought from DeepSeek-R1-0528. It can be a strong starting point for users who want a compact reasoning model. For LM Studio specifically, you may need a GGUF or MLX conversion from LM Studio Hub or another trusted publisher because the original Hugging Face model is not necessarily packaged in the exact format your local runtime expects.

Check the publisher before download. Prefer the official deepseek-ai organization, LM Studio’s trusted listings, or reputable conversions that clearly link back to the official source model. Avoid random mirrors, renamed uploads, or model cards that do not explain what was converted and from where.

Quantized vs Full-Precision DeepSeek Models

LM Studio users commonly run quantized files because quantization reduces memory use and often improves practical local speed. A 4-bit or 8-bit GGUF/MLX file can make a larger model usable on hardware that cannot load full-precision weights. The trade-off is that heavier quantization can reduce answer quality, especially for reasoning, coding, and long-output tasks.

Quantization choice	When to use it	Trade-off
Q8 / 8-bit	You have enough memory and want quality close to full precision.	Larger file and memory footprint.
Q5 / Q6	You want a balance of quality and memory use.	Good middle ground for many 8B/14B workflows.
Q4	You need the model to fit on modest hardware.	Usually acceptable, but reasoning quality may drop compared with higher precision.
Q2 / Q3 or very aggressive quantization	Only when memory is extremely limited.	Higher risk of degraded reasoning, repetition, or formatting errors.

For production-like reasoning tasks, prefer the highest-quality quantization your machine can run comfortably. A smaller model at a better quantization can be more useful than a larger model forced into an overly aggressive quantization.

Getting DeepSeek into LM Studio

There are two safe paths for adding a DeepSeek model to LM Studio.

Path A: Download from LM Studio’s model catalog

Open LM Studio, go to the model discovery/catalog area, search for “DeepSeek”, and review the available models. Before downloading, check the publisher, model name, parameter size, quantization, required memory, and whether the listing links to the official source. After downloading, the model should appear in your local model library and can be loaded from the LM Studio interface.

This path is best for most users because LM Studio usually handles the local model metadata, prompt template, and runtime details more cleanly than a manual import.

Path B: Import a local GGUF file

If you already downloaded a compatible GGUF file from a trusted source, LM Studio documents an import flow using the lms command:

lms import /path/to/model.gguf

You can also place model files in LM Studio’s expected local directory structure:

~/.lmstudio/models/
└── publisher/
    └── model/
        └── model-file.gguf

After import, refresh or restart LM Studio and check whether the model appears in your local library. If it does not appear, verify the file format, folder structure, model metadata, and whether your LM Studio version supports the runtime required by that model.

Baseline Settings for DeepSeek R1-Style Models in LM Studio

Settings are not universal. They depend on the exact checkpoint, quantization, prompt template, and hardware. The values below are safe starting points for local DeepSeek R1-style reasoning checkpoints, especially distilled models.

Setting	Recommended starting point	Why
Temperature	0.6	DeepSeek’s R1 guidance recommends 0.5–0.7, with 0.6 as the recommended value for reducing endless repetition or incoherent output.
Top-p	0.95 as a starting point	DeepSeek’s R1 evaluation setup used 0.95 for benchmarks requiring sampling. Adjust only after testing.
Top-k	Leave default first, or try 40–50 if you need local tuning.	Top-k is a runtime sampling control in tools like LM Studio; it is not a required official DeepSeek value.
Max output tokens	1024–4096 for normal work; more for hard reasoning.	Reasoning models may spend many tokens before finalizing an answer.
Context length	4096–8192 for most local tasks.	Higher context uses more memory and slows inference. Raise only when the task needs it.
System prompt	Use model-specific guidance. Keep it minimal by default.	Original R1 guidance avoided system prompts, while R1-0528 documentation says system prompt is supported. Do not force one rule across every checkpoint.
Streaming	Enabled	Streaming improves interactivity and helps you notice long or stuck generations early.
Repeat penalty	Mild, if needed.	Useful for repeated phrases or loops, but too much can damage answer quality.

About <think>...</think> traces

Some DeepSeek reasoning checkpoints may produce visible reasoning traces wrapped in <think>...</think>. This depends on the checkpoint, prompt template, runtime, and model version. Do not assume every local DeepSeek model will expose the same pattern. For user-facing products, it is often better to show only the final answer and hide or strip internal-style reasoning traces during post-processing.

For the original DeepSeek-R1 series, DeepSeek recommended avoiding system prompts and placing instructions in the user prompt. For DeepSeek-R1-0528 and the R1-0528-Qwen3-8B model card, DeepSeek notes that system prompts are supported and that it is no longer required to force the model to begin with <think>. This is why the safest advice is: use the prompt template and model card for the exact model you are running.

Speed vs Stability Tuning Playbook

If generation is too slow

• Use a smaller checkpoint, such as 7B/8B instead of 14B/32B.
• Use a more practical quantization, such as Q4/Q5/Q6 instead of full precision.
• Reduce context length. Very large context windows slow every request and reserve memory.
• Enable GPU offload only as far as your VRAM comfortably allows.
• Close memory-heavy applications before loading the model.
• Use the official DeepSeek API instead of local inference when you need hosted V4 performance and do not need local-only privacy.

If answers repeat or loop

• Keep temperature near 0.6 or lower it slightly to 0.5.
• Add a mild repetition penalty if the same phrases repeat.
• Reduce overlong context, especially if previous turns contain repetitive text.
• Start a fresh chat for unrelated tasks.
• Try a higher-quality quantization or a larger model if the issue persists.

If answers are unstable across runs

• Lower temperature and avoid changing multiple sampling settings at once.
• Use clear prompts with explicit output requirements.
• For math and formal reasoning, add an instruction such as: “Please reason step by step and put the final answer clearly at the end.”
• Run multiple tests for benchmark-like evaluations instead of relying on one answer.

If the model will not load

• Confirm the file is a supported local format for your LM Studio runtime.
• Use a smaller or more quantized file if RAM/VRAM is insufficient.
• Lower the configured context length before loading.
• Update LM Studio and the relevant runtime.
• Re-download the model if the file may be incomplete or corrupted.
• Use lms log stream to inspect errors during loading.

Running DeepSeek as a Local Server in LM Studio

LM Studio can serve local models through a local API server. This is useful when you want to connect a local DeepSeek model to scripts, internal tools, coding assistants, or applications that expect an OpenAI-compatible API.

LM Studio API choices — rechecked August 25, 2026: LM Studio 0.4 introduced its native v1 REST API and recommends /api/v1/* for new LM Studio-specific applications. Use POST /api/v1/chat for native stateful chat and model-management features. Continue to use /v1/chat/completions or /v1/responses when an OpenAI-compatible client expects those interfaces.

Authentication: the local server binds to 127.0.0.1 and does not require authentication by default. LM Studio 0.4 or newer can require API tokens. Enable authentication before LAN access, enable CORS only when necessary, and do not expose the server publicly without deliberate network and access controls.

To start the server, open LM Studio’s Developer tab and toggle the server on, or use the CLI:

lms server start --bind 127.0.0.1

LM Studio’s official documentation shows that the server can run on localhost and can also be served on the local network when explicitly enabled. By default, examples commonly use port 1234.

OpenAI-compatible endpoints

For most integrations, use the OpenAI-compatible API. LM Studio documents support for endpoints including:

• GET /v1/models
• POST /v1/responses
• POST /v1/chat/completions
• POST /v1/embeddings
• POST /v1/completions for legacy-style completions

For chat-tuned DeepSeek reasoning checkpoints, use /v1/chat/completions or /v1/responses. Avoid the legacy completions endpoint unless your use case specifically requires raw text completion behavior.

Find the correct local model ID

Do not guess the model name. Query LM Studio first:

curl http://localhost:1234/v1/models

Then copy the exact model ID from the response and use it in your requests. This prevents a common mistake: sending hosted DeepSeek IDs such as deepseek-v4-flash, deepseek-v4-pro, or deepseek-v4-flash-vision-exp—or a hosted Files API file_id—to a local LM Studio server whose checkpoint has a different name and capability contract.

cURL example

curl http://localhost:1234/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "REPLACE_WITH_LM_STUDIO_MODEL_ID",
    "messages": [
      {
        "role": "user",
        "content": "Explain the difference between local DeepSeek in LM Studio and the official DeepSeek API."
      }
    ],
    "temperature": 0.6
  }'

Python example using the OpenAI client

import os
from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:1234/v1",
    api_key=os.environ.get("LM_API_TOKEN", "lm-studio"),
)

completion = client.chat.completions.create(
    model="REPLACE_WITH_THE_ID_FROM_GET_V1_MODELS",
    messages=[{"role": "user", "content": "Give me a short checklist for running this local model safely."}],
    temperature=0.6,
    max_tokens=800,
)

print(completion.choices[0].message.content)

lm-studio is only a placeholder accepted by OpenAI clients when authentication is disabled. Use the actual LM Studio token when authentication is enabled.

Using the Responses endpoint

LM Studio also supports POST /v1/responses in its OpenAI-compatible layer. This can be useful for newer tools that use response-style APIs:

curl http://localhost:1234/v1/responses \
  -H "Content-Type: application/json" \
  -d '{
    "model": "REPLACE_WITH_LM_STUDIO_MODEL_ID",
    "input": "Summarize how to keep a local DeepSeek server private."
  }'

Use whichever endpoint your client library or integration supports best. The important part is to keep the base URL pointed to LM Studio and the model parameter set to the local LM Studio model ID.

Local Server Safety and Privacy

Running DeepSeek locally gives you more control over your data, but only if you keep the local server properly isolated.

• Keep localhost as the default. localhost means only your own machine can call the server.
• Enable LAN access only when needed. If you serve on your local network, other devices on that network may be able to reach the model.
• Use API tokens when sharing access. LM Studio supports token-based authentication in newer versions. Enable it before allowing access beyond your own machine.
• Do not expose LM Studio directly to the public internet. Avoid router port forwarding and public tunnels unless you also add strong authentication, HTTPS, firewall rules, and monitoring.
• Be careful with MCP or tool integrations. If a model has access to tools, file operations, browser automation, or plugins, unauthorized API access becomes much riskier.
• Clear local history when needed. Local inference keeps prompts on your device, but chat history, logs, or app state may still remain on disk depending on your LM Studio settings.

LM Studio’s own offline documentation says local chats, document processing, and local server requests can stay local once model files are downloaded. Internet access is still needed for actions such as searching for models, downloading models, downloading runtimes, or checking for updates.

Troubleshooting DeepSeek in LM Studio

The server is running, but my app cannot connect

• Confirm the server is actually running in the Developer tab or with lms server start.
• Use http://localhost:1234/v1 for the OpenAI-compatible base URL on the same machine.
• Use the LAN IP only if “serve on local network” is enabled and your firewall allows it.
• If authentication is enabled, include Authorization: Bearer YOUR_TOKEN.
• List available models with GET /v1/models and use the exact local ID.
• Check lms log stream for invalid JSON, unknown model IDs, or runtime errors.

The model responds with garbled text

• Verify that you are using the correct prompt template for the model.
• Re-download through LM Studio’s catalog if a manual import introduced metadata issues.
• Try a less aggressive quantization.
• Confirm the model files and tokenizer/config files come from the expected source.

The model ignores instructions

• Use clear user prompts and keep system prompts minimal unless the model card recommends otherwise.
• Reduce temperature if outputs drift.
• Use a larger or better-quantized checkpoint for complex tasks.
• For structured output, use explicit examples and validate the output in code.

When to Use Local LM Studio vs the Official DeepSeek API

Need	Better choice	Reason
Offline/private experimentation	LM Studio	Prompts can stay on your device after the model and runtime are downloaded.
Hosted V4 text quality and 1M official context	DeepSeek API	Use deepseek-v4-flash or deepseek-v4-pro.
Hosted screenshot, chart, or image understanding	DeepSeek API	Use the experimental deepseek-v4-flash-vision-exp; URLs, inline Base64, and hosted Files file_id inputs are supported.
Learning local LLM workflows	LM Studio	Use its model catalog, exact local model IDs, and OpenAI-compatible endpoints.
Running official V4 weights locally	Server-class local setup	Flash 0731 and Pro 0813 weights are available, but their scale and runtime requirements make them unsuitable for most desktops.
Testing smaller reasoning models	LM Studio	Use trusted R1-style distilled checkpoints and tune locally.

Wrap-Up

LM Studio is a practical way to run DeepSeek-style reasoning models locally, especially distilled R1 and R1-0528 checkpoints. Start with an 8B-class model, use a trusted source, keep temperature around 0.6, avoid oversized context windows, and use LM Studio’s local server only on localhost unless you intentionally need network access.

For current hosted DeepSeek API work, choose deepseek-v4-flash or deepseek-v4-pro for text, or deepseek-v4-flash-vision-exp for supported image-and-text input, and set thinking mode deliberately. For LM Studio, use only the exact local model ID and capabilities returned by the server; hosted model IDs, Files API references, and local checkpoints are not interchangeable.

Continue with these related Chat-Deep.ai resources:

• DeepSeek AI Chat homepage
• DeepSeek Models Hub
• DeepSeek V4 guide
• DeepSeek R1 guide
• DeepSeek Local vs API
• DeepSeek troubleshooting guide
• Chat-Deep.ai security notes

Official Sources

• DeepSeek Models & Pricing
• DeepSeek API Change Log
• DeepSeek Vision guide
• DeepSeek Files API guide
• Official DeepSeek-V4-Flash-0731 model card
• Official DeepSeek-V4-Pro-0813 model card
• LM Studio system requirements
• LM Studio model downloads and quantization guidance
• LM Studio OpenAI-compatible endpoints

FAQ