DeepSeek Complete Guide 2026: V4 Models, API Integration, and Deployment

# BAD — will stop working after July 24, 2026
model = "deepseek-chat"          # deprecated

# GOOD — use V4 model identifiers
model = "deepseek-v4-flash"      # cost-optimized
model = "deepseek-v4-pro"        # maximum capability

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ.get("DEEPSEEK_API_KEY"),
    base_url="https://api.deepseek.com"
)

response = client.chat.completions.create(
    model="deepseek-v4-flash",
    messages=[
        {"role": "system", "content": "You are a helpful coding assistant."},
        {"role": "user", "content": "Write a Python function to merge two sorted lists."}
    ],
    max_tokens=1024,
    temperature=0.3
)

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

stream = client.chat.completions.create(
    model="deepseek-v4-flash",
    messages=[{"role": "user", "content": "Explain how transformers work in 3 paragraphs."}],
    stream=True
)

for chunk in stream:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)

import json

response = client.chat.completions.create(
    model="deepseek-v4-pro",
    messages=[
        {"role": "user", "content": "Extract the company name, revenue, and year from: 'Acme Corp reported $12.5M revenue in 2025.'"}
    ],
    functions=[{
        "name": "extract_financial_data",
        "description": "Extract structured financial information",
        "parameters": {
            "type": "object",
            "properties": {
                "company": {"type": "string"},
                "revenue": {"type": "number"},
                "year": {"type": "integer"}
            },
            "required": ["company", "revenue", "year"]
        }
    }],
    function_call={"name": "extract_financial_data"}
)

args = json.loads(response.choices[0].message.function_call.arguments)
print(args)  # {'company': 'Acme Corp', 'revenue': 12500000, 'year': 2025}

response = client.embeddings.create(
    model="deepseek-v4-flash",  # embeddings supported on Flash tier
    input="DeepSeek V4 supports 1M token context windows."
)
embedding = response.data[0].embedding
print(f"Dimension: {len(embedding)}")  # typically 2048 or 4096

# Install vLLM with DeepSeek support (vLLM >= 0.8.0 required)
pip install vllm

# Serve V4-Flash with tensor parallelism across 2 GPUs
python -m vllm.entrypoints.openai.api_server \
    --model deepseek-ai/DeepSeek-V4-Flash \
    --tensor-parallel-size 2 \
    --max-model-len 131072 \
    --gpu-memory-utilization 0.95 \
    --port 8000

local_client = OpenAI(
    api_key="not-needed",
    base_url="http://localhost:8000/v1"
)

response = local_client.chat.completions.create(
    model="deepseek-ai/DeepSeek-V4-Flash",
    messages=[{"role": "user", "content": "Hello from local deployment!"}]
)

FROM nvidia/cuda:12.4-runtime-ubuntu22.04

RUN pip install vllm

# Download model on container start
ENTRYPOINT ["python", "-m", "vllm.entrypoints.openai.api_server", \
    "--model", "deepseek-ai/DeepSeek-V4-Flash", \
    "--tensor-parallel-size", "2", \
    "--max-model-len", "131072"]

# Build and run
docker build -t deepseek-v4-flash .
docker run --gpus all -p 8000:8000 deepseek-v4-flash

# deepseek-v4-flash-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: deepseek-v4-flash
spec:
  replicas: 1
  selector:
    matchLabels:
      app: deepseek-v4-flash
  template:
    metadata:
      labels:
        app: deepseek-v4-flash
    spec:
      containers:
      - name: vllm
        image: vllm/vllm-openai:latest
        args: [
          "--model", "deepseek-ai/DeepSeek-V4-Flash",
          "--tensor-parallel-size", "2",
          "--max-model-len", "131072",
          "--gpu-memory-utilization", "0.95"
        ]
        resources:
          limits:
            nvidia.com/gpu: 2
        ports:
        - containerPort: 8000

# Download quantized weights from Hugging Face
# Models are available in FP16, INT8, and INT4 formats

# Serve with INT4 via vLLM
python -m vllm.entrypoints.openai.api_server \
    --model deepseek-ai/DeepSeek-V4-Flash-INT4 \
    --tensor-parallel-size 1 \
    --max-model-len 65536

import hashlib
import json

cache = {}

def cached_completion(prompt: str, model: str = "deepseek-v4-flash") -> str:
    key = hashlib.sha256(prompt.encode()).hexdigest()
    if key in cache:
        return cache[key]

    response = client.chat.completions.create(
        model=model,
        messages=[{"role": "user", "content": prompt}],
        max_tokens=500
    )
    text = response.choices[0].message.content
    cache[key] = text
    return text

# Non-thinking mode (instant response)
response = client.chat.completions.create(
    model="deepseek-v4-flash",
    messages=[
        {"role": "system", "content": "You are a helpful assistant. Respond directly without reasoning."},
        {"role": "user", "content": "What is the capital of France?"}
    ]
)

# Max thinking mode (deep reasoning)
response = client.chat.completions.create(
    model="deepseek-v4-pro",
    messages=[
        {"role": "system", "content": "You are a math expert. Reason step by step and show your work."},
        {"role": "user", "content": "Prove that the square root of 2 is irrational."}
    ],
    temperature=0.6,
    max_tokens=4096
)

response = client.chat.completions.create(
    model="deepseek-v4-pro",
    messages=[
        {"role": "system", "content": "Extract information as valid JSON only."},
        {"role": "user", "content": "Extract: John Doe, age 35, works at Acme Corp in San Francisco"}
    ],
    response_format={"type": "json_object"}
)

import json
data = json.loads(response.choices[0].message.content)
print(data)  # {"name": "John Doe", "age": 35, "company": "Acme Corp", "location": "San Francisco"}

from concurrent.futures import ThreadPoolExecutor, as_completed
from openai import OpenAI

client = OpenAI(api_key="...", base_url="https://api.deepseek.com")

def process_document(doc_text: str) -> dict:
    response = client.chat.completions.create(
        model="deepseek-v4-flash",
        messages=[
            {"role": "system", "content": "Summarize in 2 sentences."},
            {"role": "user", "content": doc_text[:2000]}
        ],
        max_tokens=100
    )
    return {"summary": response.choices[0].message.content}

documents = ["Doc1 text...", "Doc2 text...", "Doc3 text..."]  # 1000+ documents

with ThreadPoolExecutor(max_workers=10) as executor:
    futures = {executor.submit(process_document, doc): doc for doc in documents}
    for future in as_completed(futures):
        result = future.result()
        print(result["summary"])

import numpy as np
from openai import OpenAI

class DeepSeekRAG:
    def __init__(self, api_key: str):
        self.client = OpenAI(api_key=api_key, base_url="https://api.deepseek.com")

    def embed(self, texts: list[str]) -> np.ndarray:
        response = self.client.embeddings.create(
            model="deepseek-v4-flash",
            input=texts
        )
        return np.array([d.embedding for d in response.data])

    def retrieve(self, query: str, documents: list[str], top_k: int = 3) -> list[tuple[str, float]]:
        query_emb = self.embed([query])
        doc_embs = self.embed(documents)
        scores = np.dot(doc_embs, query_emb.T).flatten()
        top_indices = np.argsort(scores)[::-1][:top_k]
        return [(documents[i], float(scores[i])) for i in top_indices]

    def generate(self, query: str, context: str) -> str:
        response = self.client.chat.completions.create(
            model="deepseek-v4-pro",
            messages=[
                {"role": "system", "content": "Answer using only the provided context."},
                {"role": "user", "content": f"Context:\n{context}\n\nQuestion: {query}"}
            ],
            temperature=0.1
        )
        return response.choices[0].message.content

rag = DeepSeekRAG(api_key="...")

docs = [
    "DeepSeek V4 was released on April 24, 2026 under MIT license.",
    "V4 uses Mixture-of-Experts with 1.6T total parameters.",
    "The model supports 1M token context windows."
]

results = rag.retrieve("When was DeepSeek V4 released?", docs)
answer = rag.generate("When was DeepSeek V4 released?", "\n".join([d for d, _ in results]))
print(answer)

# Using Hugging Face Transformers + PEFT
from transformers import AutoModelForCausalLM, AutoTokenizer
from peft import LoraConfig, get_peft_model
from datasets import load_dataset

model_name = "deepseek-ai/DeepSeek-V4-Flash"
tokenizer = AutoTokenizer.from_pretrained(model_name)

# Load with quantization for memory efficiency
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype="bfloat16",
    device_map="auto",
    load_in_4bit=True  # Requires bitsandbytes
)

# Apply LoRA adapters
lora_config = LoraConfig(
    r=16,
    lora_alpha=32,
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj"],
    lora_dropout=0.05,
    bias="none",
    task_type="CAUSAL_LM"
)
model = get_peft_model(model, lora_config)

# Load and prepare dataset
dataset = load_dataset("json", data_files="training_data.jsonl")
def format_example(example):
    return {
        "input_ids": tokenizer.apply_chat_template(
            [{"role": "user", "content": example["instruction"]},
             {"role": "assistant", "content": example["response"]}],
            tokenize=True
        )
    }
dataset = dataset.map(format_example)

# Train (requires GPU cluster)
# from transformers import Trainer, TrainingArguments
# training_args = TrainingArguments(
#     output_dir="./deepseek-v4-finetuned",
#     per_device_train_batch_size=1,
#     gradient_accumulation_steps=16,
#     num_train_epochs=3,
#     learning_rate=2e-4,
#     logging_steps=10,
#     save_strategy="epoch",
# )
# trainer = Trainer(model=model, args=training_args, train_dataset=dataset["train"])
# trainer.train()

# docker-compose multi-node vLLM
version: '3.8'
services:
  vllm-node1:
    image: vllm/vllm-openai:latest
    command: [
      "--model", "deepseek-ai/DeepSeek-V4-Pro",
      "--tensor-parallel-size", "8",
      "--pipeline-parallel-size", "2",
      "--max-model-len", "131072",
      "--gpu-memory-utilization", "0.90",
      "--port", "8000"
    ]
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 8
    networks:
      - deepseek-net
    environment:
      - NCCL_SOCKET_IFNAME=eth0
      - NCCL_IB_DISABLE=0

  vllm-node2:
    image: vllm/vllm-openai:latest
    command: [
      "--model", "deepseek-ai/DeepSeek-V4-Pro",
      "--tensor-parallel-size", "8",
      "--pipeline-parallel-size", "2",
      "--max-model-len", "131072",
      "--gpu-memory-utilization", "0.90",
      "--port", "8000"
    ]
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 8
    networks:
      - deepseek-net

networks:
  deepseek-net:
    driver: overlay