Source: https://ailoot.ai/models/nb/deepseek-v3-2-thinking/
Canonical: https://ailoot.ai/models/nb/deepseek-v3-2-thinking/
Language: nb

# DeepSeek: DeepSeek V3.2

[Markdown](https://ailoot.ai/models/nb/deepseek-v3-2-thinking/index.md) · [JSON](https://ailoot.ai/models/nb/deepseek-v3-2-thinking/facts.json)

## [DeepSeek: DeepSeek V3.2](https://ailoot.ai/models/nb/deepseek-v3-2-thinking/)

DeepSeek V3.2 kombinerer tekstbasert resonnering med verktøybruk og analyse av lang kontekst. Arkitekturen med sparsom attention og det oppdaterte samtaleformatet støtter koding, søk og agentoppgaver i flere trinn, med en kontekst på 128K og separate arbeidsflyter for tenkning og direkte svar.

- [**Ailoot Ultra · OpenAI Chat** `POST /v1/chat/completions` `deepseek-v3.2-thinking`](https://ailoot.ai/models/nb/deepseek-v3-2-thinking/#method-0)

Om modellen

Denne beskrivelsen dekker modellens funksjoner. Tilgjengelige inndata, utdata og alternativer i Ailoot er oppført nedenfor for den valgte metoden.

DeepSeek V3.2 er DeepSeeks tekstmodell for resonnering og agentarbeid, med vekt på effektiv behandling av lang kontekst. Produsenten organiserer de viktigste endringene rundt DeepSeek Sparse Attention, et oppskalert rammeverk for forsterkningslæring og en treningspipeline for agentbaserte oppgaver. Den tar imot skriftlige spørsmål og kontekst og produserer tekst, blant annet svar, kode eller innhold for verktøykall. Den er atskilt fra den tidligere V3.2 Exp-utgaven og den separate resonneringsvarianten Speciale.

DeepSeek Sparse Attention legger en indekserer og finmasket tokenutvelgelse til arkitekturen med latent attention. For en lang sekvens velger indeksereren den tidligere tokeninformasjonen som brukes av hovedberegningen for attention. Rapporten sier at dette er arkitekturendringen fra V3.1 Terminus, og at den bruker samme arkitektur som V3.2 Exp. Den publiserte konteksten er 128K tokener, noe som støtter omfattende kildemateriale og en pågående oppgave, mens generert resonnering og verktøyhistorikk også bruker av den tilgjengelige konteksten.

Ettertreningen omfatter både svar med og uten tenkning innen matematikk, programmering, logisk resonnering, generelle agentoppgaver, agentbasert koding og søk. Domenespesialister leverer data som samles i den endelige modellen, etterfulgt av blandet forsterkningslæring. For et vanlig spørsmål kan et direkte svar passe; for et vanskelig problem kan arbeidsflyten med tenkning utvikle en løsning før sluttresultatet presenteres. Angi det nødvendige svaret eller artefakten uavhengig av den mellomliggende resonneringen.

En vesentlig endring i utgaven er tenkning med verktøy. Det oppdaterte chatformatet lar resonneringen fortsette gjennom en oppgave med verktøykall, fremfor å behandle analyse og handling som uavhengige stadier. En operasjon valgt av modellen utføres av applikasjonen, som returnerer resultatet til neste trinn. Produsentens regel for verktøykontekst beholder historisk resonnering så lenge bare verktøyrelaterte meldinger legges til; når en ny brukermelding kommer, forkastes denne resonneringen mens verktøykall og resultater bevares. Korrekt skille mellom samtalerollene er viktig for denne atferden.

For koding legger du ved kildefragmentet eller relevante filer, det observerte problemet, forventet resultat og vilkårene endringen må bevare. Et illustrerende oppdrag er: «Bruk den innsendte koden og verktøyresultatene til å finne årsaken, foreslå den minste rettingen og returner den endelige patchen med underbyggende valideringsresultat.» For en søkeoppgave beskriver du spørsmålet, nødvendig dokumentasjon og hva som regnes som et fullført svar. Søke- og kjøringsverktøy leveres av applikasjonen rundt modellen, fremfor av teksten alene.

Produsenten anbefaler temperature 1.0 og top-p 0.95 for lokal bruk. V3.2 introduserer en revidert representasjon av verktøykall og en egen meldingsenkoder. Rollen developer er reservert for produsentens søkeagentmal, og det offisielle API-et tar ikke imot denne rollen. Referanseparseren forventer velformede utdata og reparerer ikke feilformede resultater; når en applikasjon bruker genererte felt eller verktøyargumenter, bør den kontrollere strukturen før den handler på grunnlag av dem.

Den tekniske rapporten identifiserer lange resonneringsforløp og overflødig selvverifisering som praktiske begrensninger. En agentoppgave kan nå 128K-grensen selv når det opprinnelige kildematerialet får plass, fordi verktøyutdata og gjentatt resonnering akkumuleres. Hold en kort oversikt over relevante observasjoner og gjør sluttartefakten uttrykkelig. For kunnskapssensitivt arbeid legger du ved det autoritative materialet eller tilbyr et egnet søkeverktøy, fremfor å forvente at treningskunnskapen definerer hvert faktum.

DeepSeek V3.2 Speciale er en separat variant for dyp resonnering med høyt beregningsforbruk og støtter ifølge modellkortet ikke verktøykall. Egenskapene bør ikke brukes som standardprofilen for verktøy i V3.2. På samme måte har den senere V4-generasjonen og den eksperimentelle forgjengeren separate identiteter og konfigurasjonsvalg. Bevar den navngitte V3.2-utgaven når du sammenligner oppgaver der modell og instruksjonsformat er viktige.

For en praktisk kildebasert analyse merker du materialene og ber om en konklusjon underbygd av relevante avsnitt, med antakelser og manglende informasjon holdt atskilt. For en agent oppgir du tillatte funksjoner, forventet sluttresultat og fullføringskriteriet. Dette klargjør modellens arbeidsflyt for resonnering og verktøy rundt en tekst-, kode- eller analyseartefakt som kan vurderes og er knyttet til den innsendte dokumentasjonen.

**Ailoot Ultra · OpenAI Chat** `POST /v1/chat/completions` `deepseek-v3.2-thinking`

[`deepseek-v3.2-thinking`](https://ailoot.ai/models/nb/#m=deepseek-v3.2-thinking&route=Ultra&caller=deepseek-v3.2-thinking&fmt=chat)

DeepSeek /`deepseek-v3.2-thinking`

### Start

DeepSeek V3.2 kombinerer tekstbasert resonnering med verktøybruk og analyse av lang kontekst. Arkitekturen med sparsom attention og det oppdaterte samtaleformatet støtter koding, søk og agentoppgaver i flere trinn, med en kontekst på 128K og separate arbeidsflyter for tenkning og direkte svar.

Godkjente inndata

Tekst

Resultater

Tekst

### Tilgjengelig i Ailoot · inndata & metoder

**Ailoot Ultra · OpenAI Chat** `POST /v1/chat/completions`

Inndatatyper

`text`

Utdatatyper

`text`

Utdataformat

json eller SSE

| Felt | Type | Krav | Verdier & grenser | Standard |
| --- | --- | --- | --- | --- |
| Felt`model` | Type`string` | KravPåkrevd | Verdier & grenser deepseek-v3.2-thinking | Standard— |
| Felt`messages` | Type`message[]` | KravPåkrevd | Verdier & grenser Minste antall elementer: 1 | Standard— |
| Felt`messages[].role` | Type`string` | KravPåkrevd | Verdier & grenser Avhenger av modellen | Standard— |
| Felt`messages[].content` | Type`string` | KravValgfritt | Verdier & grenser Gjelder når: Tekstsamtale | Standard— |
| Felt`stream` | Type`boolean` | KravValgfritt | Verdier & grenser | Standardfalse |

Kombinasjoner av inngående materialer

**Tekst** · UTF8-tekst

`messages[].content`

Metodeparametere og livssyklus

| Parameter | Avtale |
| --- | --- |
| Parameter`content_type` | Avtaleapplication/json |
| Parameter`required` | Avtalemodel, messages |
| Parameter`material_types` | Avtaletext |
| Parameter`messages` | Avtalemeldingstabell med role/content-struktur |
| Parameter`file_material` | Avtalefaktisk UTF-8-dokument satt inn som bokstavelig tekst; ingen fil-ID utledes |
| Parameter`optional_controls` | Avtalestream |
| Parameter`control_scope` | AvtaleTekstsamtale; stream er en boolsk verdi med false som standard. |
| Parameter`output_modalities` | Avtaletext |
| Parameter`hosted_operations` | Avtalefalse |
| Parameter`multimodal_input_binding` | Avtalenull |

Metodealiaser: `/chat/completions`

Livssyklus: `synchronous_or_streamed`

Send eksakt modell-ID sammen med messages.

Kontekstlengde er ikke en outputgrense.

En tekstfil kan levere bokstavelig tekst; bilde-, lyd- og filobjektinput trenger eksakt binding.

### Priser

Tariffopplysninger legger ikke til forespørselsvalg. Støttede parametere står ved den valgte metoden.

Hurtigmodus

Ikke angitt Når hurtigmodus er valgt

Flex-modus

Ikke angitt Når flex-modus er valgt

Maksimal resonneringsinnsats

Ikke angitt Når justeringen «default» brukes for maksimal resonneringsinnsats

#### Ailoot-satser

#### Priser etter konfigurasjon

| Konfigurasjon | Prisplan | Kostnad |
| --- | --- | --- |
| KonfigurasjonGrunnpriser for tokener | PrisplanGrunnsats | Kostnad Inndata · Inngående tokener **$0.00058** / 1K tokener Utdata · Utgående tokener **$0.00086** / 1K tokener Inndata · Lesing fra hurtigbuffer **$0** / 1K tokener Inndata · Skriving til hurtigbuffer **$0** / 1K tokener Inndata · Skriving til hurtigbuffer, 1 time **—** / 1K tokener |

Ailoot reserverer et estimert beløp før en forespørsel. Etter resultatet gjøres det endelige beløpet opp basert på målt forbruk. Oppgjør for strømming bruker den endelige forbruksposten. [Slik fungerer reservasjon og oppgjør →](https://ailoot.ai/docs/nb/billing/reserve/)

### Eksempelforespørsler

#### Ailoot Ultra · OpenAI Chat

curlPython SDK

```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model":"deepseek-v3.2-thinking","messages":[{"role":"user","content":"hello"}],"stream":false}')

Path("request.json").write_text(json.dumps(p,ensure_ascii=False))
PY_REQUEST
curl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/chat/completions \
  -H "Authorization: Bearer $AILOOT_API_KEY" -H 'Content-Type: application/json' \
  --data-binary @request.json -D response-headers.txt -o result.json
python3 - <<'PY_RESULT'
import json
from pathlib import Path
r=json.loads(Path("result.json").read_text())
for x in r.get("choices",[]):
    if x.get("message",{}).get("content"): print(x["message"]["content"])
PY_RESULT
```

```python
from openai import OpenAI
import os

if not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")
client=OpenAI(base_url="https://api.ailoot.ai/v1",api_key=os.environ["AILOOT_API_KEY"],max_retries=0)
result=client.chat.completions.create(model="deepseek-v3.2-thinking", messages=[{"role":"user","content":"hello"}], stream=False)
import base64, json
from pathlib import Path

def save_result(data, stem="result"):
    # Keep every field, including usage, IDs, reasoning and tool requests.
    Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
    print(json.dumps(data, ensure_ascii=False, indent=2))
    def save_blob(encoded, suffix, label):
        raw = base64.b64decode(encoded, altchars=b"-_", validate=True)
        ext = "png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "jpg" if raw.startswith(b"\xff\xd8") else "webp" if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" else suffix
        file = Path(stem + "-" + label + "." + ext)
        file.write_bytes(raw)
        print("Saved", file)
    for index, block in enumerate(data.get("content") or []):
        print("Content", index, json.dumps(block, ensure_ascii=False))
    for choice in data.get("choices") or []:
        print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))
    for index, item in enumerate(data.get("output") or []):
        print("Output", index, json.dumps(item, ensure_ascii=False))
        if item.get("type") == "image_generation_call" and item.get("result"):
            save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))
    for ci, candidate in enumerate(data.get("candidates") or []):
        for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):
            print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))
            blob = part.get("inlineData") or part.get("inline_data")
            if blob and blob.get("data"):
                mime = blob.get("mimeType") or blob.get("mime_type")
                suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")
                save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))

save_result(result.to_dict(mode="json"))
```

### Motta og lagre resultater

#### Ailoot Ultra · OpenAI Chat

json eller SSE

##### Behold alle ferdige resultater

Behold alle fullstendige returnerte svar, filer og innholdsdeler.

Behold hvert svaralternativ med innhold, verktøykall og resonnering. Sett sammen endringer i SSE etter svaralternativets/verktøyets indeks, og behold endelig avslutningsgrunn og bruksdata.

##### Hvis det opprinnelige svaret må kontrolleres

Behold forespørsels-/svar-ID-er og headere. Ingen generell URL for henting av tekstjobber oppgis.

Svarfelter

| Felt | Type |
| --- | --- |
| Felt`choices[].index` | Typeinteger |
| Felt`choices[].message.content` | Typestring\|null |
| Felt`choices[].message.tool_calls` | Typetool\_call\[\] |
| Felt`choices[].message.reasoning_content` | Typestring |
| Felt`choices[].message.reasoning_details` | Typeobject\|array |
| Felt`choices[].finish_reason` | Typestring\|null |
| Felt`usage` | Typeobject |

Feil og neste trinn

| Svar | Vilkår | Neste trinn |
| --- | --- | --- |
| Svar400 · `invalid_request_error` | VilkårUgyldige påkrevde felter, materialrepresentasjon eller parameterverdi | Neste trinnKorriger de angitte feltene før en ny opprettelsesforespørsel. |

### Aliaser

#### Modellaliaser

**Ailoot Ultra** [`deepseek-v3.2-thinking`](https://ailoot.ai/models/nb/#m=deepseek-v3.2-thinking&route=Ultra&caller=deepseek-v3.2-thinking&fmt=chat)

#### Aliaser for metodestier

`/chat/completions`

#### Tilknyttede anroper-ID-er

[`deepseek-v3.2-thinking`](https://ailoot.ai/models/nb/#m=deepseek-v3.2-thinking&route=Ultra&caller=deepseek-v3.2-thinking&fmt=chat)

FAQ · DeepSeek: DeepSeek V3.2

Hvilke inndata og resultater er tilgjengelige?

`POST /v1/chat/completions` · `deepseek-v3.2-thinking`: `text` → `text`

Hvilke felt bruker forespørselen?

`POST /v1/chat/completions` · `deepseek-v3.2-thinking`: `model`, `messages`, `stream`

Hvilke grenser gjelder?

`POST /v1/chat/completions` · `deepseek-v3.2-thinking`: `messages.min_items`: `1`

Koble Ailoot til Claude Code, OpenCode, Hermes eller egen applikasjon.

## Selskapet og dets prosjektportefølje

Selskapet og dets prosjektportefølje: millioner av kunder; månedlig salg for milliarder.

## Kjøp tokener med rabatt.

Abonnementsrabatt for jevnlig bruk. Kampanjekoder gir opptil 50% på tokenkjøp.

Abonnement

Velg et rabattabonnement for faste forespørsler.

Kampanjekode opptil 50%

Oppgi kode ved kjøp. Prisen beregnes på nytt etter gjeldende kampanje.

Kostnader i historikken

Modell, tokener og beløp lagres for hver forespørsel.

[Velg abonnement](https://ailoot.ai/docs/nb/billing/subscriptions/) · [Se modellpriser](https://ailoot.ai/models/nb/)

## Koble API-et til produktet du selger.

SaaS, apper og boter etter Ailoots offentlige tilbud og lisensavtale. Be om forhandlerlisens for videresalg.

Kommersiell applikasjon

Bygg tekst-, bilde-, video- og lydgenerering inn i betalte funksjoner i tjenesten.

Forhandlerlisens

Send prosjektbeskrivelse og tilgangsopplegg. Be om skriftlige vilkår for bruk og videresalg.

Dokumenter på nettstedet

Offentlig tilbud, lisensavtale og retningslinjer for databehandling er tilgjengelige før tilkobling.

[Be om forhandlerlisens](mailto:support@ailoot.ai) · [Offentlig tilbud og lisensavtale](https://ailoot.ai/legal/offer?lang=nb)

## Ailoot · Selskapet og dets prosjektportefølje





Ailoot bygger på etablert driftserfaring, en stor kundebase, stabil tjeneste og løpende KPI-kontroll.





Selskapet og dets prosjektportefølje: millioner av kunder; månedlig salg for milliarder.





Ailoot bruker denne driftserfaringen til API-tilgang til AI-funksjoner i kundenes produkter, agenter, applikasjoner og automatiseringer.
