modelli

DeepSeek: DeepSeek V3.2

Markdown · JSON

DeepSeek: DeepSeek V3.2

DeepSeek V3.2 combina ragionamento testuale, uso degli strumenti e analisi di contesti lunghi. La sua architettura di attenzione sparsa e il formato di conversazione aggiornato supportano programmazione, ricerca e attività degli agenti in più passaggi, con un contesto di 128K e flussi distinti per il ragionamento e la risposta diretta.

Informazioni sul modello

Questa descrizione illustra le funzionalità del modello. Gli input, gli output e le opzioni disponibili in Ailoot per il metodo selezionato sono elencati di seguito.

DeepSeek V3.2 è il modello testuale di DeepSeek per il ragionamento e il lavoro degli agenti, con particolare attenzione all'elaborazione efficiente dei contesti lunghi. Il produttore organizza i suoi principali cambiamenti intorno a DeepSeek Sparse Attention, a un framework di apprendimento per rinforzo ampliato su larga scala e a una pipeline di addestramento per attività agentiche. Accetta domande scritte e contesto e produce testo, che può comprendere una risposta, codice o contenuti di chiamate a strumenti. È distinto dalla precedente versione V3.2 Exp e dalla variante separata di ragionamento Speciale.

DeepSeek Sparse Attention aggiunge un indicizzatore e una selezione dei token a grana fine all'architettura di attenzione latente. Per una sequenza lunga, l'indicizzatore seleziona le informazioni dei token precedenti usate dal calcolo principale dell'attenzione. Il rapporto afferma che questa è la modifica architetturale rispetto a V3.1 Terminus e che usa la stessa architettura di V3.2 Exp. Il suo contesto pubblicato è di 128K token, che supporta ampio materiale di partenza e un'attività continuativa, mentre anche il ragionamento generato e la cronologia degli strumenti consumano il contesto disponibile.

Il post-addestramento copre risposte con e senza ragionamento in matematica, programmazione, ragionamento logico, attività generali degli agenti, programmazione agentica e ricerca. Specialisti dei diversi domini forniscono dati che vengono consolidati nel modello finale, seguiti da apprendimento per rinforzo misto. Per una domanda ordinaria può essere appropriata una risposta diretta; per un problema difficile, il flusso con ragionamento può sviluppare una soluzione prima di presentare il risultato finale. Specifica la risposta o l'elaborato richiesto indipendentemente dal ragionamento intermedio.

Un cambiamento sostanziale dell'edizione è il ragionamento con gli strumenti. Il formato di chat aggiornato consente al ragionamento di proseguire durante un'attività che chiama strumenti, anziché trattare analisi e azione come fasi scollegate. Un'operazione selezionata dal modello viene eseguita dall'applicazione, che ne restituisce il risultato per il passaggio successivo. La regola del produttore sul contesto degli strumenti conserva il ragionamento precedente finché vengono aggiunti soltanto messaggi relativi agli strumenti; quando arriva un nuovo messaggio dell'utente, elimina quel ragionamento mantenendo le chiamate agli strumenti e i risultati. La corretta distinzione dei ruoli della conversazione è importante per questo comportamento.

Per la programmazione, fornisci il frammento sorgente o i file pertinenti, il problema osservato, il risultato atteso e le condizioni che la modifica deve preservare. Un brief esemplificativo è: “Usa il codice fornito e i risultati degli strumenti per individuare la causa, proporre la correzione più piccola e restituire la patch finale con il relativo risultato di verifica a sostegno.” Per un'attività di ricerca, descrivi la domanda, le prove richieste e ciò che costituisce una risposta completa. Gli strumenti di ricerca e di esecuzione sono forniti dall'applicazione circostante, anziché dal solo testo.

Il produttore raccomanda una temperatura di 1.0 e top-p 0.95 per l'uso locale. V3.2 introduce una rappresentazione rivista delle chiamate agli strumenti e un encoder dedicato per i messaggi. Il suo ruolo developer è riservato al template dell'agente di ricerca del produttore e l'API ufficiale non accetta tale ruolo. Il parser di riferimento si aspetta un output ben formato e non ripara i risultati malformati; quando un'applicazione usa campi generati o argomenti per gli strumenti, dovrebbe verificarne la struttura prima di agire su di essi.

Il rapporto tecnico identifica le lunghe sequenze di ragionamento e l'autoverifica ridondante come limiti pratici. Un'attività agentica può raggiungere il limite di 128K anche quando il materiale di partenza originale rientra nel contesto, perché gli output degli strumenti e il ragionamento ripetuto si accumulano. Mantieni una registrazione concisa delle osservazioni pertinenti e rendi esplicito l'elaborato finale. Per il lavoro che dipende da conoscenze accurate, allega il materiale autorevole o fornisci uno strumento di ricerca adatto, anziché aspettarti che le conoscenze apprese durante l'addestramento definiscano ogni fatto.

DeepSeek V3.2 Speciale è una variante separata di ragionamento profondo ad alto impiego di risorse di calcolo e, secondo la scheda del modello, non supporta la chiamata di strumenti. Le sue caratteristiche non dovrebbero essere usate come profilo degli strumenti di V3.2 standard. Allo stesso modo, la successiva generazione V4 e il predecessore sperimentale hanno identità e scelte di configurazione separate. Conserva l'edizione con denominazione specifica V3.2 quando confronti attività in cui il modello e il formato dei prompt sono importanti.

Per un'analisi pratica basata sulle fonti, etichetta i materiali e richiedi una conclusione supportata dai passaggi pertinenti, mantenendo distinte le ipotesi e le informazioni mancanti. Per un agente, indica le funzioni consentite, il risultato finale atteso e il criterio di completamento. Questo prepara il flusso di ragionamento e strumenti del modello intorno a un elaborato testuale, di codice o analitico esaminabile e collegato alle prove fornite.

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

deepseek-v3.2-thinking

DeepSeek /deepseek-v3.2-thinking

Introduzione

DeepSeek V3.2 combina ragionamento testuale, uso degli strumenti e analisi di contesti lunghi. La sua architettura di attenzione sparsa e il formato di conversazione aggiornato supportano programmazione, ricerca e attività degli agenti in più passaggi, con un contesto di 128K e flussi distinti per il ragionamento e la risposta diretta.

Input accettati
Testo
Risultati
Testo

Disponibile in Ailoot · input e metodi

Ailoot Ultra · OpenAI Chat POST /v1/chat/completions
Tipi di input
text
Tipi di output
text
Formato di output
json o SSE
CampoTipoRequisitoValori e limitiPredefinito
CampomodelTipostringRequisitoObbligatorioValori e limiti
deepseek-v3.2-thinking
Predefinito—
CampomessagesTipomessage[]RequisitoObbligatorioValori e limiti
Numero minimo di elementi: 1
Predefinito—
Campomessages[].roleTipostringRequisitoObbligatorioValori e limiti
Dipende dal modello
Predefinito—
Campomessages[].contentTipostringRequisitoFacoltativoValori e limiti
Si applica quando: Conversazione testuale
Predefinito—
CampostreamTipobooleanRequisitoFacoltativoValori e limitiPredefinitofalse
Combinazioni di materiali in input

Testo · Testo UTF8

messages[].content

Parametri e ciclo di vita del metodo
ParametroContratto
Parametrocontent_typeContrattoapplication/json
ParametrorequiredContrattomodel, messages
Parametromaterial_typesContrattotext
ParametromessagesContrattoArray di messaggi con struttura role/content
Parametrofile_materialContrattoDocumento UTF-8 effettivo inserito come testo letterale; nessun ID di file dedotto
Parametrooptional_controlsContrattostream
Parametrocontrol_scopeContrattoConversazione testuale; stream è un booleano e per impostazione predefinita vale false.
Parametrooutput_modalitiesContrattotext
Parametrohosted_operationsContrattofalse
Parametromultimodal_input_bindingContrattonull

Alias del metodo: /chat/completions

Ciclo di vita: synchronous_or_streamed

Invia l’ID esatto del modello con messages.

La lunghezza del contesto non è un limite di uscita.

Un file di testo può fornire testo letterale; gli ingressi immagine/audio/oggetto file richiedono un’associazione esatta.

Tariffe

Le tariffe non aggiungono opzioni alla richiesta. I parametri supportati sono elencati nel metodo selezionato.

Modalità rapida
Non specificato Quando è selezionata la modalità rapida
Modalità flex
Non specificato Quando è selezionata la modalità flex
Sforzo massimo di ragionamento
Non specificato Quando lo sforzo massimo di ragionamento usa l'adeguamento predefinito (default)

Tariffe Ailoot

Prezzi per configurazione

ConfigurazioneListino delle tariffeCosto
ConfigurazioneTariffe di base dei tokenListino delle tariffeTariffa baseCosto
Input · Token in input $0.00058 / 1K token
Output · Token in output $0.00086 / 1K token
Input · Lettura dalla cache $0 / 1K token
Input · Scrittura nella cache $0 / 1K token
Input · Scrittura nella cache, 1 ora — / 1K token

Ailoot prenota un importo stimato prima di una richiesta. Dopo il risultato, addebita il costo finale in base all’utilizzo misurato. Per lo streaming, l’addebito usa il record finale di utilizzo. Come funzionano la prenotazione e l’addebito finale →

Esempi di richieste

Ailoot Ultra · OpenAI Chat

curlPython SDK
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
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"))

Ricevi e salva i risultati

Ailoot Ultra · OpenAI Chat

json o SSE

Conserva tutti i risultati completati

Conserva ogni risposta, file e parte di contenuto restituiti per intero.

Conserva ogni scelta con contenuto, chiamate agli strumenti e ragionamento. In SSE assembla i delta per indice di scelta e strumento e conserva il motivo finale di completamento e i dati di utilizzo.

Se occorre verificare la risposta originale

Conserva gli ID e le intestazioni di richiesta/risposta. Non viene fornito alcun URL generico per recuperare un’attività testuale.

Campi della risposta
CampoTipo
Campochoices[].indexTipointeger
Campochoices[].message.contentTipostring|null
Campochoices[].message.tool_callsTipotool_call[]
Campochoices[].message.reasoning_contentTipostring
Campochoices[].message.reasoning_detailsTipoobject|array
Campochoices[].finish_reasonTipostring|null
CampousageTipoobject
Errori e passaggi successivi
RispostaCondizionePassaggio successivo
Risposta400 · invalid_request_errorCondizioneCampi obbligatori, rappresentazione del materiale o valore del parametro non validiPassaggio successivoCorreggi i campi indicati prima di una nuova richiesta di creazione.

Alias

Alias del modello

Ailoot Ultra deepseek-v3.2-thinking

Alias dei percorsi dei metodi

/chat/completions

ID di chiamata correlati

deepseek-v3.2-thinking

FAQ · DeepSeek: DeepSeek V3.2
Quali input e risultati sono disponibili?

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

Quali campi usa la richiesta?

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

Quali limiti si applicano?

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

Maggiori dettagli

Collega Ailoot a Claude Code, OpenCode, Hermes o alla tua applicazione.

L’azienda e il suo portafoglio di progetti

L’azienda e il suo portafoglio di progetti: milioni di clienti; vendite nell’ordine dei miliardi ogni mese.

Acquista token con uno sconto.

Sconto con abbonamento per lavoro regolare. Codici fino al 50% sull’acquisto di token.

Abbonamento
Scegli un piano scontato per richieste regolari.
Codice fino al 50%
Inserisci il codice all’acquisto. Il prezzo si aggiorna secondo la promozione.
Spese nella cronologia
Modello, token e importo sono salvati per ogni richiesta.

Scegli abbonamento · Consulta prezzi dei modelli

Collega l’API al prodotto che vendi.

SaaS, app e bot secondo offerta e accordo di licenza Ailoot. Per rivendere, richiedi una licenza reseller.

Applicazione commerciale
Integra generazione di testo, immagini, video e suono nelle funzioni a pagamento.
Licenza reseller
Invia descrizione del progetto e schema di accesso. Richiedi condizioni scritte per uso e rivendita.
Documenti sul sito
Offerta, accordo di licenza e politica sui dati sono disponibili prima della connessione.

Richiedi licenza reseller · Offerta e accordo di licenza