Hlavní poznatky
- API kompatibilní s OpenAI: DeepSeek dodržuje formát OpenAI API -- přepněte změnou base URL a API key. OpenAI Python SDK, LangChain a LlamaIndex fungují okamžitě.
- 90% úspora s context caching: Sdílené prefixy promptů jsou cachovány automaticky za $0.028/M tokens oproti $0.28/M při cache misses -- nejsou potřeba žádné změny v kódu.
- 5 milionů free tokens pro začátek: Nové účty získají 5M free tokens bez nutnosti zadávat kreditní kartu, což stačí na rozsáhlé experimentování.
- Dva režimy: deepseek-chat pro standardní úkoly (max 8K výstup) a deepseek-reasoner pro Chain-of-Thought uvažování (max 64K výstup) -- reasoner spotřebovává více tokens, ale dosahuje lepších výsledků u těžkých problémů.
DeepSeek V4 API průvodce: Ceník, nastavení a příklady kódu
DeepSeek se stal lídrem v oblasti nákladů na LLM APIs. S cenami, které podbízejí OpenAI a Anthropic o řád, a plnou kompatibilitou s OpenAI SDK trvá přechod na DeepSeek asi pět minut. Tento průvodce vás provede vším: nastavením účtu, výpočtem cen, příklady kódu v Python a JavaScript, context caching a migrací z OpenAI.
Ať už stavíte chatbota, coding assistant, nebo zpracováváte celé codebase s 1M tokens context window, tento průvodce vám poskytne vše potřebné.
Rychlý start: Váš první DeepSeek API call
Začít můžete ve třech krocích.
1. Vytvoření účtu
Přejděte na platform.deepseek.com a zaregistrujte se. Nové účty obdrží 5 milionů free tokens bez nutnosti zadávat kreditní kartu — což stačí na rozsáhlé experimentování před závazkem.
2. Vygenerování API key
V dashboardu přejděte do sekce API Keys. Klikněte na Create new API key, pojmenujte jej a ihned si klíč zkopírujte. Znovu jej již neuvidíte.
Uložte klíč jako environment variable:
export DEEPSEEK_API_KEY="sk-your-key-here"
3. První požadavek
Protože DeepSeek dodržuje formát OpenAI API, můžete použít oficiální OpenAI SDK. Nejprve jej nainstalujte:
pip install openai
Poté proveďte jednoduchý chat completion call:
from openai import OpenAI
client = OpenAI(
api_key="sk-your-key-here",
base_url="https://api.deepseek.com"
)
response = client.chat.completions.create(
model="deepseek-chat",
messages=[
{"role": "system", "content": "You are a helpful assistant."},
{"role": "user", "content": "Explain Python decorators in three sentences."}
]
)
print(response.choices[0].message.content)
To je vše. Pokud jste dříve používali OpenAI API, jediné rozdíly jsou base_url a váš API key.
Rozpis cen
Model oceňování DeepSeek je přímočarý a dramaticky levnější než u konkurence. Hlavním rozlišovacím znakem je context caching, který snižuje náklady na vstup o 90 % u opakovaných prefixů promptů.
DeepSeek API ceník
| Typ tokenu | Cena za 1M tokens |
|---|---|
| Vstup (cache hit) | $0.028 |
| Vstup (cache miss) | $0.28 |
| Výstup | $0.42 |
Srovnání
| Poskytovatel / Model | Vstup (za 1M) | Výstup (za 1M) |
|---|---|---|
| DeepSeek V4 (cache hit) | $0.028 | $0.42 |
| DeepSeek V4 (cache miss) | $0.28 | $0.42 |
| OpenAI GPT-5.4 | $2.50 | $10.00 |
| Anthropic Claude Opus 4.6 | $15.00 | $75.00 |
| Google Gemini 3.1 Pro | $1.25 | $5.00 |
Čísla mluví sama za sebe. S cache hits je DeepSeek zhruba 90x levnější než OpenAI u vstupních tokens a 500x levnější než Claude Opus. I bez cachování je sazba DeepSeek za cache-miss ve výši $0.28/M stále 9x levnější než vstupní cena u GPT-5.4.
Příklad nákladů
Zpracování 100 požadavků, každý s 2,000-token system promptem a 500-token uživatelským dotazem, generující 1,000-token odpovědi:
- S cachováním (99 cache hits): cca $0.05 celkem
- Bez cachování: cca $0.29 celkem
- Stejná zátěž na GPT-5.4: cca $3.75 celkem
U aplikací s vysokým objemem se úspory rychle sčítají.
Režimy API: deepseek-chat vs deepseek-reasoner
DeepSeek nabízí dva odlišné režimy modelů, každý optimalizovaný pro jiné úkoly.
deepseek-chat
Standardní režim pro obecné úkoly. Rychlý, efektivní a vhodný pro většinu aplikací.
| Vlastnost | Hodnota |
|---|---|
| Max vstupní tokens | 1,000,000 |
| Max výstupní tokens | 8,192 |
| Nejlepší pro | Chat, shrnutí, generování kódu, obecné Q&A |
deepseek-reasoner
Umožňuje Chain-of-Thought (CoT) uvažování. Model "přemýšlí" krok za krokem, než vytvoří konečnou odpověď, což dramaticky zlepšuje přesnost u těžkých problémů.
| Vlastnost | Hodnota |
|---|---|
| Max vstupní tokens | 1,000,000 |
| Max výstupní tokens | 64,000 |
| Nejlepší pro | Matematiku, logické hádanky, komplexní debugging, vícekrokové uvažování |
Reasoner vrací jak proces uvažování, tak konečnou odpověď:
response = client.chat.completions.create(
model="deepseek-reasoner",
messages=[
{"role": "user", "content": "Prove that the square root of 2 is irrational."}
]
)
# Řetězec uvažování
print(response.choices[0].message.reasoning_content)
# Konečná odpověď
print(response.choices[0].message.content)
Kdy použít reasoner: Pokud úkol vyžaduje vícekrokovou logiku, matematické důkazy nebo komplexní debugging kódu, použijte deepseek-reasoner. Pro vše ostatní je deepseek-chat rychlejší a levnější.
Příklady kódu
Python: Základní Chat Completion
import os
from openai import OpenAI
client = OpenAI(
api_key=os.getenv("DEEPSEEK_API_KEY"),
base_url="https://api.deepseek.com"
)
def ask_deepseek(prompt, system_prompt="You are a helpful assistant."):
response = client.chat.completions.create(
model="deepseek-chat",
messages=[
{"role": "system", "content": system_prompt},
{"role": "user", "content": prompt}
],
temperature=0.7,
max_tokens=2048
)
return response.choices[0].message.content
answer = ask_deepseek("Write a Python function to merge two sorted lists.")
print(answer)
Python: Streamování
U dlouhých odpovědí poskytuje streamování lepší uživatelský zážitek tím, že vrací tokens tak, jak jsou generovány:
stream = client.chat.completions.create(
model="deepseek-chat",
messages=[
{"role": "system", "content": "You are a senior software engineer."},
{"role": "user", "content": "Review this code and suggest improvements:\n\ndef fib(n):\n if n <= 1: return n\n return fib(n-1) + fib(n-2)"}
],
stream=True
)
for chunk in stream:
if chunk.choices[0].delta.content:
print(chunk.choices[0].delta.content, end="", flush=True)
Python: Režim Reasoner
response = client.chat.completions.create(
model="deepseek-reasoner",
messages=[
{"role": "user", "content": "Find all bugs in this code and explain why each is a bug:\n\ndef quicksort(arr):\n if len(arr) <= 1:\n return arr\n pivot = arr[0]\n left = [x for x in arr if x < pivot]\n right = [x for x in arr if x > pivot]\n return quicksort(left) + [pivot] + quicksort(right)"}
]
)
print("Reasoning:", response.choices[0].message.reasoning_content)
print("Answer:", response.choices[0].message.content)
JavaScript / Node.js: Základní Chat
import OpenAI from "openai";
const client = new OpenAI({
apiKey: process.env.DEEPSEEK_API_KEY,
baseURL: "https://api.deepseek.com",
});
async function askDeepSeek(prompt) {
const response = await client.chat.completions.create({
model: "deepseek-chat",
messages: [
{ role: "system", content: "You are a helpful assistant." },
{ role: "user", content: prompt },
],
});
return response.choices[0].message.content;
}
const answer = await askDeepSeek("Explain closures in JavaScript.");
console.log(answer);
JavaScript / Node.js: Streamování
const stream = await client.chat.completions.create({
model: "deepseek-chat",
messages: [
{ role: "user", content: "Write a REST API in Express.js with CRUD routes for a todo app." },
],
stream: true,
});
for await (const chunk of stream) {
const content = chunk.choices[0]?.delta?.content;
if (content) {
process.stdout.write(content);
}
}
Context Caching: 90% úspora u opakovaných promptů
Context caching u DeepSeek je jednou z jeho nejsilnějších konkurenčních výhod a vyžaduje nulové změny v kódu na vaší straně.
Jak to funguje
Když pošlete požadavek, DeepSeek zkontroluje, zda začátek vašeho promptu odpovídá dříve cachovanému prefixu. Pokud je prvních N tokens identických s nedávným požadavkem, jsou tyto tokens obslouženy z cache za sníženou sazbu ($0.028/M vs $0.28/M).
K tomu dochází automaticky. Nemusíte deklarovat cache keys, nastavovat TTLs ani nijak upravovat své API calls.
Kdy se cachování aktivuje
Cachování se aktivuje, když:
- Stejný system prompt napříč požadavky. Pokud každý požadavek začíná "You are a senior Python developer...", tento prefix se po prvním volání zacachuje.
- Sdílená historie konverzace. V vícekrokových konverzacích se nahromaděná historie z dřívějších kroků cachuje.
- Dávkové zpracování s konzistentními šablonami. Spouštění stejného analytického promptu nad různými vstupy znamená, že pouze variabilní část podléhá plné ceně.
Maximalizace cache hits
Chcete-li z cachování vytěžit maximum:
- Dávejte statický obsah na začátek. Strukturujte své zprávy tak, aby system prompt a jakékoli pevné instrukce byly před variabilním obsahem.
- Udržujte system prompty identické. I rozdíl v jediném znaku zruší shodu v cache.
- Seskupujte podobné požadavky. Posílejte požadavky se sdílenými prefixy v rychlém sledu, aby cache zůstala teplá.
- Používejte dlouhé system prompty s důvěrou. System prompt o délce 10,000 tokens nestojí po prvním požadavku téměř nic, pokud zůstane v cache.
Migrace z OpenAI
Pokud aktuálně používáte OpenAI API, přechod na DeepSeek je změna na dva řádky. Formát API je identický.
Předtím (OpenAI)
from openai import OpenAI
client = OpenAI(
api_key="sk-openai-key-here"
# base_url defaults to https://api.openai.com/v1
)
response = client.chat.completions.create(
model="gpt-4o",
messages=[{"role": "user", "content": "Hello"}]
)
Poté (DeepSeek)
from openai import OpenAI
client = OpenAI(
api_key="sk-deepseek-key-here",
base_url="https://api.deepseek.com" # <-- přidejte tento řádek
)
response = client.chat.completions.create(
model="deepseek-chat", # <-- změňte název modelu
messages=[{"role": "user", "content": "Hello"}]
)
To je celá migrace. Změněny dva řádky: base_url a model. Vše ostatní — formát zpráv, streamování, function calling, JSON mode — funguje stejně.
Přístup přes environment variables
Pro projekty, které potřebují snadno přepínat mezi poskytovateli:
import os
from openai import OpenAI
provider = os.getenv("LLM_PROVIDER", "deepseek")
config = {
"deepseek": {
"api_key": os.getenv("DEEPSEEK_API_KEY"),
"base_url": "https://api.deepseek.com",
"model": "deepseek-chat"
},
"openai": {
"api_key": os.getenv("OPENAI_API_KEY"),
"base_url": "https://api.openai.com/v1",
"model": "gpt-4o"
}
}
client = OpenAI(
api_key=config[provider]["api_key"],
base_url=config[provider]["base_url"]
)
Používání DeepSeek s open-source nástroji
Protože je DeepSeek kompatibilní s OpenAI, funguje s rostoucím ekosystémem open-source nástrojů pro AI kódování. Zde jsou ty nejoblíbenější.
OpenCode
OpenCode je open-source terminálový AI coding assistant. Nakonfigurujte jej pro použití DeepSeek nastavením poskytovatele v konfiguraci:
{
"provider": {
"name": "deepseek",
"apiKey": "sk-your-key",
"baseURL": "https://api.deepseek.com",
"model": "deepseek-chat"
}
}
Aider
Aider je AI pair programmer pro příkazovou řádku. Nasměrujte jej na DeepSeek pomocí environment variables:
export OPENAI_API_BASE="https://api.deepseek.com"
export OPENAI_API_KEY="sk-your-deepseek-key"
aider --model openai/deepseek-chat
Continue (rozšíření pro VS Code)
Continue je open-source AI code assistant pro VS Code a JetBrains. Přidejte DeepSeek do svého ~/.continue/config.json:
{
"models": [
{
"title": "DeepSeek V4",
"provider": "openai",
"model": "deepseek-chat",
"apiBase": "https://api.deepseek.com",
"apiKey": "sk-your-key"
}
]
}
Všechny tři nástroje považují DeepSeek za přímou náhradu OpenAI. Nejsou potřeba žádné speciální adaptéry ani pluginy.
Využití 1M tokens context window
Context window o velikosti 1 milionu tokens u DeepSeek otevírá workflow, která byla dříve nepraktická.
Analýza celého codebase
Typický středně velký projekt (50 000 řádků kódu) má zhruba 500 000 tokens. S 1M context u DeepSeek můžete vložit celé codebase do jediného promptu pro:
- Revize architektury. Požádejte model o identifikaci cyklických závislostí, chybějících abstrakcí nebo nekonzistentních vzorů v celém projektu.
- Refaktorování napříč soubory. Popište požadovanou změnu a nechte model vygenerovat koordinované úpravy ve více souborech.
- Bezpečnostní audity. Prohledejte celé codebase na SQL injection, XSS a další zranitelnosti v jednom průchodu.
Praktické tipy pro velké kontexty
- Nejprve poskytněte file tree. Začněte svůj prompt strukturou adresářů, aby model pochopil rozvržení projektu před čtením jednotlivých souborů.
- Používejte jasné oddělovače. Zabalte každý soubor do značek jako
--- FILE: src/auth.py ---, aby model mohl v odpovědi odkazovat na konkrétní soubory. - Pokládejte cílené otázky. 1M context window neznamená, že potřebujete vágní prompty. Buďte konkrétní v tom, co chcete analyzovat.
- Kombinujte s cachováním. Pokud provádíte více dotazů nad stejným codebase, část s codebase se po prvním požadavku zacachuje — následné otázky stojí zlomek ceny původního volání.
Nejlepší postupy pro optimalizaci nákladů
1. Strukturujte prompty pro maximální počet cache hits
Umístěte svůj nejdelší a nejstabilnější obsah na začátek pole zpráv. System prompty, few-shot příklady a referenční dokumentace by měly předcházet variabilnímu uživatelskému dotazu.
2. Používejte deepseek-chat jako výchozí
Rezervujte si deepseek-reasoner pro úkoly, které skutečně vyžadují vícekrokové uvažování. Pro přímočaré generování, shrnutí a doplňování kódu je deepseek-chat rychlejší a spotřebovává méně tokens.
3. Nastavte odpovídající max_tokens
Nenastavujte max_tokens výše, než potřebujete. Pokud očekáváte 200-token odpověď, nastavení max_tokens: 8192 sice samo o sobě nebude stát více, ale zabrání modelu přestat dříve, pokud se začne rozepisovat.
4. Dávkujte podobné požadavky
Seskupujte požadavky, které sdílejí stejný system prompt, a posílejte je v rychlém sledu. To udržuje cache teplou a zajišťuje, že většina požadavků zasáhne cachovaný prefix.
5. Sledujte využití tokens
Kontrolujte pole usage v API odpovědích pro sledování vaší skutečné spotřeby:
response = client.chat.completions.create(
model="deepseek-chat",
messages=[{"role": "user", "content": "Hello"}]
)
print(f"Input tokens: {response.usage.prompt_tokens}")
print(f"Output tokens: {response.usage.completion_tokens}")
print(f"Cache hit tokens: {response.usage.prompt_cache_hit_tokens}")
print(f"Cache miss tokens: {response.usage.prompt_cache_miss_tokens}")
6. Používejte streamování pro dlouhé výstupy
Streamování nešetří peníze, ale zlepšuje vnímanou latenci. Uživatelé uvidí první tokens během milisekund namísto čekání na vygenerování celé odpovědi.
Závěr
DeepSeek API kombinuje agresivní ceny, kompatibilitu s OpenAI a 1M tokens context window do balíčku, který lze jen těžko ignorovat. Cesta migrace z OpenAI je triviální — změňte dva řádky kódu a vaše stávající aplikace funguje. Context caching přináší automatické úspory nákladů bez jakýchkoli změn v kódu. A ekosystém open-source nástrojů již DeepSeek podporuje jako prvořadého poskytovatele.
Pro vývojáře budující aplikace citlivé na náklady, vysokoobjemové zpracovatelské linky nebo nástroje pro analýzu celého codebase stojí DeepSeek V4 za vážné zvážení. Začněte s 5 miliony free tokens, otestujte jej proti svému současnému poskytovateli a nechte se vést čísly při svém rozhodování.
