Source: https://ailoot.ai/models/it/qwen-qwen2-5-coder-32b-instruct/
Canonical: https://ailoot.ai/models/it/qwen-qwen2-5-coder-32b-instruct/
Language: it

# Qwen2.5 Coder 32B Instruct

[Markdown](https://ailoot.ai/models/it/qwen-qwen2-5-coder-32b-instruct/index.md) · [JSON](https://ailoot.ai/models/it/qwen-qwen2-5-coder-32b-instruct/facts.json)

## [Qwen2.5 Coder 32B Instruct](https://ailoot.ai/models/it/qwen-qwen2-5-coder-32b-instruct/)

Qwen2.5-Coder-32B-Instruct è un modello di programmazione ottimizzato per seguire istruzioni, destinato a generare, spiegare e correggere codice. Fornisci file pertinenti, comportamento previsto ed evidenze dei test per ottenere un’implementazione o una correzione mirata, con il comportamento dei contesti lunghi determinato dalla configurazione del servizio.

- [**Ailoot Ultra · OpenAI Chat** `POST /v1/chat/completions` `Qwen/Qwen2.5-Coder-32B-Instruct`](https://ailoot.ai/models/it/qwen-qwen2-5-coder-32b-instruct/#method-0)
- [**Ailoot Ultra · Anthropic Messages** `POST /v1/messages` `Qwen/Qwen2.5-Coder-32B-Instruct`](https://ailoot.ai/models/it/qwen-qwen2-5-coder-32b-instruct/#method-1)

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.

Qwen2.5-Coder-32B-Instruct è l’edizione 32B ottimizzata per seguire istruzioni della serie Qwen2.5-Coder. Il produttore sviluppa questa serie per generazione di codice, ragionamento sul codice e correzione del codice, conservando le capacità matematiche e linguistiche generali. Il numero di parametri pubblicato per questa edizione è 32,5 miliardi. Il formato conversazionale permette di combinare istruzioni, sorgente e risultato previsto dalla prossima modifica.

#### Genera codice secondo un contratto chiaro

Parti dall’interfaccia che il codice deve implementare, dai tipi di input e output e da alcuni esempi rappresentativi. Indica il linguaggio e le convenzioni pertinenti del progetto. Chiedi l’implementazione e test che coprano i casi indicati. Se una funzione ausiliaria esistente definisce già il comportamento, includila, così che la proposta segua il progetto anziché creare uno schema parallelo.

Per una piccola funzionalità, fornisci il modulo interessato e spiega dove si inserisce il risultato nell’applicazione. Chiedi una modifica mirata che espliciti eventuali nuove ipotesi. Il modello restituisce codice e spiegazioni; compilazione, esecuzione e integrazione avvengono nell’ambiente di sviluppo.

#### Spiega o correggi un’implementazione esistente

Un incarico di debug deve includere l’errore esatto, l’input che lo provoca e il comportamento previsto al suo posto. Chiedi al modello di collegare il problema a una parte specifica del codice fornito prima di proporre una correzione. Un seguito utile richiede un test che fallisca con il comportamento originale e passi dopo la modifica proposta.

Per una revisione, definisci la domanda: gestione di input vuoti, ordinamento, rilascio delle risorse o significato di un valore restituito. Chiedi la posizione pertinente nel codice e un esempio che dimostri il problema. Mantieni i suggerimenti collegati ai file che il modello può esaminare, poi verifica ogni modifica proposta nel progetto.

#### Usa intenzionalmente il contesto lungo

La scheda descrive un contesto completo di 131.072 token, mentre la configurazione base pubblicata è impostata su 32.768. La procedura del produttore per testi lunghi abilita la scalatura YaRN per input oltre quella configurazione base. È un dettaglio della configurazione del servizio, quindi una richiesta a un modello ospitato va pianificata intorno al contesto consentito dal suo endpoint effettivo.

Il produttore osserva inoltre che la scalatura YaRN statica può influire sulle prestazioni con testi più brevi e consiglia di abilitarla quando serve un contesto lungo. Per una normale domanda sul codice, invia prima le interfacce e gli estratti pertinenti. Per un compito tra più file, identifica punto di ingresso, dipendenze e condizioni di accettazione, lasciando spazio per l’implementazione e la spiegazione richieste.

Caso pratico

### Caso pratico

Esempio tecnico in inglese

```
Fix stable deduplication order

Review this Python function: def unique(values): return list(set(values)). The contract requires keeping the first occurrence of each hashable value in input order. Propose a corrected implementation preserving the signature and input list. Include tests for repeated strings, empty input and values already unique. Explain why a set conversion alone does not express the ordering contract.
```

#### Risultato atteso

```
A complete stable-deduplication function, three tests and a short ordering explanation.
```

#### Verificare il risultato

```
The repeated-input test checks first-occurrence order, and the original list remains unchanged.
```

**Ailoot Ultra · OpenAI Chat** `POST /v1/chat/completions` `Qwen/Qwen2.5-Coder-32B-Instruct`

[`Qwen/Qwen2.5-Coder-32B-Instruct`](https://ailoot.ai/models/it/#m=Qwen%2FQwen2.5-Coder-32B-Instruct&route=Ultra&caller=Qwen%2FQwen2.5-Coder-32B-Instruct&fmt=chat)

Alibaba /`Qwen/Qwen2.5-Coder-32B-Instruct`

### Introduzione

Qwen2.5-Coder-32B-Instruct è un modello di programmazione ottimizzato per seguire istruzioni, destinato a generare, spiegare e correggere codice. Fornisci file pertinenti, comportamento previsto ed evidenze dei test per ottenere un’implementazione o una correzione mirata, con il comportamento dei contesti lunghi determinato dalla configurazione del servizio.

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

| Campo | Tipo | Requisito | Valori e limiti | Predefinito |
| --- | --- | --- | --- | --- |
| Campo`model` | Tipo`string` | RequisitoObbligatorio | Valori e limiti Qwen/Qwen2.5-Coder-32B-Instruct | Predefinito— |
| Campo`messages` | Tipo`message[]` | RequisitoObbligatorio | Valori e limiti Numero minimo di elementi: 1 | Predefinito— |
| Campo`messages[].role` | Tipo`string` | RequisitoObbligatorio | Valori e limiti Esempi: system, user, assistant, tool, function Condizioni: Questi ruoli sono rappresentati esplicitamente dai tipi di compatibilità del codice sorgente; l’insieme esatto dei ruoli rimane specifico del modello. Dipende dal modello | Predefinito— |
| Campo`messages[].content` | Tipo`string\|content_part[]\|null` | RequisitoFacoltativo | Valori e limiti | Predefinito— |
| Campo`messages[].tool_calls` | Tipo`tool_call[]` | RequisitoFacoltativo | Valori e limiti | Predefinito— |
| Campo`messages[].tool_call_id` | Tipo`string` | RequisitoFacoltativo | Valori e limiti Si applica quando: role=tool; usa l’ID effettivamente restituito | Predefinito— |
| Campo`messages[].name` | Tipo`string` | RequisitoFacoltativo | Valori e limiti | Predefinito— |
| Campo`messages[].reasoning_content` | Tipo`string` | RequisitoFacoltativo | Valori e limiti Si applica quando: Reinserisci il ragionamento effettivamente restituito quando il modello lo utilizza | Predefinito— |
| Campo`messages[].reasoning_details` | Tipo`object\|array` | RequisitoFacoltativo | Valori e limiti Dipende dal modello | Predefinito— |
| Campo`max_tokens` | Tipo`integer` | RequisitoFacoltativo | Valori e limiti Minimo: 1 Dipende dal modello | Predefinito— |
| Campo`max_completion_tokens` | Tipo`integer` | RequisitoFacoltativo | Valori e limiti Minimo: 1 Dipende dal modello | Predefinito— |
| Campo`stream` | Tipo`boolean` | RequisitoFacoltativo | Valori e limiti | Predefinitofalse |
| Campo`stream_options.include_usage` | Tipo`boolean` | RequisitoFacoltativo | Valori e limiti Dipende dal modello | Predefinito— |
| Campo`temperature` | Tipo`number` | RequisitoFacoltativo | Valori e limiti Dipende dal modello | Predefinito— |
| Campo`top_p` | Tipo`number` | RequisitoFacoltativo | Valori e limiti Dipende dal modello | Predefinito— |
| Campo`stop` | Tipo`string\|string[]` | RequisitoFacoltativo | Valori e limiti Dipende dal modello | Predefinito— |
| Campo`tools` | Tipo`function_tool[]` | RequisitoFacoltativo | Valori e limiti Dipende dal modello | Predefinito— |
| Campo`tools[].type` | Tipo`string` | RequisitoFacoltativo | Valori e limiti function Dipende dal modello | Predefinito— |
| Campo`tools[].function.name` | Tipo`string` | RequisitoObbligatorio | Valori e limiti Si applica quando: Funzione fornita come strumento | Predefinito— |
| Campo`tools[].function.description` | Tipo`string` | RequisitoFacoltativo | Valori e limiti | Predefinito— |
| Campo`tools[].function.parameters` | Tipo`JSON_schema` | RequisitoFacoltativo | Valori e limiti | Predefinito— |
| Campo`tool_choice` | Tipo`string\|object` | RequisitoFacoltativo | Valori e limiti Dipende dal modello | Predefinito— |
| Campo`parallel_tool_calls` | Tipo`boolean` | RequisitoFacoltativo | Valori e limiti Dipende dal modello | Predefinito— |
| Campo`response_format` | Tipo`object` | RequisitoFacoltativo | Valori e limiti Dipende dal modello | Predefinito— |
| Campo`reasoning_effort` | Tipo`string` | RequisitoFacoltativo | Valori e limiti Dipende dal modello | Predefinito— |
| Campo`reasoning` | Tipo`object` | RequisitoFacoltativo | Valori e limiti Dipende dal modello | Predefinito— |
| Campo`service_tier` | Tipo`string` | RequisitoFacoltativo | Valori e limiti Dipende dal modello | Predefinito— |
| Campo`instructions` | Tipo`string` | RequisitoFacoltativo | Valori e limiti Campo di compatibilità | Predefinito— |
| Campo`functions` | Tipo`function[]` | RequisitoFacoltativo | Valori e limiti Dipende dal modello | Predefinito— |
| Campo`function_call` | Tipo`string\|object` | RequisitoFacoltativo | Valori e limiti Dipende dal modello | Predefinito— |
| Campo`prompt_cache_options` | Tipo`object` | RequisitoFacoltativo | Valori e limiti Dipende dal modello | Predefinito— |
| Campo`modalities` | Tipo`string[]` | RequisitoFacoltativo | Valori e limiti text | Predefinito— |
| Campo`provider` | Tipo`object` | RequisitoFacoltativo | Valori e limiti Condizioni: provider.options viene rifiutato su questa rotta testuale Ultra | Predefinito— |
| Campo`cache_control.ttl` | Tipo`string` | RequisitoFacoltativo | Valori e limiti Condizioni: 1h viene rifiutato nelle posizioni effettive della cache dei prompt | Predefinito— |

Combinazioni di materiali in input

**Testo** · Testo UTF8

`messages[].content`

Parametri e ciclo di vita del metodo

| Parametro | Contratto |
| --- | --- |
| Parametro`content_type` | Contrattoapplication/json |
| Parametro`required` | Contrattomodel, messages |
| Parametro`material_types` | Contrattotext |
| Parametro`messages` | ContrattoArray di messaggi con struttura role/content |
| Parametro`file_material` | ContrattoDocumento UTF-8 effettivo inserito come testo letterale; nessun ID di file dedotto |
| Parametro`optional_controls` | Contrattostream, temperature, top\_p, stop, max\_tokens, max\_completion\_tokens, reasoning, response\_format, tools, tool\_choice |
| Parametro`control_scope` | ContrattoSpecifico del modello; gli strumenti di funzione dell’utente differiscono dagli strumenti ospitati |
| Parametro`output_modalities` | Contrattotext |
| Parametro`hosted_operations` | Contrattofalse |
| Parametro`multimodal_input_binding` | Contrattonull |

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

| Configurazione | Listino delle tariffe | Costo |
| --- | --- | --- |
| ConfigurazioneTariffe di base dei token | Listino delle tariffeTariffa base | Costo Input · Token in input **$0.00036** / 1K token Output · Token in output **$0.00036** / 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 →](https://ailoot.ai/docs/it/billing/reserve/)

### Esempi di richieste

#### Ailoot Ultra · OpenAI Chat

curlPython SDKStreaming Python

```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": "Qwen/Qwen2.5-Coder-32B-Instruct", "messages": [{"role": "user", "content": "Explain the difference between an observation and a hypothesis in three sentences."}]}')

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='Qwen/Qwen2.5-Coder-32B-Instruct',messages=[{"role":"user","content":"Explain observations and hypotheses in three sentences."}])
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"))
```

```python
from openai import OpenAI
import os
from pathlib import Path

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

with client.chat.completions.stream(model='Qwen/Qwen2.5-Coder-32B-Instruct',messages=[{"role":"user","content":"Explain observations and hypotheses in three sentences."}]) as stream:
    with Path("stream-events.jsonl").open("w",encoding="utf-8") as log:
        for event in stream:
            payload=event.to_dict(mode="json")
            log.write(json.dumps(payload,ensure_ascii=False)+"\n"); log.flush()
            print(json.dumps(payload,ensure_ascii=False))
    final=stream.get_final_completion()
    save_result(final.to_dict(mode="json"),"stream-result")
```

### 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

| Campo | Tipo |
| --- | --- |
| Campo`choices[].index` | Tipointeger |
| Campo`choices[].message.content` | Tipostring\|null |
| Campo`choices[].message.tool_calls` | Tipotool\_call\[\] |
| Campo`choices[].message.reasoning_content` | Tipostring |
| Campo`choices[].message.reasoning_details` | Tipoobject\|array |
| Campo`choices[].finish_reason` | Tipostring\|null |
| Campo`usage` | Tipoobject |

Errori e passaggi successivi

| Risposta | Condizione | Passaggio successivo |
| --- | --- | --- |
| Risposta400 · `invalid_request_error` | CondizioneCampi obbligatori, rappresentazione del materiale o valore del parametro non validi | Passaggio successivoCorreggi i campi indicati prima di una nuova richiesta di creazione. |

### Alias

#### Alias del modello

**Ailoot Ultra** [`Qwen/Qwen2.5-Coder-32B-Instruct`](https://ailoot.ai/models/it/#m=Qwen%2FQwen2.5-Coder-32B-Instruct&route=Ultra&caller=Qwen%2FQwen2.5-Coder-32B-Instruct&fmt=chat)

#### Alias dei percorsi dei metodi

Usa i percorsi dei metodi indicati sopra.

#### ID di chiamata correlati

[`Qwen/Qwen2.5-Coder-32B-Instruct`](https://ailoot.ai/models/it/#m=Qwen%2FQwen2.5-Coder-32B-Instruct&route=Ultra&caller=Qwen%2FQwen2.5-Coder-32B-Instruct&fmt=chat)

**Ailoot Ultra · Anthropic Messages** `POST /v1/messages` `Qwen/Qwen2.5-Coder-32B-Instruct`

[`Qwen/Qwen2.5-Coder-32B-Instruct`](https://ailoot.ai/models/it/#m=Qwen%2FQwen2.5-Coder-32B-Instruct&route=Ultra&caller=Qwen%2FQwen2.5-Coder-32B-Instruct&fmt=messages)

Alibaba /`Qwen/Qwen2.5-Coder-32B-Instruct`

### Introduzione

Qwen2.5-Coder-32B-Instruct è un modello di programmazione ottimizzato per seguire istruzioni, destinato a generare, spiegare e correggere codice. Fornisci file pertinenti, comportamento previsto ed evidenze dei test per ottenere un’implementazione o una correzione mirata, con il comportamento dei contesti lunghi determinato dalla configurazione del servizio.

Input accettati

Testo

Risultati

json · sse

### Disponibile in Ailoot · input e metodi

**Ailoot Ultra · Anthropic Messages** `POST /v1/messages`

Tipi di input

`text`

Tipi di output

`json`, `sse`

Formato di output

JSON o SSE

| Campo | Tipo | Requisito | Valori e limiti | Predefinito |
| --- | --- | --- | --- | --- |
| Campo`model` | Tipo`string` | RequisitoObbligatorio | Valori e limiti Qwen/Qwen2.5-Coder-32B-Instruct | Predefinito— |
| Campo`messages` | Tipo`message[]` | RequisitoObbligatorio | Valori e limiti | Predefinito— |
| Campo`messages[].role` | Tipo`string` | RequisitoObbligatorio | Valori e limiti user, assistant | Predefinito— |
| Campo`messages[].content` | Tipo`string` | RequisitoObbligatorio | Valori e limiti | Predefinito— |
| Campo`max_tokens` | Tipo`integer` | RequisitoObbligatorio | Valori e limiti | Predefinito— |
| Campo`stream` | Tipo`boolean` | RequisitoFacoltativo | Valori e limiti | Predefinitofalse |

Combinazioni di materiali in input

**Testo** · Testo UTF-8

`Stringa messages[].content`

Parametri e ciclo di vita del metodo

| Parametro | Contratto |
| --- | --- |
| Parametro`content_type` | Contrattoapplication/json |
| Parametro`required` | Contrattomodel, messages, max\_tokens |
| Parametro`optional_controls` | Contrattostream |
| Parametro`material_types` | Contrattotext |
| Parametro`text_file_material` | ContrattoLeggi il documento UTF-8 effettivo e inserisci il testo nell’ingresso indicato o nella stringa del contenuto del messaggio. |

Ciclo di vita: `synchronous_or_streamed`

### 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

| Configurazione | Listino delle tariffe | Costo |
| --- | --- | --- |
| ConfigurazioneTariffe di base dei token | Listino delle tariffeTariffa base | Costo Input · Token in input **$0.00036** / 1K token Output · Token in output **$0.00036** / 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 →](https://ailoot.ai/docs/it/billing/reserve/)

### Esempi di richieste

#### Ailoot Ultra · Anthropic Messages

Corpo JSON minimo completocurl · usa il tuo documento UTF-8Python · salva il risultato completo

```json
{
  "model": "Qwen/Qwen2.5-Coder-32B-Instruct",
  "max_tokens": 128,
  "messages": [
    {
      "role": "user",
      "content": "Summarize the incident report."
    }
  ],
  "stream": false
}
```

```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_TEXT_FILE:?Set your actual UTF-8 document}"
export AILOOT_TEXT_FILE
python3 - <<'PY_REQUEST'
import json, os
from pathlib import Path

source_file = Path(os.environ['AILOOT_TEXT_FILE'])
if not source_file.is_file():
    raise SystemExit('Set AILOOT_TEXT_FILE to your actual UTF-8 document')
text = source_file.read_text(encoding='utf-8')
if not text.strip():
    raise SystemExit('Choose a document containing text')
payload = {'model': 'Qwen/Qwen2.5-Coder-32B-Instruct', 'max_tokens': 128, 'messages': [{'role': 'user', 'content': 'Summarize the incident report.'}]}
payload['messages'][0]['content'] = 'Summarize this material and quote supporting source passages.\n\n' + text
Path('request.json').write_text(json.dumps(payload, ensure_ascii=False), encoding='utf-8')
PY_REQUEST
curl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/messages \
  -H "x-api-key: $AILOOT_API_KEY" -H 'anthropic-version: 2023-06-01' -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

result = json.loads(Path('result.json').read_text(encoding='utf-8'))
print(json.dumps(result, ensure_ascii=False, indent=2))
PY_RESULT
```

```python
import json, os
from pathlib import Path

source_file = Path(os.environ['AILOOT_TEXT_FILE'])
if not source_file.is_file():
    raise SystemExit('Set AILOOT_TEXT_FILE to your actual UTF-8 document')
text = source_file.read_text(encoding='utf-8')
if not text.strip():
    raise SystemExit('Choose a document containing text')
payload = {'model': 'Qwen/Qwen2.5-Coder-32B-Instruct', 'max_tokens': 128, 'messages': [{'role': 'user', 'content': 'Summarize the incident report.'}]}
payload['messages'][0]['content'] = 'Summarize this material and quote supporting source passages.\n\n' + text
from urllib.request import Request, urlopen
from urllib.error import HTTPError

api_key = os.environ['AILOOT_API_KEY']
if not api_key.strip():
    raise SystemExit('Set AILOOT_API_KEY before making a request')
headers = {'x-api-key': 'PLACEHOLDER_KEY', 'anthropic-version': '2023-06-01', 'Content-Type': 'application/json'}
headers['x-api-key'] = api_key
request = Request('https://api.ailoot.ai/v1/messages', data=json.dumps(payload, ensure_ascii=False).encode('utf-8'), headers=headers, method='POST')
try:
    with urlopen(request, timeout=120) as response:
        raw = response.read()
        Path('response-headers.txt').write_text(str(response.headers), encoding='utf-8')
except HTTPError as error:
    Path('result.json').write_bytes(error.read())
    Path('response-headers.txt').write_text(str(error.headers), encoding='utf-8')
    raise
Path('result.json').write_bytes(raw)
import json
from pathlib import Path

result = json.loads(Path('result.json').read_text(encoding='utf-8'))
print(json.dumps(result, ensure_ascii=False, indent=2))
```

### Ricevi e salva i risultati

#### Ailoot Ultra · Anthropic Messages

JSON o SSE

##### Conserva tutti i risultati completati

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

Conserva tutti i blocchi di contenuto, le firme di ragionamento e gli ID effettivi di utilizzo degli strumenti. Assembla tutti i delta dei blocchi SSE; il primo blocco di testo non è l’uscita completa.

##### 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

| Campo | Tipo |
| --- | --- |
| Campo`id` | Tipostring |
| Campo`model` | Tipostring |
| Campo`content[]` | Tipotext\|thinking\|tool\_use\|other content block |
| Campo`stop_reason` | Tipostring\|null |
| Campo`usage` | Tipoobject |

Errori e passaggi successivi

| Risposta | Condizione | Passaggio successivo |
| --- | --- | --- |
| Risposta400 · `invalid_request_error` | CondizioneCampi obbligatori, rappresentazione del materiale o valore del parametro non validi | Passaggio successivoCorreggi i campi indicati prima di una nuova richiesta di creazione. |

### Alias

#### Alias del modello

**Ailoot Ultra** [`Qwen/Qwen2.5-Coder-32B-Instruct`](https://ailoot.ai/models/it/#m=Qwen%2FQwen2.5-Coder-32B-Instruct&route=Ultra&caller=Qwen%2FQwen2.5-Coder-32B-Instruct&fmt=messages)

#### Alias dei percorsi dei metodi

Usa i percorsi dei metodi indicati sopra.

#### ID di chiamata correlati

[`Qwen/Qwen2.5-Coder-32B-Instruct`](https://ailoot.ai/models/it/#m=Qwen%2FQwen2.5-Coder-32B-Instruct&route=Ultra&caller=Qwen%2FQwen2.5-Coder-32B-Instruct&fmt=messages)

FAQ · Qwen/Qwen2.5-Coder-32B-Instruct

Quali input e risultati sono disponibili?

`POST /v1/chat/completions` · `Qwen/Qwen2.5-Coder-32B-Instruct`: `text` → `text` `POST /v1/messages` · `Qwen/Qwen2.5-Coder-32B-Instruct`: `text` → `json`, `sse`

Quali campi usa la richiesta?

`POST /v1/chat/completions` · `Qwen/Qwen2.5-Coder-32B-Instruct`: `model`, `messages`, `stream`, `modalities`, `provider` `POST /v1/messages` · `Qwen/Qwen2.5-Coder-32B-Instruct`: `model`, `messages`, `max_tokens`, `stream`

Quali limiti si applicano?

`POST /v1/chat/completions` · `Qwen/Qwen2.5-Coder-32B-Instruct`: `messages.min_items`: `1`

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](https://ailoot.ai/docs/it/billing/subscriptions/) · [Consulta prezzi dei modelli](https://ailoot.ai/models/it/)

## 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](mailto:support@ailoot.ai) · [Offerta e accordo di licenza](https://ailoot.ai/legal/offer?lang=it)

## Ailoot · L’azienda e il suo portafoglio di progetti





Ailoot si basa su un’esperienza operativa consolidata, un’ampia base di clienti, un servizio stabile e un controllo costante dei KPI.





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





Ailoot mette questa esperienza operativa al servizio dell’accesso API alle funzioni AI nei prodotti dei clienti, negli agenti, nelle applicazioni e nelle automazioni.