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