Põhipunktid

• OpenAI-ühilduv API: DeepSeek järgib OpenAI API formaati -- vahetamiseks muuda base URL-i ja API võtit. OpenAI Python SDK, LangChain ja LlamaIndex töötavad koheselt.
• 90% sääst context caching abil: Jagatud prompt eesliited puhverdatakse (cached) automaatselt hinnaga $0.028/M tokens vs $0.28/M cache misses puhul -- koodi muudatusi pole vaja.
• 5 miljonit tasuta tokens alustamiseks: Uued kontod saavad 5M tasuta tokens ilma krediitkaardi nõudeta, millest piisab põhjalikuks eksperimenteerimiseks.
• Kaks režiimi: deepseek-chat tavaliste ülesannete jaoks (8K max väljund) ja deepseek-reasoner Chain-of-Thought reasoning jaoks (64K max väljund) -- reasoner kasutab rohkem tokens, kuid annab paremaid tulemusi keeruliste probleemide puhul.

DeepSeek V4 API juhend: Hinnastamine, seadistamine ja koodinäited

DeepSeek on muutunud LLM API-de kululiidriks. Hinnastusega, mis on suurusjärgu võrra soodsam kui OpenAI ja Anthropic ning täieliku OpenAI SDK ühilduvusega, võtab DeepSeek-ile üleminek umbes viis minutit. See juhend viib sind läbi kõige: konto seadistamine, hinnamajandus, koodinäited Python-is ja JavaScript-is, context caching ja üleminek OpenAI-lt.

Olenemata sellest, kas ehitad chatbot'i, koodiassistenti või töötled terveid koodibaase 1M token context window abil, see juhend aitab sind.

---

Kiire algus: Sinu esimene DeepSeek API väljakutse

Alustamine koosneb kolmest sammust.

1. Loo konto

Mine aadressile platform.deepseek.com ja registreeru. Uued kontod saavad 5 miljonit tasuta tokens ilma krediitkaardi nõudeta — piisavalt, et enne pühendumist põhjalikult eksperimenteerida.

2. Genereeri API võti

Navigeeri dashboard'is jaotisesse API Keys. Klõpsa Create new API key, pane sellele nimi ja kopeeri võti koheselt. Hiljem sa seda enam vaadata ei saa.

Salvesta võti keskkonnamuutujana:

export DEEPSEEK_API_KEY="sk-your-key-here"

3. Tee oma esimene päring

Kuna DeepSeek järgib OpenAI API formaati, saad kasutada ametlikku OpenAI SDK-d. Installi see esmalt:

pip install openai

Seejärel tee lihtne vestluse lõpetamise väljakutse:

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)

See ongi kõik. Kui oled varem OpenAI API-t kasutanud, on ainsad erinevused base_url ja sinu API võti.

---

Hindade jaotus

DeepSeek-i hinnastamismudel on lihtne ja märkimisväärselt odavam kui konkurentidel. Peamine eristaja on context caching, mis vähendab sisendkulusid 90% korduvate prompt eesliidete puhul.

DeepSeek API hinnakiri

Token tüüp	Maksumus 1M tokens kohta
Sisend (cache hit)	$0.028
Sisend (cache miss)	$0.28
Väljund	$0.42

Kuidas see võrdleb

Pakkuja / Mudel	Sisend (1M kohta)	Väljund (1M kohta)
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

Numbrid räägivad enda eest. Cache hits puhul on DeepSeek sisend tokens osas umbes 90x odavam kui OpenAI ja 500x odavam kui Claude Opus. Isegi ilma caching-uta on DeepSeek-i cache-miss määr $0.28/M siiski 9x odavam kui GPT-5.4 sisendi hind.

Kulunäide

Töödeldes 100 päringut, millest igaühel on 2,000-token system prompt ja 500-token user query, genereerides 1,000-token vastuseid:

• Caching-uga (99 cache hits): ~$0.05 kokku
• Ilma caching-uta: ~$0.29 kokku
• Sama töökoormus GPT-5.4-ga: ~$3.75 kokku

Suuremahuliste rakenduste puhul kasvab sääst kiiresti.

---

API režiimid: deepseek-chat vs deepseek-reasoner

DeepSeek pakub kahte erinevat mudeli režiimi, mis mõlemad on optimeeritud erinevate ülesannete jaoks.

deepseek-chat

Standardrežiim üldotstarbeliste ülesannete jaoks. Kiire, tõhus ja sobilik enamiku rakenduste jaoks.

Omadus	Väärtus
Max sisend tokens	1,000,000
Max väljund tokens	8,192
Parim... jaoks	Vestlus, kokkuvõtete tegemine, koodi genereerimine, üldine Q&A

deepseek-reasoner

Võimaldab Chain-of-Thought (CoT) reasoning. Mudel "mõtleb" samm-sammult enne lõpliku vastuse andmist, parandades märkimisväärselt täpsust keeruliste probleemide puhul.

Omadus	Väärtus
Max sisend tokens	1,000,000
Max väljund tokens	64,000
Parim... jaoks	Matemaatika, loogikaülesanded, keeruline silumine, mitmeastmeline reasoning

Reasoner tagastab nii mõtlemisprotsessi kui ka lõpliku vastuse:

response = client.chat.completions.create(
    model="deepseek-reasoner",
    messages=[
        {"role": "user", "content": "Prove that the square root of 2 is irrational."}
    ]
)

# Reasoning ahel
print(response.choices[0].message.reasoning_content)

# Lõplik vastus
print(response.choices[0].message.content)

Millal kasutada reasoner-it: Kui ülesanne nõuab mitmeastmelist loogikat, matemaatilisi tõestusi või keerulist koodi silumist, kasuta deepseek-reasoner. Kõige muu jaoks on deepseek-chat kiirem ja odavam.

---

Koodinäited

Python: Tavaline vestluse lõpetamine

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: Streaming

Pikkade vastuste puhul pakub streaming paremat kasutajakogemust, tagastades tokens nende genereerimise ajal:

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: Reasoner režiim

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: Tavaline vestlus

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: Streaming

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% sääst korduvate prompts puhul

DeepSeek-i context caching on üks selle tugevamaid konkurentsieeliseid ja see nõuab sinu poolt null koodimuudatust.

Kuidas see töötab

Kui saadad päringu, kontrollib DeepSeek, kas sinu prompt algus ühtib varem puhverdatud eesliitega. Kui esimesed N tokens on identsed hiljutise päringuga, serveeritakse need tokens puhvrist soodsama hinnaga ($0.028/M vs $0.28/M).

See toimub automaatselt. Sa ei pea deklareerima cache keys, seadistama TTLs ega muutma oma API väljakutseid ühelgi viisil.

Millal caching aktiveerub

Caching lülitub sisse, kui:

• Sama system prompt läbi päringute. Kui iga päring algab fraasiga "You are a senior Python developer...", siis see eesliide puhverdatakse pärast esimest väljakutset.
• Jagatud vestluse ajalugu. Mitmeastmelistes vestlustes puhverdatakse varasematest etappidest kogunenud ajalugu.
• Partiitöötlus consistent mallidega. Sama analüüsi prompt-i käitamine erinevate sisenditega tähendab, et ainult muutuva osa eest tuleb tasuda täishinda.

Cache hits maksimeerimine

Caching-ust maksimumi võtmiseks:

1. Pane staatiline sisu ettepoole. Struktureeri oma sõnumid nii, et system prompt ja kõik fikseeritud juhised oleksid enne muutuvat sisu.
2. Hoia system prompts identsed. Isegi ühe tähemärgi erinevus tühistab cache-i ühtivuse.
3. Grupeeri sarnased päringud kokku. Saada jagatud eesliidetega päringud kiiresti üksteise järel, et cache püsiks soe.
4. Kasuta pikki system prompts julgelt. 10,000-token system prompt ei maksa pärast esimest päringut peaaegu midagi, kui see jääb puhvrisse.

---

Üleminek OpenAI-lt

Kui kasutad praegu OpenAI API-t, on DeepSeek-ile üleminek kahe rea muudatus. API formaat on identne.

Enne (OpenAI)

from openai import OpenAI

client = OpenAI(
    api_key="sk-openai-key-here"
    # base_url vaikimisi https://api.openai.com/v1
)

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Hello"}]
)

Pärast (DeepSeek)

from openai import OpenAI

client = OpenAI(
    api_key="sk-deepseek-key-here",
    base_url="https://api.deepseek.com"  # <-- lisa see rida
)

response = client.chat.completions.create(
    model="deepseek-chat",              # <-- muuda mudeli nime
    messages=[{"role": "user", "content": "Hello"}]
)

See ongi kogu üleminek. Kaks rida muudetud: base_url ja model. Kõik muu — sõnumite formaat, streaming, function calling, JSON mode — töötab samamoodi.

Keskkonnamuutujate lähenemine

Projektidele, mis peavad pakkujate vahel hõlpsasti vahetama:

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"]
)

---

DeepSeek kasutamine avatud lähtekoodiga tööriistadega

Kuna DeepSeek on OpenAI-ühilduv, töötab see kasvava avatud lähtekoodiga AI kooditööriistade ökosüsteemiga. Siin on kõige populaarsemad.

OpenCode

OpenCode on avatud lähtekoodiga terminalipõhine AI koodiassistent. Seadista see DeepSeek-i kasutama, määrate pakkuja oma seadistustes:

{
  "provider": {
    "name": "deepseek",
    "apiKey": "sk-your-key",
    "baseURL": "https://api.deepseek.com",
    "model": "deepseek-chat"
  }
}

Aider

Aider on käsurea AI paaristöötaja. Suuna see DeepSeek-ile keskkonnamuutujate abil:

export OPENAI_API_BASE="https://api.deepseek.com"
export OPENAI_API_KEY="sk-your-deepseek-key"
aider --model openai/deepseek-chat

Continue (VS Code laiendus)

Continue on avatud lähtekoodiga AI koodiassistent VS Code ja JetBrains jaoks. Lisa DeepSeek oma ~/.continue/config.json faili:

{
  "models": [
    {
      "title": "DeepSeek V4",
      "provider": "openai",
      "model": "deepseek-chat",
      "apiBase": "https://api.deepseek.com",
      "apiKey": "sk-your-key"
    }
  ]
}

Kõik kolm tööriista käsitlevad DeepSeek-i kui OpenAI otsest asendust. Erilisi adaptereid ega pistikprogramme pole vaja.

---

1M token context window ära kasutamine

DeepSeek-i 1 miljoni tokeni suurune context window avab töövoogusid, mis olid varem praktiliselt võimatud.

Kogu koodibaasi analüüs

Tüüpiline keskmise suurusega projekt (50,000 rida koodi) on umbes 500,000 tokens. DeepSeek-i 1M context abil saad sisestada terve koodibaasi ühte prompt-i, et teha:

• Arhitektuuri ülevaated. Palu mudelil tuvastada ringviiteid, puuduvaid abstraktsioone või ebakõlasid kogu projektis.
• Failideülene refaktoreerimine. Kirjelda soovitud muudatust ja lase mudelil genereerida koordineeritud muudatused mitmes failis.
• Turvaauditid. Skaneeri kogu koodibaasi SQL injection, XSS ja muude haavatavuste suhtes ühe korraga.

Praktilised näpunäited suurte contexts jaoks

1. Esita esmalt failipuu. Alusta oma prompt-i kataloogistruktuuriga, et mudel mõistaks projekti ülesehitust enne üksikute failide lugemist.
2. Kasuta selgeid eraldajaid. Ümbritse iga fail tähistega nagu --- FILE: src/auth.py ---, et mudel saaks oma vastuses viidata konkreetsetele failidele.
3. Esita fokuseeritud küsimusi. 1M context window ei tähenda, et peaksid esitama ebamääraseid prompts. Ole täpne selles, mida soovid analüüsida.
4. Kombineeri caching-uga. Kui teed sama koodibaasi kohta mitu päringut, siis koodibaasi osa puhverdatakse pärast esimest päringut — järgnevad küsimused maksavad vaid murdosa esialgsest väljakutsest.

---

Parimad tavad kulude optimeerimiseks

1. Struktureeri prompts maksimaalseks cache hits saamiseks

Aseta oma pikim ja stabiilseim sisu sõnumite massiivi algusesse. System prompts, few-shot näited ja viitedokumentatsioon peaksid olema enne muutuvat kasutaja päringut.

2. Kasuta vaikimisi deepseek-chat-i

Jäta deepseek-reasoner ülesannete jaoks, mis nõuavad tõesti mitmeastmelist reasoning-ut. Lihtsa genereerimise, kokkuvõtete ja koodi täiendamise jaoks on deepseek-chat kiirem ja kasutab vähem tokens.

3. Sea sobiv max_tokens

Ära sea max_tokens väärtust kõrgemaks kui vaja. Kui ootad 200-token vastust, ei maksa max_tokens: 8192 seadmine iseenesest rohkem, kuid see takistab mudelil liiga vara lõpetamast, kui see hakkab ekslema.

4. Grupeeri sarnased päringud

Grupeeri päringud, mis jagavad sama system prompt-i, ja saada need kiiresti üksteise järel. See hoiab cache-i soojana ja tagab, et enamik päringuid tabab puhverdatud eesliidet.

5. Jälgi token-ite kasutust

Kontrolli usage välja API vastustes, et jälgida oma tegelikku tarbimist:

# Vastus vestlusest
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. Kasuta streaming-ut pikkade väljundite puhul

Streaming ei säästa raha, kuid parandab tajutavat latentsust. Kasutajad näevad esimesi tokens millisekundite jooksul, selle asemel et oodata kogu vastuse genereerimist.

---

Kokkuvõte

DeepSeek API ühendab agressiivse hinnastamise, OpenAI ühilduvuse ja 1M token context window paketiks, mida on raske ignoreerida. Üleminekutee OpenAI-lt on triviaalne — muuda kaks rida koodi ja sinu olemasolev rakendus töötab. Context caching pakub automaatset kulusäästu ilma igasuguste koodimuudatusteta. Ja avatud lähtekoodiga tööriistade ökosüsteem toetab juba DeepSeek-i kui esmaklassilist pakkujat.

Arendajatele, kes ehitavad kulutundlikke rakendusi, suuremahulisi töötlemisliine või kogu koodibaasi analüüsi tööriistu, on DeepSeek V4 tõsiselt kaalumist väärt. Alusta 5 miljoni tasuta tokens-iga, võrdle seda oma praeguse pakkujaga ja lase numbritel oma otsust juhtida.