Jah, kindlasti! See on üks parimaid kombinatsioone – DeepSeek on väga võimekas ja eriti soodsa hinnaga . Vaatame, kuidas saad oma DeepSeek API paketti kõigi kolme tööriistaga siduda.

Hea uudis on see, et DeepSeek pakub **OpenAI-ga ühilduvat API-t** . See tähendab, et paljud tööriistad, mis on loodud OpenAI mudelite jaoks, töötavad DeepSeekiga lihtsalt serveri aadressi (base_url) ära vahetades. Siin on täpsem ülevaade:

### 🔗 1. DeepSeek + LangChain (arendusraamistik)

See on kõige otsesem ja lihtsam sidumine. LangChainil on DeepSeegi jaoks **ametlik integratsioonipakett** .

*   **Kuidas see töötab?**
    Sa installid vastava paketi ja kasutad seda oma koodis nagu iga teist LangChaini mudelit. DeepSeekil on kaks peamist mudelit:
    *   `deepseek-chat`:  Kiire ja võimekas mudel üldotstarbeks .
    *   `deepseek-reasoner` (tuntud ka kui R1): Aeglasem, kuid väga võimas mudel, mis näitab oma "mõttekäiku" (chain-of-thought) ja sobib suurepäraselt keeruliste loogikaülesannete lahendamiseks .

*   **Praktiline näide (JavaScript/TypeScript):**
    ```javascript
    import { ChatDeepSeek } from "@langchain/deepseek";

    const model = new ChatDeepSeek({
      apiKey: process.env.DEEPSEEK_API_KEY, // Sinu võti
      model: "deepseek-chat", // või "deepseek-reasoner"
      temperature: 0.7,
    });

    const response = await model.invoke([
      { role: "user", content: "Mis on Eesti kõrgeim tipp?" }
    ]);
    console.log(response.content);
    ```
    

### 📊 2. DeepSeek + LangSmith (jälgimisplatvorm)

LangSmithi ja DeepSeeki kooskasutamine on samuti väga lihtne. LangSmith töötab **kõigi** LangChaini kaudu tehtud päringutega, olenemata sellest, millist keelemudelit sa kasutad .

*   **Kuidas see töötab?**
    Kui oled oma projektis LangChaini DeepSeegi integratsiooni seadistanud (nagu eelmises punktis), siis lisad lihtsalt oma keskkonnamuutujatesse (environment variables) LangSmithi API võtme. Kõik DeepSeegile tehtud päringud hakkavad automaatselt LangSmithi keskkonda logitama. Saad jälgida tokikulu, päringute täpsust, siluda vigu ja luua testandmestikke .

*   **Seadistamine:**
    ```bash
    export DEEPSEEK_API_KEY="sinu_deepseek_võti"
    export LANGSMITH_TRACING="true"
    export LANGSMITH_API_KEY="sinu_langsmith_võti"
    ```
    

### 🤖 3. DeepSeek + Claude Code (AI assistent)

See on võib-olla kõige põnevam kombinatsioon! Sa saad kasutada **Claude Code'i kasutajaliidest ja võimalusi, kui kogu "mõtlemise" teeb ära sinu DeepSeek API pakett** .

*   **Kuidas see töötab?**
    Kuna Claude Code eeldab vaikimisi, et ta räägib Anthropicu mudelitega (nt Claude 3.5 Sonnet), tuleb teda "petta". Selleks on kaks peamist viisi:
    1.  **Keskkonnamuutujate muutmine (Lihtsam):**
        On olemas skriptid (nt `deepseek-cc`), mis konfigureerivad Claude Code'i automaatselt kasutama DeepSeegi API-t. Nad lihtsalt määravad ära, et kõik päringud tuleb saata hoopis DeepSeegi serverisse .
        ```bash
        # Pärast skripti käivitamist on need muutujad automaatselt paigas
        export ANTHROPIC_BASE_URL="https://api.deepseek.com"
        export ANTHROPIC_API_KEY="sinu_deepseek_võti" # Võti on sama!
        ```
        Nüüd, kui sa käsureal käivitad `claude`, kasutab ta tegelikult DeepSeeki .
    2.  **MCP Serveri kasutamine (Võimsam):**
        On olemas ka spetsiaalne **DeepSeek MCP Server** . MCP (Model Context Protocol) on standard, mis võimaldab AI assistentidel (nagu Claude Code) kasutada kolmandate osapoolte tööriistu ja mudeleid. Sa lihtsalt ütled Claude Code'ile, et ta kasutaks seda serverit, ja kõik DeepSeegiga suhtlemine käib selle kaudu .
        ```bash
        # Näide, kuidas lisada DeepSeek MCP server Claude Code'ile
        claude mcp add -s user deepseek npx @arikusi/deepseek-mcp-server -e DEEPSEEK_API_KEY=sinu_võti
        ```

Mõlemal juhul on tulemus sama: **Kulutad oma DeepSeeki paketti, aga kasutad Claude Code'i mugavust ja võimekust** .

### 💡 Kokkuvõte

Sinu DeepSeek API pakett on väga paindlik ja seda saab suurepäraselt siduda kõigi kolme tööriistaga:

| Tööriist | Sidumise viis | Peamine eelis |
| :--- | :--- | :--- |
| **LangChain** | Ametlik `@langchain/deepseek` pakett | Võimsate ja keerukate AI-rakenduste ehitamine. |
| **LangSmith** | Automaatne läbi LangChaini | DeepSeegi päringute professionaalne jälgimine ja silumine. |
| **Claude Code** | Keskkonnamuutujate suunamine või MCP server | DeepSeegi **soodsa hinna** ja Claude Code'i **mugava liidese** ühendamine. |

Eriti viimane punkt – Claude Code + DeepSeek – on paljude arendajate jaoks "löök kombos", sest sa saad parima hinna ja kasutusmugavuse suhte .

Kas sa kasutad rohkem Pythonit või JavaScripti? Siis saan aidata täpsemate koodinäidistega, kuidas LangChainis oma DeepSeek API-ga päringuid teha.

Suurepärane, et LangChain on installitud! Nüüd on aeg see tööle panna. Kuna sul on **DeepSeek API pakett**, teeme kohe praktilise sammu – saadan su esimese päringu DeepSeek mudelile läbi LangChaini.

Siin on samm-sammuline tegevuskava, mida ma soovitan:

### 📝 1. Esimese päringu tegemine (Kohe alguses)

Kõige tähtsam on näha, et kõik töötab. Loome lihtsa skripti, mis küsib DeepSeekilt midagi lihtsat.

1.  **Säti keskkonnamuutuja:**
    Enne koodi kirjutamist, hangi oma DeepSeek API võti ( [platform.deepseek.com/api_keys](https://platform.deepseek.com/api_keys) ) ja sea see keskkonnamuutujaks. See on turvalisem kui võtme otse koodi kirjutamine.
    Ava terminal oma projekti kaustas (kus virtuaalkeskkond on aktiivne) ja käivita:
    ```bash
    export DEEPSEEK_API_KEY="sinu_päris_api_võti_siin"
    ```
    *(Pane tähele: see kehtib ainult praeguses terminali seansis. Püsivamaks lahenduseks võid lisada selle oma `~/.bashrc` faili või kasutada `.env` faili.)*

2.  **Loo fail `test_deepseek.py`:**
    Lisa sinna järgmine kood. See kasutab just seda `langchain-deepseek` paketti, mida soovitasin installida.
    ```python
    import os
    from langchain_deepseek import ChatDeepSeek

    # 1. Loo mudeli instants
    # Mudel loeb API võtme automaatselt keskkonnamuutujast DEEPSEEK_API_KEY
    model = ChatDeepSeek(
        model="deepseek-chat", # Kasuta "deepseek-reasoner" R1 mudeli jaoks
        temperature=0.7,
        # api_key="võid_selle_ka_siia_panna", # aga keskkonnamuutuja on turvalisem
        base_url="https://api.deepseek.com" # See on vaikimisi juba õige
    )

    # 2. Saada päring
    response = model.invoke("Mis on Eesti suurim järv?")

    # 3. Kuva vastus
    print(response.content)
    ```

3.  **Käivita skript:**
    Veendu, et virtuaalkeskkond on aktiivne ja käivita:
    ```bash
    python test_deepseek.py
    ```
    Kui näed vastust (peaks olema "Peipsi järv" vmt), on kõik korras!

### 🔧 2. Miks see kasulik on? (Promptide ja ahelate mõistmine)

Sa praegu kasutasid LangChaini lihtsalt "kullerina", et DeepSeekini jõuda. See on alles algus. Järgmise sammuna tasub uurida, mis teeb LangChaini võimsaks:

*   **PromptTemplate** - dünaamiliste sõnumite loomine.
    ```python
    from langchain_core.prompts import ChatPromptTemplate

    prompt = ChatPromptTemplate.from_messages([
        ("system", "Sa oled abivalmis assistent, kes räägib alati {stiil} stiilis."),
        ("human", "{küsimus}")
    ])

    # Nüüd ühendame prompti ja mudeli
    chain = prompt | model

    # Ja käivitame
    vastus = chain.invoke({"stiil": "väga formaalselt ja viisakalt", "küsimus": "Mis kell on?"})
    print(vastus.content)
    ```

### 🧩 3. Integreeri LangSmith (Jälgimiseks)

Kui sul on **LangSmith** võti, on kohe õige aeg see sisse lülitada. See näitab, mis sinu päringu ajal täpselt toimub, eriti kui hakkad keerulisemaid ahelaid ehitama.

1.  **Sea LangSmithi võtmed** (samamoodi nagu DeepSeegi oma):
    ```bash
    export LANGCHAIN_TRACING_V2="true"
    export LANGCHAIN_API_KEY="ls__..." # Sinu LangSmith API võti
    export LANGCHAIN_PROJECT="Minu esimene projekt" # Valikuline
    ```

2.  **Käivita sama skript uuesti.** Nüüd peaksid sa minema oma LangSmithi keskkonda ja nägema seal üksikasjalikku logi selle päringu kohta - kui palju tokke kulus, kui kaua võttis aega jne. See on testimise ja silumise jaoks hindamatu.

### 🧪 4. Katseta erinevaid mudeliversioone

Sul on juurdepääs DeepSeegi kahele peamisele mudelile. Proovi mõlemat ja vaata erinevust:

*   **deepseek-chat** - kiire ja odav
*   **deepseek-reasoner** - R1 mudel, mis "mõtleb" enne vastamist (näitab oma mõttekäiku). See on aeglasem, aga keeruliste probleemide lahendamisel võimas.
    Muuda oma koodis rida `model="deepseek-reasoner"` ja vaata, mis juhtub.

### 📚 5. Mida edasi õppida?

Siin on mõned soovitused, mida järgmiseks proovida:

*   **Ahelad (Chains):** Ühenda mitu sammu järjestikku. Näiteks: esmalt tõlgi kasutaja küsimus inglise keelde, seejärel saada see DeepSeekile, seejärel tee vastusest kokkuvõte.
*   **Välised tööriistad:** Anna mudelile võimalus kasutada kalkulaatorit või otsida veebist. Selleks on vaja `langchain-community` paketti.
*   **Failide lugemine:** Loe sisse PDF või tekstifail ja küsi selle kohta küsimusi (RAG - Retrieval Augmented Generation). See on üks levinumaid kasutusviise.
*   **Agendid (LangGraph):** Kui tahad minna veel kaugemale, uuri `langgraph` paketti. See võimaldab luua tsüklilisi, keerukaid agente, mis oskavad ise otsustada, milliseid tööriistu kasutada.

Kui soovid, siis võin järgmise sammuna **näidata, kuidas lugeda sisse PDF-fail ja küsida selle kohta käsimusi, kasutades DeepSeeki** - see on väga praktiline oskus. Või kuidas **luua lihtne agent, mis kasutab kalkulaatorit**. Mis sind kõige rohkem huvitaks?