Source: https://ailoot.ai/models/ms/qwen-qwen3-next-80b-a3b-instruct/
Canonical: https://ailoot.ai/models/ms/qwen-qwen3-next-80b-a3b-instruct/
Language: ms

# Qwen: Qwen3 Next 80B A3B Instruct

[Markdown](https://ailoot.ai/models/ms/qwen-qwen3-next-80b-a3b-instruct/index.md) · [JSON](https://ailoot.ai/models/ms/qwen-qwen3-next-80b-a3b-instruct/facts.json)

## [Qwen: Qwen3 Next 80B A3B Instruct](https://ailoot.ai/models/ms/qwen-qwen3-next-80b-a3b-instruct/)

Qwen3-Next-80B-A3B-Instruct ialah edisi teks tanpa pemikiran Qwen dengan 80 bilion parameter keseluruhan dan 3 bilion parameter yang diaktifkan. Ia menggabungkan perhatian hibrid, pakar jarang dan panggilan alat dengan konteks natif 262,144 token, yang boleh diluaskan kepada 1,010,000 melalui konfigurasi.

- [**Ailoot Ultra · OpenAI Chat** `POST /v1/chat/completions` `qwen/qwen3-next-80b-a3b-instruct`](https://ailoot.ai/models/ms/qwen-qwen3-next-80b-a3b-instruct/#method-0)
- [**Ailoot Ultra · Anthropic Messages** `POST /v1/messages` `qwen/qwen3-next-80b-a3b-instruct`](https://ailoot.ai/models/ms/qwen-qwen3-next-80b-a3b-instruct/#method-1)

Tentang model

Huraian ini merangkumi keupayaan model. Input, output dan pilihan yang tersedia di Ailoot disenaraikan di bawah untuk kaedah yang dipilih.

Sorotan Qwen3-Next: arahan teks langsung

Qwen3-Next-80B-A3B-Instruct ialah edisi teks berarahan tanpa pemikiran Qwen3-Next. Ia menerima teks dan mengembalikan teks, termasuk penerangan, cadangan kod dan artifak dokumen yang diminta. Ia tidak menjana blok pemikiran eksplisit. Bezakan ia daripada edisi Thinking dan Qwen3-Coder-Next yang khusus untuk pengekodan; berkongsi seni bina keluarga tidak menjadikan kontrak responsnya saling boleh ganti.

Keluarga ini memperkenalkan perhatian hibrid yang menggabungkan Gated DeltaNet dan perhatian berpagar, pakar dengan tahap sparsity yang tinggi, pengoptimuman kestabilan termasuk penormalan lapisan berpusat sifar dan dengan susutan pemberat, serta ramalan berbilang token. Perubahan itu menangani representasi dan latihan jujukan panjang. Kecekapan inferensnya bergantung pada pelaksanaan, jadi angka seni bina tidak seharusnya menjadi jaminan kependaman atau daya pemprosesan tetap.

Gambaran keseluruhan model

Checkpoint ini mempunyai 80 bilion parameter keseluruhan dan mengaktifkan tiga bilion. Ia mempunyai 48 lapisan dalam pola pakar berulang tiga DeltaNet kepada satu perhatian berpagar. Pembuat menyenaraikan 512 pakar, sepuluh pakar yang diaktifkan dan satu pakar dikongsi, dengan pralatihan pada 15 trilion token diikuti pascalatihan. Parameter yang diaktifkan bukan saiz checkpoint lengkap.

Konteks natifnya ialah 262,144 token, dengan peluasan yang didokumentasikan kepada 1,010,000. Contoh penggunaan pembuat membenarkan konteks lebih kecil, seperti 32,768, apabila kekangan sumber menghalang tetapan lebih besar daripada berfungsi. Teks, sejarah perbualan, pemerhatian alat dan kandungan terjana berkongsi had jujukan yang dikonfigurasikan. Peluasan ialah laluan konfigurasi tambahan dan bukannya input tanpa had secara lalai.

Menggunakan antara muka berarahan

Model ini hanya menyokong mod berarahan tanpa pemikiran. Ia boleh menerangkan algoritma, menunjukkan pengiraan atau memberikan justifikasi bagi kesimpulan dalam teks biasa tanpa menghasilkan blok pemikiran khusus. Minta format dan batas artifak: fungsi lengkap, laporan ringkas, jadual bukti atau jawapan dengan langkah sokongan. Permintaan untuk penerangan panjang tidak menukarnya menjadi checkpoint Thinking yang dinamakan secara berasingan.

Bagi tugas dokumen, kekalkan pengecam bahagian dan tentukan soalan yang mesti dijawab oleh laporan. Bagi kod, berikan fungsi atau modul yang relevan, kekangan input dan output yang dijangka. Bagi matematik, berikan pernyataan lengkap dan minta hasil akhir yang dipisahkan dengan jelas. Bandingkan pengiraan, kod atau penerangan yang dikembalikan dengan keadaan yang dibekalkan dan hasil sebenar.

Pelaksanaan dan alat

Pembuat mendokumentasikan panggilan alat dan mengesyorkan Qwen-Agent untuk templat dan penghuraian, dengan alat yang dikonfigurasikan atau disambungkan melalui MCP. Aliran kerja bersambung boleh menyediakan pengambilan, pemeriksaan atau pelaksanaan yang dibenarkan dan mengembalikan pemerhatian sebenar. Nyatakan alat, tindakan yang dibenarkan dan syarat selesai yang kelihatan, kemudian minta laporan akhir membezakan cadangan daripada hasil sebenar yang dikembalikan.

Ramalan berbilang token ialah sebahagian daripada latihan, tetapi penggunaannya dalam inferens bergantung pada pelaksanaan dan tidak tersedia secara umum dalam setiap aliran kerja ringan. Templat atau ciri seni bina tidak dengan sendirinya membuktikan akses kepada sumber semasa, fail atau persekitaran kod. Kekalkan model yang tepat dan format perbualan yang digunakan oleh antara muka pilihan.

Teks ultra panjang

Pembuat mengesahkan konteks kira-kira sejuta token dengan YaRN dan memberikan kaedah faktor empat berdasarkan 262,144 kedudukan natif. Bagi beban kerja 524,288 token, ia mencadangkan faktor dua. Penskalaan statik boleh menurunkan prestasi teks lebih pendek, jadi konfigurasi seharusnya mengikut keperluan sebenar untuk input lebih panjang.

Susun bahan panjang mengikut dokumen, laluan kod atau bahagian dan buang pengulangan yang tidak berkaitan. Minta jawapan mengenal pasti petikan atau syarat yang menyokongnya. Peruntukkan ruang untuk respons dan bukannya menganggap angka konteks terbesar sebagai ingatan lengkap bagi setiap butiran yang dibekalkan. Angka peluasan 1,010,000 yang diterbitkan dan pengesahan sekitar sejuta kekal dalam skop aliran kerja konteks panjang pembuat.

Panduan penjanaan

Best Practices mengesyorkan temperature 0.7, top\_p 0.8, top\_k 20 dan min\_p 0. Apabila disokong, penalti kehadiran antara sifar dan dua boleh mengurangkan teks berulang, tetapi nilai lebih tinggi mungkin mencampurkan bahasa atau sedikit mengurangkan kualiti. Pembuat mengesyorkan peruntukan output 16,384 token bagi kebanyakan pertanyaan. Ini ialah bajet penjanaan yang disyorkan dan bukannya maksimum keras bebas; ia tidak seharusnya mewarisi peruntukan lebih panjang edisi Thinking.

Nyatakan bentuk hasil secara jelas, seperti pembatas matematik atau medan jawapan. Pastikan artifak akhir mudah diperiksa dan sahkan pengiraan, petikan atau kodnya berdasarkan sumber. Edisi teks sahaja ini tidak menerima imej, audio atau video sebagai inputnya sendiri, jadi bahan tersebut memerlukan representasi berasingan yang sesuai sebelum boleh menyokong tugas.

Hasil praktikal

Output yang berguna ialah artifak teks konkrit yang berasaskan keadaan yang dibekalkan: penerangan dokumen, cadangan kod atau jawapan langsung dengan butiran sokongan yang diperlukan. Konteks panjang dan panggilan alat boleh membantu membawa lebih banyak bukti sepanjang aliran kerja, manakala kontrak tanpa pemikiran menjelaskan gaya output edisi yang tepat ini. Semak hasil dalam persekitaran tugas sebenar dan bukan menyimpulkan ketepatan daripada panjangnya atau ungkapan yang yakin.

Tugas praktikal

### Tugas praktikal

Contoh teknikal dalam bahasa Inggeris

```
Explain a section-specific decision

Answer only from these procedure sections. Section 2: standard purchases need a manager's approval. Section 4: emergency safety purchases may proceed first, but must be reported to that manager within one day. Case: a broken emergency exit light needs replacement today. Give a concise recommendation with section references and identify the follow-up obligation. Do not invent an approval already granted.
```

#### Hasil yang dijangka

```
A direct recommendation with supporting sections and the one-day reporting obligation.
```

#### Semak hasil

```
The emergency exception retains its reporting condition and is not generalised to all purchases.
```

**Ailoot Ultra · OpenAI Chat** `POST /v1/chat/completions` `qwen/qwen3-next-80b-a3b-instruct`

[`qwen/qwen3-next-80b-a3b-instruct`](https://ailoot.ai/models/ms/#m=qwen%2Fqwen3-next-80b-a3b-instruct&route=Ultra&caller=qwen%2Fqwen3-next-80b-a3b-instruct&fmt=chat)

Alibaba /`qwen/qwen3-next-80b-a3b-instruct`

### Pengenalan

Qwen3-Next-80B-A3B-Instruct ialah edisi teks tanpa pemikiran Qwen dengan 80 bilion parameter keseluruhan dan 3 bilion parameter yang diaktifkan. Ia menggabungkan perhatian hibrid, pakar jarang dan panggilan alat dengan konteks natif 262,144 token, yang boleh diluaskan kepada 1,010,000 melalui konfigurasi.

Input yang diterima

Teks

Hasil

Teks

### Tersedia di Ailoot · input & kaedah

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

Input

`text`

Output

`text`

Format output

json atau SSE

| Medan | Jenis | Keperluan | Nilai & had | Lalai |
| --- | --- | --- | --- | --- |
| Medan`model` | Jenis`string` | KeperluanDiperlukan | Nilai & had qwen/qwen3-next-80b-a3b-instruct | Lalai— |
| Medan`messages` | Jenis`message[]` | KeperluanDiperlukan | Nilai & had Item minimum: 1 | Lalai— |
| Medan`messages[].role` | Jenis`string` | KeperluanDiperlukan | Nilai & had Contoh: system, user, assistant, tool, function Syarat: Peranan ini diwakili secara eksplisit oleh jenis keserasian dalam kod sumber; set peranan model yang tepat kekal khusus untuk setiap model. Bergantung pada model | Lalai— |
| Medan`messages[].content` | Jenis`string\|content_part[]\|null` | KeperluanPilihan | Nilai & had | Lalai— |
| Medan`messages[].tool_calls` | Jenis`tool_call[]` | KeperluanPilihan | Nilai & had | Lalai— |
| Medan`messages[].tool_call_id` | Jenis`string` | KeperluanPilihan | Nilai & had Terpakai apabila: role=tool; gunakan ID sebenar yang dipulangkan | Lalai— |
| Medan`messages[].name` | Jenis`string` | KeperluanPilihan | Nilai & had | Lalai— |
| Medan`messages[].reasoning_content` | Jenis`string` | KeperluanPilihan | Nilai & had Terpakai apabila: Hantar semula penaakulan sebenar yang dipulangkan apabila model ini menggunakannya | Lalai— |
| Medan`messages[].reasoning_details` | Jenis`object\|array` | KeperluanPilihan | Nilai & had Bergantung pada model | Lalai— |
| Medan`max_tokens` | Jenis`integer` | KeperluanPilihan | Nilai & had Minimum: 1 Bergantung pada model | Lalai— |
| Medan`max_completion_tokens` | Jenis`integer` | KeperluanPilihan | Nilai & had Minimum: 1 Bergantung pada model | Lalai— |
| Medan`stream` | Jenis`boolean` | KeperluanPilihan | Nilai & had | Lalaifalse |
| Medan`stream_options.include_usage` | Jenis`boolean` | KeperluanPilihan | Nilai & had Bergantung pada model | Lalai— |
| Medan`temperature` | Jenis`number` | KeperluanPilihan | Nilai & had Bergantung pada model | Lalai— |
| Medan`top_p` | Jenis`number` | KeperluanPilihan | Nilai & had Bergantung pada model | Lalai— |
| Medan`stop` | Jenis`string\|string[]` | KeperluanPilihan | Nilai & had Bergantung pada model | Lalai— |
| Medan`tools` | Jenis`function_tool[]` | KeperluanPilihan | Nilai & had Bergantung pada model | Lalai— |
| Medan`tools[].type` | Jenis`string` | KeperluanPilihan | Nilai & had function Bergantung pada model | Lalai— |
| Medan`tools[].function.name` | Jenis`string` | KeperluanDiperlukan | Nilai & had Terpakai apabila: alat fungsi dibekalkan | Lalai— |
| Medan`tools[].function.description` | Jenis`string` | KeperluanPilihan | Nilai & had | Lalai— |
| Medan`tools[].function.parameters` | Jenis`JSON_schema` | KeperluanPilihan | Nilai & had | Lalai— |
| Medan`tool_choice` | Jenis`string\|object` | KeperluanPilihan | Nilai & had Bergantung pada model | Lalai— |
| Medan`parallel_tool_calls` | Jenis`boolean` | KeperluanPilihan | Nilai & had Bergantung pada model | Lalai— |
| Medan`response_format` | Jenis`object` | KeperluanPilihan | Nilai & had Bergantung pada model | Lalai— |
| Medan`reasoning_effort` | Jenis`string` | KeperluanPilihan | Nilai & had Bergantung pada model | Lalai— |
| Medan`reasoning` | Jenis`object` | KeperluanPilihan | Nilai & had Bergantung pada model | Lalai— |
| Medan`service_tier` | Jenis`string` | KeperluanPilihan | Nilai & had Bergantung pada model | Lalai— |
| Medan`instructions` | Jenis`string` | KeperluanPilihan | Nilai & had Medan keserasian | Lalai— |
| Medan`functions` | Jenis`function[]` | KeperluanPilihan | Nilai & had Bergantung pada model | Lalai— |
| Medan`function_call` | Jenis`string\|object` | KeperluanPilihan | Nilai & had Bergantung pada model | Lalai— |
| Medan`prompt_cache_options` | Jenis`object` | KeperluanPilihan | Nilai & had Bergantung pada model | Lalai— |
| Medan`modalities` | Jenis`string[]` | KeperluanPilihan | Nilai & had text | Lalai— |
| Medan`provider` | Jenis`object` | KeperluanPilihan | Nilai & had Syarat: provider.options ditolak pada laluan teks Ultra ini | Lalai— |
| Medan`cache_control.ttl` | Jenis`string` | KeperluanPilihan | Nilai & had Syarat: 1h ditolak pada lokasi cache prompt yang digunakan | Lalai— |

Gabungan bahan input

**Teks** · Teks UTF8

`messages[].content`

Parameter kaedah dan kitar hayat

| Parameter | Kontrak |
| --- | --- |
| Parameter`content_type` | Kontrakapplication/json |
| Parameter`required` | Kontrakmodel, messages |
| Parameter`material_types` | Kontraktext |
| Parameter`messages` | Kontraktatasusunan mesej dengan struktur role/content |
| Parameter`file_material` | Kontrakdokumen UTF-8 sebenar dimasukkan sebagai teks literal; ID fail tidak diandaikan |
| Parameter`optional_controls` | Kontrakstream, temperature, top\_p, stop, max\_tokens, max\_completion\_tokens, reasoning, response\_format, tools, tool\_choice |
| Parameter`control_scope` | Kontrakkhusus model; alat fungsi pengguna berbeza daripada alat yang dihoskan |
| Parameter`output_modalities` | Kontraktext |
| Parameter`hosted_operations` | Kontrakfalse |
| Parameter`multimodal_input_binding` | Kontraknull |

Kitar hayat: `synchronous_or_streamed`

Hantar ID model yang tepat bersama messages.

Panjang konteks bukan had output.

Fail teks boleh membekalkan teks literal; input imej/audio/objek fail memerlukan pengikatan tepat.

### Pelan harga

Rujukan tarif tidak menambah pilihan permintaan. Parameter yang disokong disenaraikan untuk kaedah yang dipilih.

Mod pantas

Kadar standard Apabila mod pantas dipilih

Mod flex

Kadar standard Apabila mod flex dipilih

Usaha penaakulan maksimum

Kadar standard Apabila usaha penaakulan maksimum menggunakan pelarasan default

#### Kadar Ailoot

#### Harga mengikut konfigurasi

Padankan setiap caj dengan syarat yang dipaparkan. Gunakan satu kadar bagi setiap set konfigurasi alternatif.

| Konfigurasi | Jadual kadar | Token konteks, melebihi | Token konteks, sehingga dan termasuk | Caj |
| --- | --- | --- | --- | --- |
| KonfigurasiKadar asas token | Jadual kadarKadar asas | Token konteks, melebihi— | Token konteks, sehingga dan termasukTiada had atas | Caj Input · Token input **$0.000286** / 1K token Output · Token output **$0.0022** / 1K token Input · Bacaan cache **$0.00014** / 1K token Input · Penulisan cache **$0** / 1K token Input · Penulisan cache, 1 jam **—** / 1K token |
| KonfigurasiTahap panjang permintaan 1 | Jadual kadar— | Token konteks, melebihi0 | Token konteks, sehingga dan termasukTiada had atas | Caj Input · Token input **$0.000286** / 1K token Output · Token output **$0.0022** / 1K token Input · Bacaan cache **$0.00014** / 1K token Input · Penulisan cache **$0** / 1K token Input · Penulisan cache, 1 jam **—** / 1K token |

Ailoot merizabkan anggaran amaun sebelum permintaan. Selepas hasil diterima, caj akhir diselesaikan berdasarkan penggunaan terukur. Penyelesaian caj penstriman menggunakan rekod penggunaan akhir. [Cara rizab dan penyelesaian caj berfungsi →](https://ailoot.ai/docs/ms/billing/reserve/)

### Contoh permintaan

#### Ailoot Ultra · OpenAI Chat

curlPython SDKPenstriman 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/qwen3-next-80b-a3b-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/qwen3-next-80b-a3b-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/qwen3-next-80b-a3b-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")
```

### Terima dan simpan hasil

#### Ailoot Ultra · OpenAI Chat

json atau SSE

##### Simpan semua hasil yang selesai

Simpan setiap respons lengkap, fail dan bahagian kandungan yang dikembalikan.

Kekalkan setiap pilihan jawapan bersama kandungan, panggilan alat dan penaakulannya. Dalam SSE, gabungkan delta mengikut indeks pilihan jawapan/alat dan kekalkan sebab penamatan akhir serta data penggunaan.

##### Jika respons asal perlu disemak

Kekalkan ID permintaan/respons dan pengepala. Tiada URL umum bagi pengambilan tugas teks dibekalkan.

Medan respons

| Medan | Jenis |
| --- | --- |
| Medan`choices[].index` | Jenisinteger |
| Medan`choices[].message.content` | Jenisstring\|null |
| Medan`choices[].message.tool_calls` | Jenistool\_call\[\] |
| Medan`choices[].message.reasoning_content` | Jenisstring |
| Medan`choices[].message.reasoning_details` | Jenisobject\|array |
| Medan`choices[].finish_reason` | Jenisstring\|null |
| Medan`usage` | Jenisobject |

Ralat dan langkah seterusnya

| Respons | Syarat | Langkah seterusnya |
| --- | --- | --- |
| Respons400 · `invalid_request_error` | SyaratMedan wajib, perwakilan bahan atau nilai parameter tidak sah | Langkah seterusnyaBetulkan medan yang ditunjukkan sebelum permintaan penciptaan baharu. |

### Alias

#### Alias model

**Ailoot Ultra** [`qwen/qwen3-next-80b-a3b-instruct`](https://ailoot.ai/models/ms/#m=qwen%2Fqwen3-next-80b-a3b-instruct&route=Ultra&caller=qwen%2Fqwen3-next-80b-a3b-instruct&fmt=chat)

#### Alias laluan kaedah

Gunakan laluan kaedah yang dipaparkan di atas.

#### ID pemanggil berkaitan

[`qwen/qwen3-next-80b-a3b-instruct`](https://ailoot.ai/models/ms/#m=qwen%2Fqwen3-next-80b-a3b-instruct&route=Ultra&caller=qwen%2Fqwen3-next-80b-a3b-instruct&fmt=chat)

**Ailoot Ultra · Anthropic Messages** `POST /v1/messages` `qwen/qwen3-next-80b-a3b-instruct`

[`qwen/qwen3-next-80b-a3b-instruct`](https://ailoot.ai/models/ms/#m=qwen%2Fqwen3-next-80b-a3b-instruct&route=Ultra&caller=qwen%2Fqwen3-next-80b-a3b-instruct&fmt=messages)

Alibaba /`qwen/qwen3-next-80b-a3b-instruct`

### Pengenalan

Qwen3-Next-80B-A3B-Instruct ialah edisi teks tanpa pemikiran Qwen dengan 80 bilion parameter keseluruhan dan 3 bilion parameter yang diaktifkan. Ia menggabungkan perhatian hibrid, pakar jarang dan panggilan alat dengan konteks natif 262,144 token, yang boleh diluaskan kepada 1,010,000 melalui konfigurasi.

Input yang diterima

Teks

Hasil

json · sse

### Tersedia di Ailoot · input & kaedah

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

Input

`text`

Output

`json`, `sse`

Format output

JSON atau SSE

| Medan | Jenis | Keperluan | Nilai & had | Lalai |
| --- | --- | --- | --- | --- |
| Medan`model` | Jenis`string` | KeperluanDiperlukan | Nilai & had qwen/qwen3-next-80b-a3b-instruct | Lalai— |
| Medan`messages` | Jenis`message[]` | KeperluanDiperlukan | Nilai & had | Lalai— |
| Medan`messages[].role` | Jenis`string` | KeperluanDiperlukan | Nilai & had user, assistant | Lalai— |
| Medan`messages[].content` | Jenis`string` | KeperluanDiperlukan | Nilai & had | Lalai— |
| Medan`max_tokens` | Jenis`integer` | KeperluanDiperlukan | Nilai & had | Lalai— |
| Medan`stream` | Jenis`boolean` | KeperluanPilihan | Nilai & had | Lalaifalse |

Gabungan bahan input

**Teks** · Teks UTF-8

`rentetan messages[].content`

Parameter kaedah dan kitar hayat

| Parameter | Kontrak |
| --- | --- |
| Parameter`content_type` | Kontrakapplication/json |
| Parameter`required` | Kontrakmodel, messages, max\_tokens |
| Parameter`optional_controls` | Kontrakstream |
| Parameter`material_types` | Kontraktext |
| Parameter`text_file_material` | KontrakBaca dokumen UTF-8 sebenar dan letakkan teksnya dalam rentetan input atau kandungan mesej yang ditunjukkan. |

Kitar hayat: `synchronous_or_streamed`

### Pelan harga

Rujukan tarif tidak menambah pilihan permintaan. Parameter yang disokong disenaraikan untuk kaedah yang dipilih.

Mod pantas

Kadar standard Apabila mod pantas dipilih

Mod flex

Kadar standard Apabila mod flex dipilih

Usaha penaakulan maksimum

Kadar standard Apabila usaha penaakulan maksimum menggunakan pelarasan default

#### Kadar Ailoot

#### Harga mengikut konfigurasi

Padankan setiap caj dengan syarat yang dipaparkan. Gunakan satu kadar bagi setiap set konfigurasi alternatif.

| Konfigurasi | Jadual kadar | Token konteks, melebihi | Token konteks, sehingga dan termasuk | Caj |
| --- | --- | --- | --- | --- |
| KonfigurasiKadar asas token | Jadual kadarKadar asas | Token konteks, melebihi— | Token konteks, sehingga dan termasukTiada had atas | Caj Input · Token input **$0.000286** / 1K token Output · Token output **$0.0022** / 1K token Input · Bacaan cache **$0.00014** / 1K token Input · Penulisan cache **$0** / 1K token Input · Penulisan cache, 1 jam **—** / 1K token |
| KonfigurasiTahap panjang permintaan 1 | Jadual kadar— | Token konteks, melebihi0 | Token konteks, sehingga dan termasukTiada had atas | Caj Input · Token input **$0.000286** / 1K token Output · Token output **$0.0022** / 1K token Input · Bacaan cache **$0.00014** / 1K token Input · Penulisan cache **$0** / 1K token Input · Penulisan cache, 1 jam **—** / 1K token |

Ailoot merizabkan anggaran amaun sebelum permintaan. Selepas hasil diterima, caj akhir diselesaikan berdasarkan penggunaan terukur. Penyelesaian caj penstriman menggunakan rekod penggunaan akhir. [Cara rizab dan penyelesaian caj berfungsi →](https://ailoot.ai/docs/ms/billing/reserve/)

### Contoh permintaan

#### Ailoot Ultra · Anthropic Messages

Badan JSON minimum yang lengkapcurl · gunakan dokumen UTF-8 andaPython · simpan hasil lengkap

```json
{
  "model": "qwen/qwen3-next-80b-a3b-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/qwen3-next-80b-a3b-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/qwen3-next-80b-a3b-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))
```

### Terima dan simpan hasil

#### Ailoot Ultra · Anthropic Messages

JSON atau SSE

##### Simpan semua hasil yang selesai

Simpan setiap respons lengkap, fail dan bahagian kandungan yang dikembalikan.

Kekalkan semua blok kandungan, tandatangan penaakulan dan ID penggunaan alat sebenar. Gabungkan semua delta blok SSE; blok teks pertama bukan keseluruhan output.

##### Jika respons asal perlu disemak

Kekalkan ID permintaan/respons dan pengepala. Tiada URL umum bagi pengambilan tugas teks dibekalkan.

Medan respons

| Medan | Jenis |
| --- | --- |
| Medan`id` | Jenisstring |
| Medan`model` | Jenisstring |
| Medan`content[]` | Jenistext\|thinking\|tool\_use\|other content block |
| Medan`stop_reason` | Jenisstring\|null |
| Medan`usage` | Jenisobject |

Ralat dan langkah seterusnya

| Respons | Syarat | Langkah seterusnya |
| --- | --- | --- |
| Respons400 · `invalid_request_error` | SyaratMedan wajib, perwakilan bahan atau nilai parameter tidak sah | Langkah seterusnyaBetulkan medan yang ditunjukkan sebelum permintaan penciptaan baharu. |

### Alias

#### Alias model

**Ailoot Ultra** [`qwen/qwen3-next-80b-a3b-instruct`](https://ailoot.ai/models/ms/#m=qwen%2Fqwen3-next-80b-a3b-instruct&route=Ultra&caller=qwen%2Fqwen3-next-80b-a3b-instruct&fmt=messages)

#### Alias laluan kaedah

Gunakan laluan kaedah yang dipaparkan di atas.

#### ID pemanggil berkaitan

[`qwen/qwen3-next-80b-a3b-instruct`](https://ailoot.ai/models/ms/#m=qwen%2Fqwen3-next-80b-a3b-instruct&route=Ultra&caller=qwen%2Fqwen3-next-80b-a3b-instruct&fmt=messages)

FAQ · Qwen: Qwen3 Next 80B A3B Instruct

Apakah input dan hasil yang tersedia?

`POST /v1/chat/completions` · `qwen/qwen3-next-80b-a3b-instruct`: `text` → `text` `POST /v1/messages` · `qwen/qwen3-next-80b-a3b-instruct`: `text` → `json`, `sse`

Apakah medan yang digunakan oleh permintaan?

`POST /v1/chat/completions` · `qwen/qwen3-next-80b-a3b-instruct`: `model`, `messages`, `stream`, `modalities`, `provider` `POST /v1/messages` · `qwen/qwen3-next-80b-a3b-instruct`: `model`, `messages`, `max_tokens`, `stream`

Apakah had yang terpakai?

`POST /v1/chat/completions` · `qwen/qwen3-next-80b-a3b-instruct`: `messages.min_items`: `1`

Sambungkan Ailoot kepada Claude Code, OpenCode, Hermes atau aplikasi anda.

## Syarikat dan portfolio projeknya

Syarikat dan portfolio projeknya: jutaan pelanggan; jualan bernilai berbilion setiap bulan.

## Beli token dengan diskaun.

Diskaun langganan untuk penggunaan berkala. Kod promosi — sehingga 50% bagi pembelian token.

Langganan

Pilih pelan berdiskaun untuk permintaan berkala anda.

Kod promosi sehingga 50%

Masukkan kod semasa pembelian. Harga dikira semula mengikut promosi semasa.

Perbelanjaan dalam sejarah

Model, token dan jumlah disimpan bagi setiap permintaan.

[Pilih langganan](https://ailoot.ai/docs/ms/billing/subscriptions/) · [Lihat harga model](https://ailoot.ai/models/ms/)

## Sambungkan API kepada produk yang anda jual.

SaaS, aplikasi dan bot — di bawah tawaran rasmi serta perjanjian lesen Ailoot. Untuk jualan semula, mohon lesen penjual semula.

Aplikasi komersial

Tambahkan penjanaan teks, imej, video dan audio pada ciri berbayar perkhidmatan anda.

Lesen penjual semula

Hantar keterangan projek dan susunan akses. Minta terma penggunaan serta jualan semula secara bertulis.

Dokumen pada laman

Tawaran, perjanjian lesen dan dasar pemprosesan data tersedia sebelum sambungan.

[Mohon lesen penjual semula](mailto:support@ailoot.ai) · [Tawaran dan perjanjian lesen](https://ailoot.ai/legal/offer?lang=ms)

## Ailoot · Syarikat dan portfolio projeknya





Ailoot berteraskan pengalaman operasi yang mantap, pangkalan pelanggan yang besar, perkhidmatan yang stabil dan pemantauan KPI berterusan.





Syarikat dan portfolio projeknya: jutaan pelanggan; jualan bernilai berbilion setiap bulan.





Ailoot menggunakan pengalaman operasi ini untuk akses API kepada ciri AI dalam produk pelanggan, ejen, aplikasi dan automasi.