Source: https://ailoot.ai/models/cs/minimax-m3/
Canonical: https://ailoot.ai/models/cs/minimax-m3/
Language: cs
# MiniMax: MiniMax M3
[Markdown](https://ailoot.ai/models/cs/minimax-m3/index.md) · [JSON](https://ailoot.ai/models/cs/minimax-m3/facts.json)
## [MiniMax: MiniMax M3](https://ailoot.ai/models/cs/minimax-m3/)
MiniMax M3 je multimodální model pro dlouhodobou práci na kódu a agentní úlohy, který využívá MiniMax Sparse Attention a návrh pro dlouhý kontext. Uvedená chatová rozhraní Ultra přijímají text a vracejí textové odpovědi.
- [**Ailoot · Anthropic Messages** `POST /v1/messages` `MiniMax-M3`](https://ailoot.ai/models/cs/minimax-m3/#method-0)
- [**Ailoot · OpenAI Responses** `POST /v1/responses` `MiniMax-M3`](https://ailoot.ai/models/cs/minimax-m3/#method-1)
- [**Ailoot · OpenAI Chat** `POST /v1/chat/completions` `MiniMax-M3`](https://ailoot.ai/models/cs/minimax-m3/#method-2)
- [**Ailoot Ultra · OpenAI Chat** `POST /v1/chat/completions` `MiniMax-M3`](https://ailoot.ai/models/cs/minimax-m3/#method-3)
- [**Ailoot Ultra · Anthropic Messages** `POST /v1/messages` `MiniMax-M3`](https://ailoot.ai/models/cs/minimax-m3/#method-4)
- [**Ailoot · Anthropic Messages** `POST /v1/messages` `minimax`](https://ailoot.ai/models/cs/minimax-m3/#method-5)
- [**Ailoot · OpenAI Responses** `POST /v1/responses` `minimax`](https://ailoot.ai/models/cs/minimax-m3/#method-6)
- [**Ailoot · OpenAI Chat** `POST /v1/chat/completions` `minimax`](https://ailoot.ai/models/cs/minimax-m3/#method-7)
- [**Ailoot · Anthropic Messages** `POST /v1/messages` `minimax-latest`](https://ailoot.ai/models/cs/minimax-m3/#method-8)
- [**Ailoot · OpenAI Responses** `POST /v1/responses` `minimax-latest`](https://ailoot.ai/models/cs/minimax-m3/#method-9)
- [**Ailoot · OpenAI Chat** `POST /v1/chat/completions` `minimax-latest`](https://ailoot.ai/models/cs/minimax-m3/#method-10)
- [**Ailoot · Anthropic Messages** `POST /v1/messages` `minimax-text`](https://ailoot.ai/models/cs/minimax-m3/#method-11)
- [**Ailoot · OpenAI Responses** `POST /v1/responses` `minimax-text`](https://ailoot.ai/models/cs/minimax-m3/#method-12)
- [**Ailoot · OpenAI Chat** `POST /v1/chat/completions` `minimax-text`](https://ailoot.ai/models/cs/minimax-m3/#method-13)
- [**Ailoot · Anthropic Messages** `POST /v1/messages` `minimax-text-latest`](https://ailoot.ai/models/cs/minimax-m3/#method-14)
- [**Ailoot · OpenAI Responses** `POST /v1/responses` `minimax-text-latest`](https://ailoot.ai/models/cs/minimax-m3/#method-15)
- [**Ailoot · OpenAI Chat** `POST /v1/chat/completions` `minimax-text-latest`](https://ailoot.ai/models/cs/minimax-m3/#method-16)
- [**Ailoot · Anthropic Messages** `POST /v1/messages` `minimax/minimax-m3`](https://ailoot.ai/models/cs/minimax-m3/#method-17)
- [**Ailoot · OpenAI Responses** `POST /v1/responses` `minimax/minimax-m3`](https://ailoot.ai/models/cs/minimax-m3/#method-18)
- [**Ailoot · OpenAI Chat** `POST /v1/chat/completions` `minimax/minimax-m3`](https://ailoot.ai/models/cs/minimax-m3/#method-19)
- [**Ailoot Ultra · OpenAI Chat** `POST /v1/chat/completions` `minimax/minimax-m3`](https://ailoot.ai/models/cs/minimax-m3/#method-20)
- [**Ailoot Ultra · Anthropic Messages** `POST /v1/messages` `minimax/minimax-m3`](https://ailoot.ai/models/cs/minimax-m3/#method-21)
O modelu
Tento popis zahrnuje schopnosti modelu. Vstupy, výstupy a možnosti dostupné v Ailoot jsou uvedeny níže pro vybranou metodu.
MiniMax M3 je multimodální základní model společnosti MiniMax pro dlouhodobé úlohy o více krocích. Jeho zveřejněný profil popisuje textové, obrazové a video vstupy s textovým výstupem; uvedená chatová rozhraní Ultra přijímají text a vracejí textové odpovědi. Model je postaven na MiniMax Sparse Attention, která vybírá bloky klíčů a hodnot místo použití plné pozornosti v celém dlouhém kontextu. Jeho zveřejněné zaměření zahrnuje programování, používání nástrojů a spolupráci v několika kolech konverzace.
#### Vložte podklady k úloze do konverzace
Písemný cíl spojte s písemnými pozorováními, která vymezují problém. Při práci na rozhraní popište a označte zkoumanou obrazovku i stav. U otázky k videu dodejte přepis nebo písemné poznámky, které určují příslušnou scénu či časový úsek a viditelný sled událostí k analýze. Žádejte konkrétní textový výsledek, například popis, porovnání nebo návrh implementace, a zachovejte označení zdrojů potřebná k jeho ověření.
Multimodální trénování modelu používá prokládaný materiál a trénování spolupráce je zaměřeno na delší interakce. Užitečné pracovní zadání udržuje písemné instrukce blízko zdroje, který popisují. Oddělte důkazy od předpokladů, aby pozdější kolo mohlo navázat na skutečná pozorování.
#### Programování a práce s pomocí nástrojů
U programátorské úlohy dodejte příslušný zdroj, požadované chování a podmínky dokládající dokončení. Uchovejte skutečný výstup příkazů nebo testů v konverzaci, pokud na něm další krok závisí. Aplikace s nástroji může provést navrženou operaci a vrátit její výsledek modelu.
Zveřejněný profil modelu dokumentuje volání funkcí a strukturované výstupy podle JSON Schema; uvedená specifikace Ultra Chat považuje tools a response\_format za závislé na modelu. Operace nebo pole výsledku definujte podle úlohy a následně ověřte vrácená data vůči jejich zdrojům. Než spojíte závěry z několika kroků, zachovejte vazbu každého pozorování na příslušnou akci nástroje.
#### Dlouhý kontext a jasný konečný stav
Zveřejněný profil modelu popisuje kontext přibližně jednoho milionu tokenů. Každý požadavek plánujte podle skutečné kapacity rozhraní, které jej obsluhuje, a vyhraďte místo pro odpověď. Dokončená rozhodnutí, nejnovější pozorování a otevřené otázky uchovávejte v pojmenovaných oddílech místo opakovaného připojování všech podkladů.
Užitečný výsledek M3 ponechává výtvor a jeho důkazy pohromadě: cílenou změnu s validací, analýzu navázanou na vizuální zdroj nebo další akci, jejíž výsledek vyřeší zbývající otázku. Rozšířený postup tak může pokračovat ze stavu, který lze prohlédnout.
Praktická úloha
### Praktická úloha
Technický příklad v angličtině
```
Analyze a written video sequence
Analyze these written scene notes, using no video access. [00:03] Operator places a tray on a scale. [00:07] Display reads 2.4 kg. [00:10] A second tray is placed beside it, not on the scale. Summarize the sequence and state which tray has a recorded weight and what remains unknown.
```
#### Očekávaný výsledek
```
A source-labelled sequence summary and a clear known/unknown distinction for tray weights.
```
#### Ověření výsledku
```
Ensure the 2.4 kg reading is not assigned to the unweighed second tray.
```
**Ailoot · Anthropic Messages** `POST /v1/messages` `MiniMax-M3`
[`MiniMax-M3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=MiniMax-M3&fmt=messages)
MiniMax /`MiniMax-M3`
ID modelu
- `MiniMax-M3`
- `minimax`
- `minimax-latest`
- `minimax-text`
- `minimax-text-latest`
- `minimax/minimax-m3`
### Úvod
MiniMax M3 je multimodální model pro dlouhodobou práci na kódu a agentní úlohy, který využívá MiniMax Sparse Attention a návrh pro dlouhý kontext. Uvedená chatová rozhraní Ultra přijímají text a vracejí textové odpovědi.
Přijímané vstupy
Text · Obrázky
Výsledky
Text
### Dostupné v Ailoot · vstupy a metody
**Ailoot · Anthropic Messages** `POST /v1/messages`
Vstup
`text`, `image`
Výstup
`text`
Kontext
1 000 000 tokens
Maximální výstup
524 288 tokens
Výstupní formát
json nebo SSE
| Pole | Typ | Požadavek | Hodnoty a limity | Výchozí |
| --- | --- | --- | --- | --- |
| Pole`model` | Typ`string` | PožadavekPovinné | Hodnoty a limity MiniMax-M3 | Výchozí— |
| Pole`messages` | Typ`message[]` | PožadavekPovinné | Hodnoty a limity Minimální počet položek: 1 | Výchozí— |
| Pole`messages[].role` | Typ`string` | PožadavekPovinné | Hodnoty a limity user, assistant | Výchozí— |
| Pole`messages[].content` | Typ`string\|content_block[]` | PožadavekPovinné | Hodnoty a limity | Výchozí— |
| Pole`system` | Typ`string\|content_block[]` | PožadavekVolitelné | Hodnoty a limity | Výchozí— |
| Pole`max_tokens` | Typ`integer` | PožadavekPovinné | Hodnoty a limity Minimum: 1 Limit platí pro: přesný limit vybraného modelu/karty | Výchozí— |
| Pole`stream` | Typ`boolean` | PožadavekVolitelné | Hodnoty a limity | Výchozífalse |
| Pole`temperature` | Typ`number` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`top_p` | Typ`number` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`stop_sequences` | Typ`string[]` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`tools` | Typ`tool[]` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`tools[].name` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Platí, když: nástroj je dodán | Výchozí— |
| Pole`tools[].description` | Typ`string` | PožadavekVolitelné | Hodnoty a limity | Výchozí— |
| Pole`tools[].input_schema` | Typ`JSON_schema` | PožadavekVolitelné | Hodnoty a limity | Výchozí— |
| Pole`tool_choice` | Typ`object` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`thinking.type` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`thinking.budget_tokens` | Typ`integer` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`output_config.effort` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`metadata` | Typ`object` | PožadavekVolitelné | Hodnoty a limity | Výchozí— |
| Pole`cache_control` | Typ`object` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
Kombinace vstupních materiálů
**Text** · text UTF8
`messages[].content nebo blok type=text`
**Text + obrázek**
`{type:image,source:{type:base64,media_type,data}} nebo zdroj type=url`
Parametry a životní cyklus metody
| Parametr | Kontrakt |
| --- | --- |
| Parametr`material_types` | Kontrakttext, image |
| Parametr`required` | Kontraktmodel, messages, max\_tokens |
| Parametr`optional_controls` | Kontraktnull |
| Parametr`content_type` | Kontraktapplication/json |
| Parametr`text_file_material` | Kontraktskutečný obsah UTF-8 vložený jako text; ID/URLs souborů vyžadují samostatnou přesně vymezenou podporu |
Životní cyklus: `exact retained published method`
Struktury metod a ID jsou přesné; schopnosti dodavatele jsou oddělené od připuštění požadavku.
### Tarify
#### Sazby metod Ailoot
Vstup
0,0003 US$ */ 1K*
Výstup
0,0012 US$ */ 1K*
Čtení z mezipaměti
≈0,00006 US$ */ 1K*
Zápis do mezipaměti
0,0003 US$ */ 1K*
Zápis do mezipaměti, 5 min
0,0003 US$ */ 1K tokens*
#### Ceny podle délky požadavku · Anthropic Messages
| Velikost požadavku v tokenech | Vstup | Výstup | Čtení z mezipaměti | Zápis do mezipaměti | Mezipaměť 5 min | Mezipaměť 1 hodina |
| --- | --- | --- | --- | --- | --- | --- |
| Velikost požadavku v tokenech(0; 524 288\] | Vstup0,0003 US$ | Výstup0,0012 US$ | Čtení z mezipaměti≈0,00006 US$ | Zápis do mezipaměti0,0003 US$ | Mezipaměť 5 min0,0003 US$ | Mezipaměť 1 hodinaZákladní: — |
| Velikost požadavku v tokenech(524 288; 1 000 000\] | Vstup0,0006 US$ | Výstup0,0024 US$ | Čtení z mezipaměti≈0,00012 US$ | Zápis do mezipaměti0,0006 US$ | Mezipaměť 5 min0,0006 US$ | Mezipaměť 1 hodinaZákladní: — |
Sazby v USD za 1K tokenů. Není-li sazba nastavena, použije se zděděná základní sazba této metody; «—» znamená, že základní sazba není nastavena.
Ailoot před požadavkem rezervuje odhadovanou částku. Po výsledku vyúčtuje konečný poplatek podle naměřeného využití. Při streamování se účtování řídí konečným záznamem využití. [Jak funguje rezervace a vyúčtování →](https://ailoot.ai/docs/cs/billing/reserve/)
#### Podrobnosti referenčního tarifu
Referenční tabulky modelu nemění výběr metody, cenové nabídky ani poplatky. Skutečné poplatky používají sazby vybrané metody Ailoot.
Referenční tabulky modelu
#### Ceny podle konfigurace
Přiřaďte každý poplatek k uvedeným podmínkám. Pro každou sadu alternativních konfigurací použijte jednu sazbu.
| Konfigurace | Tabulka sazeb | Tokeny kontextu, více než | Tokeny kontextu, do uvedené hodnoty včetně | Poplatek |
| --- | --- | --- | --- | --- |
| KonfiguraceOpenAI Chat · Základní sazby za tokeny | Tabulka sazebZákladní sazba | Tokeny kontextu, více než— | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.0006** / 1K tokenů Výstup · Výstupní tokeny **$0.0024** / 1K tokenů Vstup · Čtení z mezipaměti **$0.00012** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguraceOpenAI Chat · Úroveň 1 podle délky požadavku | Tabulka sazeb— | Tokeny kontextu, více než0 | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.0006** / 1K tokenů Výstup · Výstupní tokeny **$0.0024** / 1K tokenů Vstup · Čtení z mezipaměti **$0.00012** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguraceAnthropic Messages · Základní sazby za tokeny | Tabulka sazebZákladní sazba | Tokeny kontextu, více než— | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.0006** / 1K tokenů Výstup · Výstupní tokeny **$0.0024** / 1K tokenů Vstup · Čtení z mezipaměti **$0.00012** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguraceAnthropic Messages · Úroveň 1 podle délky požadavku | Tabulka sazeb— | Tokeny kontextu, více než0 | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.0006** / 1K tokenů Výstup · Výstupní tokeny **$0.0024** / 1K tokenů Vstup · Čtení z mezipaměti **$0.00012** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
### Příklady požadavků
#### Ailoot · Anthropic Messages
Textový příkladVstup, obrázekPython SDKNode.js SDKStreamování v Pythonu
```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_TEXT_FILE:?Set your actual UTF-8 source-material file}"
export AILOOT_TEXT_FILE
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model": "MiniMax-M3", "max_tokens": 1024, "messages": []}')
f=Path(os.environ["AILOOT_TEXT_FILE"])
if not f.is_file():raise SystemExit("Choose your actual UTF-8 source material")
text=f.read_text(encoding="utf-8")
if not text.strip():raise SystemExit("Source material must contain text")
p["messages"]=[{"role":"user","content":"Summarize this material and quote supporting source passages.\n\n"+text}]
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/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
print(json.dumps(json.loads(Path("result.json").read_text()),ensure_ascii=False,indent=2))
PY_RESULT
```
```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_IMAGE_FILE:?Set your actual PNG JPEG or WebP image}"
export AILOOT_IMAGE_FILE
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model": "MiniMax-M3", "max_tokens": 1024, "messages": [{"role": "user", "content": [{"type": "text", "text": "Read labels and numbers in this image; flag unreadable text."}]}]}')
import base64
f=Path(os.environ["AILOOT_IMAGE_FILE"])
if not f.is_file():raise SystemExit("Choose an actual PNG JPEG or WebP image")
raw=f.read_bytes()
mime="image/png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "image/jpeg" if raw.startswith(b"\xff\xd8") else "image/webp" if raw[:4]==b"RIFF" and raw[8:12]==b"WEBP" else None
if not mime:raise SystemExit("Use PNG JPEG or WebP")
b64=base64.b64encode(raw).decode()
p["messages"][0]["content"].append({"type":"image","source":{"type":"base64","media_type":mime,"data":b64}})
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/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
print(json.dumps(json.loads(Path("result.json").read_text()),ensure_ascii=False,indent=2))
PY_RESULT
```
```python
import anthropic
import os
if not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")
client = anthropic.Anthropic(base_url="https://api.ailoot.ai", api_key=os.environ["AILOOT_API_KEY"], max_retries=0)
msg = client.messages.create(
model="MiniMax-M3",
max_tokens=1024,
messages=[{"role": "user", "content": "Explain the difference between an observation and a hypothesis 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(msg.to_dict(mode="json"))
```
```js
import Anthropic from "@anthropic-ai/sdk";
if (!process.env.AILOOT_API_KEY?.trim()) throw new Error("Set AILOOT_API_KEY before making a request");
const client = new Anthropic({ baseURL: "https://api.ailoot.ai", apiKey: process.env.AILOOT_API_KEY, maxRetries: 0 });
const msg = await client.messages.create({
model: "MiniMax-M3",
max_tokens: 1024,
messages: [{ role: "user", content: "Explain the difference between an observation and a hypothesis in three sentences." }],
});
import { writeFileSync } from "node:fs";
function saveResult(data, stem = "result") {
writeFileSync(stem + ".json", JSON.stringify(data, null, 2));
console.log(JSON.stringify(data, null, 2));
const saveBlob = (encoded, suffix, label) => {
const raw = Buffer.from(encoded, "base64");
const ext = raw.subarray(0,8).equals(Buffer.from([137,80,78,71,13,10,26,10])) ? "png" : raw[0]===255 && raw[1]===216 ? "jpg" : raw.subarray(0,4).toString()==="RIFF" && raw.subarray(8,12).toString()==="WEBP" ? "webp" : suffix;
const file = `${stem}-${label}.${ext}`;
writeFileSync(file, raw); console.log("Saved", file);
};
for (const [i, block] of (data.content || []).entries()) console.log("Content", i, JSON.stringify(block));
for (const choice of data.choices || []) console.log("Choice", choice.index, JSON.stringify(choice.message || choice.delta || {}));
for (const [i, item] of (data.output || []).entries()) {
console.log("Output", i, JSON.stringify(item));
if (item.type === "image_generation_call" && item.result) saveBlob(item.result, item.output_format || "bin", `output-${i}`);
}
for (const [ci, candidate] of (data.candidates || []).entries()) {
for (const [pi, part] of (candidate.content?.parts || []).entries()) {
console.log("Candidate/part", ci, pi, JSON.stringify(part));
const blob = part.inlineData || part.inline_data;
if (blob?.data) {
const mime = blob.mimeType || blob.mime_type;
const suffix = ({"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"})[mime] || "bin";
saveBlob(blob.data, suffix, `candidate-${ci}-part-${pi}`);
}
}
}
}
saveResult(msg);
```
```python
import anthropic,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=anthropic.Anthropic(base_url="https://api.ailoot.ai",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.messages.stream(model='MiniMax-M3',max_tokens=1024,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_message()
save_result(final.to_dict(mode="json"),"stream-result")
```
### Přijímání a ukládání výsledků
#### Ailoot · Anthropic Messages
json nebo SSE
##### Uchovejte všechny dokončené výsledky
Uchovejte každou úplnou vrácenou odpověď, soubor i část obsahu.
Zachovejte všechny bloky obsahu, podpisy uvažování a skutečná ID použití nástrojů. Sestavte všechny přírůstky bloků SSE; první textový blok není úplný výstup.
##### Pokud je nutné ověřit původní odpověď
Zachovejte ID požadavků/odpovědí a hlavičky. Není dodána obecná URL pro načtení textové úlohy.
Pole odpovědi
| Pole | Typ |
| --- | --- |
| Pole`id` | Typstring |
| Pole`model` | Typstring |
| Pole`content[]` | Typtext\|thinking\|tool\_use\|other content block |
| Pole`stop_reason` | Typstring\|null |
| Pole`usage` | Typobject |
Chyby a další kroky
| Odpověď | Podmínka | Další krok |
| --- | --- | --- |
| Odpověď400 · `invalid_request_error` | PodmínkaNeplatná povinná pole, reprezentace podkladů nebo hodnota parametru | Další krokPřed novým požadavkem na vytvoření opravte uvedená pole. |
### Aliasy
#### Aliasy modelu
Ailoot [`MiniMax-M3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=MiniMax-M3&fmt=messages), [`minimax`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax&fmt=messages), [`minimax-latest`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-latest&fmt=messages), [`minimax-text`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-text&fmt=messages), [`minimax-text-latest`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-text-latest&fmt=messages), [`minimax/minimax-m3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax%2Fminimax-m3&fmt=messages)
**Ailoot Ultra** [`MiniMax-M3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Ultra&caller=MiniMax-M3&fmt=messages), [`minimax/minimax-m3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Ultra&caller=minimax%2Fminimax-m3&fmt=messages)
#### Aliasy cest metod
`/chat/completions`
#### Související ID modelů
[`minimax/minimax-m3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax%2Fminimax-m3&fmt=messages), [`minimax/minimax-m3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Ultra&caller=minimax%2Fminimax-m3&fmt=messages), [`minimax`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax&fmt=messages), [`minimax-latest`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-latest&fmt=messages), [`minimax-text`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-text&fmt=messages), [`minimax-text-latest`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-text-latest&fmt=messages), [`MiniMax-M3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=MiniMax-M3&fmt=messages), [`MiniMax-M3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Ultra&caller=MiniMax-M3&fmt=messages)
**Ailoot · OpenAI Responses** `POST /v1/responses` `MiniMax-M3`
[`MiniMax-M3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=MiniMax-M3&fmt=responses)
MiniMax /`MiniMax-M3`
ID modelu
- `MiniMax-M3`
- `minimax`
- `minimax-latest`
- `minimax-text`
- `minimax-text-latest`
- `minimax/minimax-m3`
### Úvod
MiniMax M3 je multimodální model pro dlouhodobou práci na kódu a agentní úlohy, který využívá MiniMax Sparse Attention a návrh pro dlouhý kontext. Uvedená chatová rozhraní Ultra přijímají text a vracejí textové odpovědi.
Přijímané vstupy
Text · Obrázky
Výsledky
Text
### Dostupné v Ailoot · vstupy a metody
**Ailoot · OpenAI Responses** `POST /v1/responses`
Vstup
`text`, `image`
Výstup
`text`
Kontext
1 000 000 tokens
Maximální výstup
1 000 000 tokens
Výstupní formát
json nebo SSE
| Pole | Typ | Požadavek | Hodnoty a limity | Výchozí |
| --- | --- | --- | --- | --- |
| Pole`model` | Typ`string` | PožadavekPovinné | Hodnoty a limity MiniMax-M3 | Výchozí— |
| Pole`input` | Typ`string\|input_item[]` | PožadavekPovinné | Hodnoty a limity | Výchozí— |
| Pole`instructions` | Typ`string` | PožadavekVolitelné | Hodnoty a limity | Výchozí— |
| Pole`input[].type` | Typ`string` | PožadavekVolitelné | Hodnoty a limity message, reasoning, function\_call, function\_call\_output | Výchozí— |
| Pole`input[].content` | Typ`string\|content_part[]` | PožadavekVolitelné | Hodnoty a limity | Výchozí— |
| Pole`input[].call_id` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Platí, když: function\_call\_output; zachovejte skutečně vrácené call\_id | Výchozí— |
| Pole`input[].output` | Typ`string\|content_part[]` | PožadavekVolitelné | Hodnoty a limity Platí, když: function\_call\_output | Výchozí— |
| Pole`max_output_tokens` | Typ`integer` | PožadavekVolitelné | Hodnoty a limity Minimum: 1 Závisí na modelu | Výchozí— |
| Pole`stream` | Typ`boolean` | PožadavekVolitelné | Hodnoty a limity | Výchozífalse |
| Pole`temperature` | Typ`number` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`top_p` | Typ`number` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`tools` | Typ`tool[]` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`tool_choice` | Typ`string\|object` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`parallel_tool_calls` | Typ`boolean` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`reasoning.effort` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`reasoning.summary` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`text.format` | Typ`object` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`text.verbosity` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`include` | Typ`string[]` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`store` | Typ`boolean` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`previous_response_id` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Požadavek na ID: Pouze skutečné ID odpovědi z podporovaného pokračování Závisí na modelu | Výchozí— |
| Pole`service_tier` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`prompt_cache_key` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`prompt_cache_options` | Typ`object` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
Kombinace vstupních materiálů
**Text** · text UTF8
`vstupní text nebo část input_text`
**Text + obrázek**
`{type:input_image,image_url}`
Parametry a životní cyklus metody
| Parametr | Kontrakt |
| --- | --- |
| Parametr`material_types` | Kontrakttext, image |
| Parametr`required` | Kontraktmodel, input |
| Parametr`optional_controls` | Kontraktnull |
| Parametr`content_type` | Kontraktapplication/json |
| Parametr`text_file_material` | Kontraktskutečný obsah UTF-8 vložený jako text; ID/URLs souborů vyžadují samostatnou přesně vymezenou podporu |
Životní cyklus: `exact retained published method`
Struktury metod a ID jsou přesné; schopnosti dodavatele jsou oddělené od připuštění požadavku.
### Tarify
#### Sazby metod Ailoot
Vstup
0,0003 US$ */ 1K*
Výstup
0,0012 US$ */ 1K*
Čtení z mezipaměti
≈0,00006 US$ */ 1K*
Zápis do mezipaměti
0,0003 US$ */ 1K*
Zápis do mezipaměti, 5 min
0,0003 US$ */ 1K tokens*
#### Ceny podle délky požadavku · OpenAI Responses
| Velikost požadavku v tokenech | Vstup | Výstup | Čtení z mezipaměti | Zápis do mezipaměti | Mezipaměť 5 min | Mezipaměť 1 hodina |
| --- | --- | --- | --- | --- | --- | --- |
| Velikost požadavku v tokenech(0; 524 288\] | Vstup0,0003 US$ | Výstup0,0012 US$ | Čtení z mezipaměti≈0,00006 US$ | Zápis do mezipaměti0,0003 US$ | Mezipaměť 5 min0,0003 US$ | Mezipaměť 1 hodinaZákladní: — |
| Velikost požadavku v tokenech(524 288; 1 000 000\] | Vstup0,0006 US$ | Výstup0,0024 US$ | Čtení z mezipaměti≈0,00012 US$ | Zápis do mezipaměti0,0006 US$ | Mezipaměť 5 min0,0006 US$ | Mezipaměť 1 hodinaZákladní: — |
Sazby v USD za 1K tokenů. Není-li sazba nastavena, použije se zděděná základní sazba této metody; «—» znamená, že základní sazba není nastavena.
Ailoot před požadavkem rezervuje odhadovanou částku. Po výsledku vyúčtuje konečný poplatek podle naměřeného využití. Při streamování se účtování řídí konečným záznamem využití. [Jak funguje rezervace a vyúčtování →](https://ailoot.ai/docs/cs/billing/reserve/)
#### Podrobnosti referenčního tarifu
Referenční tabulky modelu nemění výběr metody, cenové nabídky ani poplatky. Skutečné poplatky používají sazby vybrané metody Ailoot.
Referenční tabulky modelu
#### Ceny podle konfigurace
Přiřaďte každý poplatek k uvedeným podmínkám. Pro každou sadu alternativních konfigurací použijte jednu sazbu.
| Konfigurace | Tabulka sazeb | Tokeny kontextu, více než | Tokeny kontextu, do uvedené hodnoty včetně | Poplatek |
| --- | --- | --- | --- | --- |
| KonfiguraceOpenAI Chat · Základní sazby za tokeny | Tabulka sazebZákladní sazba | Tokeny kontextu, více než— | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.0006** / 1K tokenů Výstup · Výstupní tokeny **$0.0024** / 1K tokenů Vstup · Čtení z mezipaměti **$0.00012** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguraceOpenAI Chat · Úroveň 1 podle délky požadavku | Tabulka sazeb— | Tokeny kontextu, více než0 | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.0006** / 1K tokenů Výstup · Výstupní tokeny **$0.0024** / 1K tokenů Vstup · Čtení z mezipaměti **$0.00012** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguraceAnthropic Messages · Základní sazby za tokeny | Tabulka sazebZákladní sazba | Tokeny kontextu, více než— | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.0006** / 1K tokenů Výstup · Výstupní tokeny **$0.0024** / 1K tokenů Vstup · Čtení z mezipaměti **$0.00012** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguraceAnthropic Messages · Úroveň 1 podle délky požadavku | Tabulka sazeb— | Tokeny kontextu, více než0 | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.0006** / 1K tokenů Výstup · Výstupní tokeny **$0.0024** / 1K tokenů Vstup · Čtení z mezipaměti **$0.00012** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
### Příklady požadavků
#### Ailoot · OpenAI Responses
Textový příkladVstup, obrázekPython SDKNode.js SDKStreamování v Pythonu
```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_TEXT_FILE:?Set your actual UTF-8 source-material file}"
export AILOOT_TEXT_FILE
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model": "MiniMax-M3", "input": ""}')
f=Path(os.environ["AILOOT_TEXT_FILE"])
if not f.is_file():raise SystemExit("Choose your actual UTF-8 source material")
text=f.read_text(encoding="utf-8")
if not text.strip():raise SystemExit("Source material must contain text")
p["input"]="Summarize this material and quote supporting source passages.\n\n"+text
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/responses \
-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 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(json.loads(Path("result.json").read_text(encoding="utf-8")))
PY_RESULT
```
```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_IMAGE_FILE:?Set your actual PNG JPEG or WebP image}"
export AILOOT_IMAGE_FILE
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model": "MiniMax-M3", "input": [{"role": "user", "content": [{"type": "input_text", "text": "Read labels and numbers in this image; flag unreadable text."}]}]}')
import base64
f=Path(os.environ["AILOOT_IMAGE_FILE"])
if not f.is_file():raise SystemExit("Choose an actual PNG JPEG or WebP image")
raw=f.read_bytes()
mime="image/png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "image/jpeg" if raw.startswith(b"\xff\xd8") else "image/webp" if raw[:4]==b"RIFF" and raw[8:12]==b"WEBP" else None
if not mime:raise SystemExit("Use PNG JPEG or WebP")
b64=base64.b64encode(raw).decode()
p["input"][0]["content"].append({"type":"input_image","image_url":"data:"+mime+";base64,"+b64})
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/responses \
-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 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(json.loads(Path("result.json").read_text(encoding="utf-8")))
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)
resp = client.responses.create(model="MiniMax-M3", input="Explain the difference between an observation and a hypothesis 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(resp.to_dict(mode="json"))
```
```js
import OpenAI from "openai";
if (!process.env.AILOOT_API_KEY?.trim()) throw new Error("Set AILOOT_API_KEY before making a request");
const client = new OpenAI({ baseURL: "https://api.ailoot.ai/v1", apiKey: process.env.AILOOT_API_KEY, maxRetries: 0 });
const resp = await client.responses.create({ model: "MiniMax-M3", input: "Explain the difference between an observation and a hypothesis in three sentences." });
import { writeFileSync } from "node:fs";
function saveResult(data, stem = "result") {
writeFileSync(stem + ".json", JSON.stringify(data, null, 2));
console.log(JSON.stringify(data, null, 2));
const saveBlob = (encoded, suffix, label) => {
const raw = Buffer.from(encoded, "base64");
const ext = raw.subarray(0,8).equals(Buffer.from([137,80,78,71,13,10,26,10])) ? "png" : raw[0]===255 && raw[1]===216 ? "jpg" : raw.subarray(0,4).toString()==="RIFF" && raw.subarray(8,12).toString()==="WEBP" ? "webp" : suffix;
const file = `${stem}-${label}.${ext}`;
writeFileSync(file, raw); console.log("Saved", file);
};
for (const [i, block] of (data.content || []).entries()) console.log("Content", i, JSON.stringify(block));
for (const choice of data.choices || []) console.log("Choice", choice.index, JSON.stringify(choice.message || choice.delta || {}));
for (const [i, item] of (data.output || []).entries()) {
console.log("Output", i, JSON.stringify(item));
if (item.type === "image_generation_call" && item.result) saveBlob(item.result, item.output_format || "bin", `output-${i}`);
}
for (const [ci, candidate] of (data.candidates || []).entries()) {
for (const [pi, part] of (candidate.content?.parts || []).entries()) {
console.log("Candidate/part", ci, pi, JSON.stringify(part));
const blob = part.inlineData || part.inline_data;
if (blob?.data) {
const mime = blob.mimeType || blob.mime_type;
const suffix = ({"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"})[mime] || "bin";
saveBlob(blob.data, suffix, `candidate-${ci}-part-${pi}`);
}
}
}
}
saveResult(resp);
```
```python
from openai import OpenAI
import os
from pathlib import Path
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))
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)
with client.responses.stream(model="MiniMax-M3", input="Explain the difference between an observation and a hypothesis 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_response()
save_result(final.to_dict(mode="json"),"stream-result")
```
### Přijímání a ukládání výsledků
#### Ailoot · OpenAI Responses
json nebo SSE
##### Uchovejte všechny dokončené výsledky
Uchovejte každou úplnou vrácenou odpověď, soubor i část obsahu.
Zachovejte každou výstupní položku a část obsahu, skutečné call\_id funkce, šifrované uvažování a údaje o využití. Při streamování uchovejte úplnou identitu události/položky.
##### Pokud je nutné ověřit původní odpověď
Zachovejte ID požadavků/odpovědí a hlavičky. Není dodána obecná URL pro načtení textové úlohy.
Pole odpovědi
| Pole | Typ |
| --- | --- |
| Pole`id` | Typstring |
| Pole`status` | Typstring |
| Pole`output[]` | Typmessage\|reasoning\|function\_call\|other item |
| Pole`output[].content[]` | Typcontent part |
| Pole`usage` | Typobject |
Chyby a další kroky
| Odpověď | Podmínka | Další krok |
| --- | --- | --- |
| Odpověď400 · `invalid_request_error` | PodmínkaNeplatná povinná pole, reprezentace podkladů nebo hodnota parametru | Další krokPřed novým požadavkem na vytvoření opravte uvedená pole. |
### Aliasy
#### Aliasy modelu
Ailoot [`MiniMax-M3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=MiniMax-M3&fmt=responses), [`minimax`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax&fmt=responses), [`minimax-latest`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-latest&fmt=responses), [`minimax-text`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-text&fmt=responses), [`minimax-text-latest`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-text-latest&fmt=responses), [`minimax/minimax-m3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax%2Fminimax-m3&fmt=responses)
**Ailoot Ultra** [`MiniMax-M3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Ultra&caller=MiniMax-M3), [`minimax/minimax-m3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Ultra&caller=minimax%2Fminimax-m3)
#### Aliasy cest metod
`/chat/completions`
#### Související ID modelů
[`minimax/minimax-m3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax%2Fminimax-m3&fmt=responses), [`minimax/minimax-m3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Ultra&caller=minimax%2Fminimax-m3), [`minimax`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax&fmt=responses), [`minimax-latest`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-latest&fmt=responses), [`minimax-text`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-text&fmt=responses), [`minimax-text-latest`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-text-latest&fmt=responses), [`MiniMax-M3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=MiniMax-M3&fmt=responses), [`MiniMax-M3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Ultra&caller=MiniMax-M3)
**Ailoot · OpenAI Chat** `POST /v1/chat/completions` `MiniMax-M3`
[`MiniMax-M3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=MiniMax-M3&fmt=chat)
MiniMax /`MiniMax-M3`
ID modelu
- `MiniMax-M3`
- `minimax`
- `minimax-latest`
- `minimax-text`
- `minimax-text-latest`
- `minimax/minimax-m3`
### Úvod
MiniMax M3 je multimodální model pro dlouhodobou práci na kódu a agentní úlohy, který využívá MiniMax Sparse Attention a návrh pro dlouhý kontext. Uvedená chatová rozhraní Ultra přijímají text a vracejí textové odpovědi.
Přijímané vstupy
Text · Obrázky
Výsledky
Text
### Dostupné v Ailoot · vstupy a metody
**Ailoot · OpenAI Chat** `POST /v1/chat/completions`
Vstup
`text`, `image`
Výstup
`text`
Kontext
1 000 000 tokens
Maximální výstup
524 288 tokens
Výstupní formát
json nebo SSE
| Pole | Typ | Požadavek | Hodnoty a limity | Výchozí |
| --- | --- | --- | --- | --- |
| Pole`model` | Typ`string` | PožadavekPovinné | Hodnoty a limity MiniMax-M3 | Výchozí— |
| Pole`messages` | Typ`message[]` | PožadavekPovinné | Hodnoty a limity Minimální počet položek: 1 | Výchozí— |
| Pole`messages[].role` | Typ`string` | PožadavekPovinné | Hodnoty a limity Příklady: system, user, assistant, tool, function Podmínky: Tyto role jsou výslovně zastoupeny typy kompatibility zdrojového kódu; přesná sada rolí zůstává specifická pro daný model. Závisí na modelu | Výchozí— |
| Pole`messages[].content` | Typ`string\|content_part[]\|null` | PožadavekVolitelné | Hodnoty a limity | Výchozí— |
| Pole`messages[].tool_calls` | Typ`tool_call[]` | PožadavekVolitelné | Hodnoty a limity | Výchozí— |
| Pole`messages[].tool_call_id` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Platí, když: role=tool; použijte skutečně vrácené ID | Výchozí— |
| Pole`messages[].name` | Typ`string` | PožadavekVolitelné | Hodnoty a limity | Výchozí— |
| Pole`messages[].reasoning_content` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Platí, když: Předávejte zpět skutečně vrácené uvažování tam, kde je tento model používá | Výchozí— |
| Pole`messages[].reasoning_details` | Typ`object\|array` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`max_tokens` | Typ`integer` | PožadavekVolitelné | Hodnoty a limity Minimum: 1 Závisí na modelu | Výchozí— |
| Pole`max_completion_tokens` | Typ`integer` | PožadavekVolitelné | Hodnoty a limity Minimum: 1 Závisí na modelu | Výchozí— |
| Pole`stream` | Typ`boolean` | PožadavekVolitelné | Hodnoty a limity | Výchozífalse |
| Pole`stream_options.include_usage` | Typ`boolean` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`temperature` | Typ`number` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`top_p` | Typ`number` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`stop` | Typ`string\|string[]` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`tools` | Typ`function_tool[]` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`tools[].type` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`tools[].function.name` | Typ`string` | PožadavekPovinné | Hodnoty a limity Platí, když: nástroj typu funkce je dodán | Výchozí— |
| Pole`tools[].function.description` | Typ`string` | PožadavekVolitelné | Hodnoty a limity | Výchozí— |
| Pole`tools[].function.parameters` | Typ`JSON_schema` | PožadavekVolitelné | Hodnoty a limity | Výchozí— |
| Pole`tool_choice` | Typ`string\|object` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`parallel_tool_calls` | Typ`boolean` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`response_format` | Typ`object` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`reasoning_effort` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`reasoning` | Typ`object` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`service_tier` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`instructions` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Pole kompatibility | Výchozí— |
| Pole`functions` | Typ`function[]` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`function_call` | Typ`string\|object` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`prompt_cache_options` | Typ`object` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
Kombinace vstupních materiálů
**Text** · text UTF8
`messages[].content`
**Text + obrázek**
`{type:image_url,image_url:{url,detail}}`
Parametry a životní cyklus metody
| Parametr | Kontrakt |
| --- | --- |
| Parametr`material_types` | Kontrakttext, image |
| Parametr`required` | Kontraktmodel, messages |
| Parametr`optional_controls` | Kontraktnull |
| Parametr`content_type` | Kontraktapplication/json |
| Parametr`text_file_material` | Kontraktskutečný obsah UTF-8 vložený jako text; ID/URLs souborů vyžadují samostatnou přesně vymezenou podporu |
Životní cyklus: `exact retained published method`
Struktury metod a ID jsou přesné; schopnosti dodavatele jsou oddělené od připuštění požadavku.
### Tarify
#### Sazby metod Ailoot
Vstup
0,0003 US$ */ 1K*
Výstup
0,0012 US$ */ 1K*
Čtení z mezipaměti
≈0,00006 US$ */ 1K*
Zápis do mezipaměti
0,0003 US$ */ 1K*
Zápis do mezipaměti, 5 min
0,0003 US$ */ 1K tokens*
#### Ceny podle délky požadavku · OpenAI Chat
| Velikost požadavku v tokenech | Vstup | Výstup | Čtení z mezipaměti | Zápis do mezipaměti | Mezipaměť 5 min | Mezipaměť 1 hodina |
| --- | --- | --- | --- | --- | --- | --- |
| Velikost požadavku v tokenech(0; 524 288\] | Vstup0,0003 US$ | Výstup0,0012 US$ | Čtení z mezipaměti≈0,00006 US$ | Zápis do mezipaměti0,0003 US$ | Mezipaměť 5 min0,0003 US$ | Mezipaměť 1 hodinaZákladní: — |
| Velikost požadavku v tokenech(524 288; 1 000 000\] | Vstup0,0006 US$ | Výstup0,0024 US$ | Čtení z mezipaměti≈0,00012 US$ | Zápis do mezipaměti0,0006 US$ | Mezipaměť 5 min0,0006 US$ | Mezipaměť 1 hodinaZákladní: — |
Sazby v USD za 1K tokenů. Není-li sazba nastavena, použije se zděděná základní sazba této metody; «—» znamená, že základní sazba není nastavena.
Ailoot před požadavkem rezervuje odhadovanou částku. Po výsledku vyúčtuje konečný poplatek podle naměřeného využití. Při streamování se účtování řídí konečným záznamem využití. [Jak funguje rezervace a vyúčtování →](https://ailoot.ai/docs/cs/billing/reserve/)
#### Podrobnosti referenčního tarifu
Referenční tabulky modelu nemění výběr metody, cenové nabídky ani poplatky. Skutečné poplatky používají sazby vybrané metody Ailoot.
Referenční tabulky modelu
#### Ceny podle konfigurace
Přiřaďte každý poplatek k uvedeným podmínkám. Pro každou sadu alternativních konfigurací použijte jednu sazbu.
| Konfigurace | Tabulka sazeb | Tokeny kontextu, více než | Tokeny kontextu, do uvedené hodnoty včetně | Poplatek |
| --- | --- | --- | --- | --- |
| KonfiguraceOpenAI Chat · Základní sazby za tokeny | Tabulka sazebZákladní sazba | Tokeny kontextu, více než— | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.0006** / 1K tokenů Výstup · Výstupní tokeny **$0.0024** / 1K tokenů Vstup · Čtení z mezipaměti **$0.00012** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguraceOpenAI Chat · Úroveň 1 podle délky požadavku | Tabulka sazeb— | Tokeny kontextu, více než0 | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.0006** / 1K tokenů Výstup · Výstupní tokeny **$0.0024** / 1K tokenů Vstup · Čtení z mezipaměti **$0.00012** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguraceAnthropic Messages · Základní sazby za tokeny | Tabulka sazebZákladní sazba | Tokeny kontextu, více než— | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.0006** / 1K tokenů Výstup · Výstupní tokeny **$0.0024** / 1K tokenů Vstup · Čtení z mezipaměti **$0.00012** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguraceAnthropic Messages · Úroveň 1 podle délky požadavku | Tabulka sazeb— | Tokeny kontextu, více než0 | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.0006** / 1K tokenů Výstup · Výstupní tokeny **$0.0024** / 1K tokenů Vstup · Čtení z mezipaměti **$0.00012** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
### Příklady požadavků
#### Ailoot · OpenAI Chat
Textový příkladVstup, obrázekPython SDKNode.js SDKStreamování v Pythonu
```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_TEXT_FILE:?Set your actual UTF-8 source-material file}"
export AILOOT_TEXT_FILE
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model": "MiniMax-M3", "messages": []}')
f=Path(os.environ["AILOOT_TEXT_FILE"])
if not f.is_file():raise SystemExit("Choose your actual UTF-8 source material")
text=f.read_text(encoding="utf-8")
if not text.strip():raise SystemExit("Source material must contain text")
p["messages"]=[{"role":"user","content":"Summarize this material and quote supporting source passages.\n\n"+text}]
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
print(json.dumps(json.loads(Path("result.json").read_text()),ensure_ascii=False,indent=2))
PY_RESULT
```
```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_IMAGE_FILE:?Set your actual PNG JPEG or WebP image}"
export AILOOT_IMAGE_FILE
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model": "MiniMax-M3", "messages": [{"role": "user", "content": [{"type": "text", "text": "Read labels and numbers in this image; flag unreadable text."}]}]}')
import base64
f=Path(os.environ["AILOOT_IMAGE_FILE"])
if not f.is_file():raise SystemExit("Choose an actual PNG JPEG or WebP image")
raw=f.read_bytes()
mime="image/png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "image/jpeg" if raw.startswith(b"\xff\xd8") else "image/webp" if raw[:4]==b"RIFF" and raw[8:12]==b"WEBP" else None
if not mime:raise SystemExit("Use PNG JPEG or WebP")
b64=base64.b64encode(raw).decode()
p["messages"][0]["content"].append({"type":"image_url","image_url":{"url":"data:"+mime+";base64,"+b64}})
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
print(json.dumps(json.loads(Path("result.json").read_text()),ensure_ascii=False,indent=2))
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)
resp = client.chat.completions.create(
model="MiniMax-M3",
messages=[{"role": "user", "content": "Explain the difference between an observation and a hypothesis 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(resp.to_dict(mode="json"))
```
```js
import OpenAI from "openai";
if (!process.env.AILOOT_API_KEY?.trim()) throw new Error("Set AILOOT_API_KEY before making a request");
const client = new OpenAI({ baseURL: "https://api.ailoot.ai/v1", apiKey: process.env.AILOOT_API_KEY, maxRetries: 0 });
const resp = await client.chat.completions.create({
model: "MiniMax-M3",
messages: [{ role: "user", content: "Explain the difference between an observation and a hypothesis in three sentences." }],
});
import { writeFileSync } from "node:fs";
function saveResult(data, stem = "result") {
writeFileSync(stem + ".json", JSON.stringify(data, null, 2));
console.log(JSON.stringify(data, null, 2));
const saveBlob = (encoded, suffix, label) => {
const raw = Buffer.from(encoded, "base64");
const ext = raw.subarray(0,8).equals(Buffer.from([137,80,78,71,13,10,26,10])) ? "png" : raw[0]===255 && raw[1]===216 ? "jpg" : raw.subarray(0,4).toString()==="RIFF" && raw.subarray(8,12).toString()==="WEBP" ? "webp" : suffix;
const file = `${stem}-${label}.${ext}`;
writeFileSync(file, raw); console.log("Saved", file);
};
for (const [i, block] of (data.content || []).entries()) console.log("Content", i, JSON.stringify(block));
for (const choice of data.choices || []) console.log("Choice", choice.index, JSON.stringify(choice.message || choice.delta || {}));
for (const [i, item] of (data.output || []).entries()) {
console.log("Output", i, JSON.stringify(item));
if (item.type === "image_generation_call" && item.result) saveBlob(item.result, item.output_format || "bin", `output-${i}`);
}
for (const [ci, candidate] of (data.candidates || []).entries()) {
for (const [pi, part] of (candidate.content?.parts || []).entries()) {
console.log("Candidate/part", ci, pi, JSON.stringify(part));
const blob = part.inlineData || part.inline_data;
if (blob?.data) {
const mime = blob.mimeType || blob.mime_type;
const suffix = ({"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"})[mime] || "bin";
saveBlob(blob.data, suffix, `candidate-${ci}-part-${pi}`);
}
}
}
}
saveResult(resp);
```
```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='MiniMax-M3',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")
```
### Přijímání a ukládání výsledků
#### Ailoot · OpenAI Chat
json nebo SSE
##### Uchovejte všechny dokončené výsledky
Uchovejte každou úplnou vrácenou odpověď, soubor i část obsahu.
Zachovejte každou volbu a její obsah/volání nástrojů/uvažování. V SSE sestavujte přírůstky podle indexu volby/nástroje a zachovejte konečný důvod ukončení i údaje o využití.
##### Pokud je nutné ověřit původní odpověď
Zachovejte ID požadavků/odpovědí a hlavičky. Není dodána obecná URL pro načtení textové úlohy.
Pole odpovědi
| Pole | Typ |
| --- | --- |
| Pole`choices[].index` | Typinteger |
| Pole`choices[].message.content` | Typstring\|null |
| Pole`choices[].message.tool_calls` | Typtool\_call\[\] |
| Pole`choices[].message.reasoning_content` | Typstring |
| Pole`choices[].message.reasoning_details` | Typobject\|array |
| Pole`choices[].finish_reason` | Typstring\|null |
| Pole`usage` | Typobject |
Chyby a další kroky
| Odpověď | Podmínka | Další krok |
| --- | --- | --- |
| Odpověď400 · `invalid_request_error` | PodmínkaNeplatná povinná pole, reprezentace podkladů nebo hodnota parametru | Další krokPřed novým požadavkem na vytvoření opravte uvedená pole. |
### Aliasy
#### Aliasy modelu
Ailoot [`MiniMax-M3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=MiniMax-M3&fmt=chat), [`minimax`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax&fmt=chat), [`minimax-latest`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-latest&fmt=chat), [`minimax-text`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-text&fmt=chat), [`minimax-text-latest`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-text-latest&fmt=chat), [`minimax/minimax-m3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax%2Fminimax-m3&fmt=chat)
**Ailoot Ultra** [`MiniMax-M3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Ultra&caller=MiniMax-M3&fmt=chat), [`minimax/minimax-m3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Ultra&caller=minimax%2Fminimax-m3&fmt=chat)
#### Aliasy cest metod
`/chat/completions`
#### Související ID modelů
[`minimax/minimax-m3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax%2Fminimax-m3&fmt=chat), [`minimax/minimax-m3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Ultra&caller=minimax%2Fminimax-m3&fmt=chat), [`minimax`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax&fmt=chat), [`minimax-latest`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-latest&fmt=chat), [`minimax-text`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-text&fmt=chat), [`minimax-text-latest`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-text-latest&fmt=chat), [`MiniMax-M3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=MiniMax-M3&fmt=chat), [`MiniMax-M3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Ultra&caller=MiniMax-M3&fmt=chat)
**Ailoot Ultra · OpenAI Chat** `POST /v1/chat/completions` `MiniMax-M3`
[`MiniMax-M3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Ultra&caller=MiniMax-M3&fmt=chat)
MiniMax /`MiniMax-M3`
ID modelu
- `MiniMax-M3`
- `minimax/minimax-m3`
### Úvod
MiniMax M3 je multimodální model pro dlouhodobou práci na kódu a agentní úlohy, který využívá MiniMax Sparse Attention a návrh pro dlouhý kontext. Uvedená chatová rozhraní Ultra přijímají text a vracejí textové odpovědi.
Přijímané vstupy
Text
Výsledky
Text
### Dostupné v Ailoot · vstupy a metody
**Ailoot Ultra · OpenAI Chat** `POST /v1/chat/completions`
Vstup
`text`
Výstup
`text`
Výstupní formát
json nebo SSE
| Pole | Typ | Požadavek | Hodnoty a limity | Výchozí |
| --- | --- | --- | --- | --- |
| Pole`model` | Typ`string` | PožadavekPovinné | Hodnoty a limity MiniMax-M3 | Výchozí— |
| Pole`messages` | Typ`message[]` | PožadavekPovinné | Hodnoty a limity Minimální počet položek: 1 | Výchozí— |
| Pole`messages[].role` | Typ`string` | PožadavekPovinné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`messages[].content` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Platí, když: Textová konverzace | Výchozí— |
| Pole`stream` | Typ`boolean` | PožadavekVolitelné | Hodnoty a limity | Výchozífalse |
Kombinace vstupních materiálů
**Text** · text UTF8
`messages[].content`
Parametry a životní cyklus metody
| Parametr | Kontrakt |
| --- | --- |
| Parametr`content_type` | Kontraktapplication/json |
| Parametr`required` | Kontraktmodel, messages |
| Parametr`material_types` | Kontrakttext |
| Parametr`messages` | Kontraktpole zpráv se strukturou role/content |
| Parametr`file_material` | Kontraktskutečný dokument UTF-8 vložený jako doslovný text; ID souboru se neodvozuje |
| Parametr`optional_controls` | Kontraktstream |
| Parametr`control_scope` | KontraktTextová konverzace; stream je booleovská hodnota a ve výchozím nastavení je false. |
| Parametr`output_modalities` | Kontrakttext |
| Parametr`hosted_operations` | Kontraktfalse |
| Parametr`multimodal_input_binding` | Kontraktnull |
Aliasy metody: `/chat/completions`
Životní cyklus: `synchronous_or_streamed`
Odešlete přesné ID modelu spolu s messages.
Délka kontextu není limitem výstupu.
Textový soubor může dodat doslovný text; obrazové/zvukové vstupy a vstupy v podobě souborových objektů vyžadují přesnou vazbu.
### Tarify
Údaje o tarifech nepřidávají možnosti požadavku. Podporované parametry jsou uvedeny u vybrané metody.
Rychlý režim
Standardní sazba Při výběru rychlého režimu
Režim flex
Standardní sazba Při výběru režimu flex
Maximální intenzita uvažování
Standardní sazba Když se při maximální intenzitě uvažování použije výchozí úprava (default)
#### Sazby Ailoot
#### Ceny podle konfigurace
Přiřaďte každý poplatek k uvedeným podmínkám. Pro každou sadu alternativních konfigurací použijte jednu sazbu.
| Konfigurace | Tabulka sazeb | Tokeny kontextu, více než | Tokeny kontextu, do uvedené hodnoty včetně | Poplatek |
| --- | --- | --- | --- | --- |
| KonfiguraceZákladní sazby za tokeny | Tabulka sazebZákladní sazba | Tokeny kontextu, více než— | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.0006** / 1K tokenů Výstup · Výstupní tokeny **$0.0024** / 1K tokenů Vstup · Čtení z mezipaměti **$0.00012** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguracePásmo délky požadavku 1 | Tabulka sazeb— | Tokeny kontextu, více než0 | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.0006** / 1K tokenů Výstup · Výstupní tokeny **$0.0024** / 1K tokenů Vstup · Čtení z mezipaměti **$0.00012** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
Ailoot před požadavkem rezervuje odhadovanou částku. Po výsledku vyúčtuje konečný poplatek podle naměřeného využití. Při streamování se účtování řídí konečným záznamem využití. [Jak funguje rezervace a vyúčtování →](https://ailoot.ai/docs/cs/billing/reserve/)
### Příklady požadavků
#### 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":"MiniMax-M3","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="MiniMax-M3", 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"))
```
### Přijímání a ukládání výsledků
#### Ailoot Ultra · OpenAI Chat
json nebo SSE
##### Uchovejte všechny dokončené výsledky
Uchovejte každou úplnou vrácenou odpověď, soubor i část obsahu.
Zachovejte každou volbu a její obsah/volání nástrojů/uvažování. V SSE sestavujte přírůstky podle indexu volby/nástroje a zachovejte konečný důvod ukončení i údaje o využití.
##### Pokud je nutné ověřit původní odpověď
Zachovejte ID požadavků/odpovědí a hlavičky. Není dodána obecná URL pro načtení textové úlohy.
Pole odpovědi
| Pole | Typ |
| --- | --- |
| Pole`choices[].index` | Typinteger |
| Pole`choices[].message.content` | Typstring\|null |
| Pole`choices[].message.tool_calls` | Typtool\_call\[\] |
| Pole`choices[].message.reasoning_content` | Typstring |
| Pole`choices[].message.reasoning_details` | Typobject\|array |
| Pole`choices[].finish_reason` | Typstring\|null |
| Pole`usage` | Typobject |
Chyby a další kroky
| Odpověď | Podmínka | Další krok |
| --- | --- | --- |
| Odpověď400 · `invalid_request_error` | PodmínkaNeplatná povinná pole, reprezentace podkladů nebo hodnota parametru | Další krokPřed novým požadavkem na vytvoření opravte uvedená pole. |
### Aliasy
#### Aliasy modelu
Ailoot [`MiniMax-M3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=MiniMax-M3&fmt=chat), [`minimax`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax&fmt=chat), [`minimax-latest`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-latest&fmt=chat), [`minimax-text`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-text&fmt=chat), [`minimax-text-latest`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-text-latest&fmt=chat), [`minimax/minimax-m3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax%2Fminimax-m3&fmt=chat)
**Ailoot Ultra** [`MiniMax-M3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Ultra&caller=MiniMax-M3&fmt=chat), [`minimax/minimax-m3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Ultra&caller=minimax%2Fminimax-m3&fmt=chat)
#### Aliasy cest metod
`/chat/completions`
#### Související ID modelů
[`minimax/minimax-m3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax%2Fminimax-m3&fmt=chat), [`minimax/minimax-m3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Ultra&caller=minimax%2Fminimax-m3&fmt=chat), [`minimax`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax&fmt=chat), [`minimax-latest`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-latest&fmt=chat), [`minimax-text`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-text&fmt=chat), [`minimax-text-latest`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-text-latest&fmt=chat), [`MiniMax-M3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=MiniMax-M3&fmt=chat), [`MiniMax-M3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Ultra&caller=MiniMax-M3&fmt=chat)
**Ailoot Ultra · Anthropic Messages** `POST /v1/messages` `MiniMax-M3`
[`MiniMax-M3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Ultra&caller=MiniMax-M3&fmt=messages)
MiniMax /`MiniMax-M3`
ID modelu
- `MiniMax-M3`
- `minimax/minimax-m3`
### Úvod
MiniMax M3 je multimodální model pro dlouhodobou práci na kódu a agentní úlohy, který využívá MiniMax Sparse Attention a návrh pro dlouhý kontext. Uvedená chatová rozhraní Ultra přijímají text a vracejí textové odpovědi.
Přijímané vstupy
Text
Výsledky
json · sse
### Dostupné v Ailoot · vstupy a metody
**Ailoot Ultra · Anthropic Messages** `POST /v1/messages`
Vstup
`text`
Výstup
`json`, `sse`
Výstupní formát
JSON nebo SSE
| Pole | Typ | Požadavek | Hodnoty a limity | Výchozí |
| --- | --- | --- | --- | --- |
| Pole`model` | Typ`string` | PožadavekPovinné | Hodnoty a limity MiniMax-M3 | Výchozí— |
| Pole`messages` | Typ`message[]` | PožadavekPovinné | Hodnoty a limity | Výchozí— |
| Pole`messages[].role` | Typ`string` | PožadavekPovinné | Hodnoty a limity user, assistant | Výchozí— |
| Pole`messages[].content` | Typ`string` | PožadavekPovinné | Hodnoty a limity | Výchozí— |
| Pole`max_tokens` | Typ`integer` | PožadavekPovinné | Hodnoty a limity | Výchozí— |
| Pole`stream` | Typ`boolean` | PožadavekVolitelné | Hodnoty a limity | Výchozífalse |
Kombinace vstupních materiálů
**Text** · text UTF-8
`řetězec messages[].content`
Parametry a životní cyklus metody
| Parametr | Kontrakt |
| --- | --- |
| Parametr`content_type` | Kontraktapplication/json |
| Parametr`required` | Kontraktmodel, messages, max\_tokens |
| Parametr`optional_controls` | Kontraktstream |
| Parametr`material_types` | Kontrakttext |
| Parametr`text_file_material` | KontraktPřečtěte skutečný dokument UTF-8 a vložte jeho text do uvedeného pole input nebo do řetězce obsahu zprávy. |
Životní cyklus: `synchronous_or_streamed`
### Tarify
Údaje o tarifech nepřidávají možnosti požadavku. Podporované parametry jsou uvedeny u vybrané metody.
Rychlý režim
Standardní sazba Při výběru rychlého režimu
Režim flex
Standardní sazba Při výběru režimu flex
Maximální intenzita uvažování
Standardní sazba Když se při maximální intenzitě uvažování použije výchozí úprava (default)
#### Sazby Ailoot
#### Ceny podle konfigurace
Přiřaďte každý poplatek k uvedeným podmínkám. Pro každou sadu alternativních konfigurací použijte jednu sazbu.
| Konfigurace | Tabulka sazeb | Tokeny kontextu, více než | Tokeny kontextu, do uvedené hodnoty včetně | Poplatek |
| --- | --- | --- | --- | --- |
| KonfiguraceZákladní sazby za tokeny | Tabulka sazebZákladní sazba | Tokeny kontextu, více než— | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.0006** / 1K tokenů Výstup · Výstupní tokeny **$0.0024** / 1K tokenů Vstup · Čtení z mezipaměti **$0.00012** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguracePásmo délky požadavku 1 | Tabulka sazeb— | Tokeny kontextu, více než0 | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.0006** / 1K tokenů Výstup · Výstupní tokeny **$0.0024** / 1K tokenů Vstup · Čtení z mezipaměti **$0.00012** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
Ailoot před požadavkem rezervuje odhadovanou částku. Po výsledku vyúčtuje konečný poplatek podle naměřeného využití. Při streamování se účtování řídí konečným záznamem využití. [Jak funguje rezervace a vyúčtování →](https://ailoot.ai/docs/cs/billing/reserve/)
### Příklady požadavků
#### Ailoot Ultra · Anthropic Messages
Úplné minimální tělo požadavku JSONcurl · použijte svůj dokument UTF-8Python · uložte úplný výsledek
```json
{
"model": "MiniMax-M3",
"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': 'MiniMax-M3', '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': 'MiniMax-M3', '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))
```
### Přijímání a ukládání výsledků
#### Ailoot Ultra · Anthropic Messages
JSON nebo SSE
##### Uchovejte všechny dokončené výsledky
Uchovejte každou úplnou vrácenou odpověď, soubor i část obsahu.
Zachovejte všechny bloky obsahu, podpisy uvažování a skutečná ID použití nástrojů. Sestavte všechny přírůstky bloků SSE; první textový blok není úplný výstup.
##### Pokud je nutné ověřit původní odpověď
Zachovejte ID požadavků/odpovědí a hlavičky. Není dodána obecná URL pro načtení textové úlohy.
Pole odpovědi
| Pole | Typ |
| --- | --- |
| Pole`id` | Typstring |
| Pole`model` | Typstring |
| Pole`content[]` | Typtext\|thinking\|tool\_use\|other content block |
| Pole`stop_reason` | Typstring\|null |
| Pole`usage` | Typobject |
Chyby a další kroky
| Odpověď | Podmínka | Další krok |
| --- | --- | --- |
| Odpověď400 · `invalid_request_error` | PodmínkaNeplatná povinná pole, reprezentace podkladů nebo hodnota parametru | Další krokPřed novým požadavkem na vytvoření opravte uvedená pole. |
### Aliasy
#### Aliasy modelu
Ailoot [`MiniMax-M3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=MiniMax-M3&fmt=messages), [`minimax`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax&fmt=messages), [`minimax-latest`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-latest&fmt=messages), [`minimax-text`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-text&fmt=messages), [`minimax-text-latest`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-text-latest&fmt=messages), [`minimax/minimax-m3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax%2Fminimax-m3&fmt=messages)
**Ailoot Ultra** [`MiniMax-M3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Ultra&caller=MiniMax-M3&fmt=messages), [`minimax/minimax-m3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Ultra&caller=minimax%2Fminimax-m3&fmt=messages)
#### Aliasy cest metod
`/chat/completions`
#### Související ID modelů
[`minimax/minimax-m3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax%2Fminimax-m3&fmt=messages), [`minimax/minimax-m3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Ultra&caller=minimax%2Fminimax-m3&fmt=messages), [`minimax`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax&fmt=messages), [`minimax-latest`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-latest&fmt=messages), [`minimax-text`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-text&fmt=messages), [`minimax-text-latest`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-text-latest&fmt=messages), [`MiniMax-M3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=MiniMax-M3&fmt=messages), [`MiniMax-M3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Ultra&caller=MiniMax-M3&fmt=messages)
**Ailoot · Anthropic Messages** `POST /v1/messages` `minimax`
[`minimax`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax&fmt=messages)
MiniMax /`minimax`
ID modelu
- `MiniMax-M3`
- `minimax`
- `minimax-latest`
- `minimax-text`
- `minimax-text-latest`
- `minimax/minimax-m3`
### Úvod
MiniMax M3 je multimodální model pro dlouhodobou práci na kódu a agentní úlohy, který využívá MiniMax Sparse Attention a návrh pro dlouhý kontext. Uvedená chatová rozhraní Ultra přijímají text a vracejí textové odpovědi.
Přijímané vstupy
Text · Obrázky
Výsledky
Text
### Dostupné v Ailoot · vstupy a metody
**Ailoot · Anthropic Messages** `POST /v1/messages`
Vstup
`text`, `image`
Výstup
`text`
Kontext
1 000 000 tokens
Maximální výstup
524 288 tokens
Výstupní formát
json nebo SSE
| Pole | Typ | Požadavek | Hodnoty a limity | Výchozí |
| --- | --- | --- | --- | --- |
| Pole`model` | Typ`string` | PožadavekPovinné | Hodnoty a limity minimax | Výchozí— |
| Pole`messages` | Typ`message[]` | PožadavekPovinné | Hodnoty a limity Minimální počet položek: 1 | Výchozí— |
| Pole`messages[].role` | Typ`string` | PožadavekPovinné | Hodnoty a limity user, assistant | Výchozí— |
| Pole`messages[].content` | Typ`string\|content_block[]` | PožadavekPovinné | Hodnoty a limity | Výchozí— |
| Pole`system` | Typ`string\|content_block[]` | PožadavekVolitelné | Hodnoty a limity | Výchozí— |
| Pole`max_tokens` | Typ`integer` | PožadavekPovinné | Hodnoty a limity Minimum: 1 Limit platí pro: přesný limit vybraného modelu/karty | Výchozí— |
| Pole`stream` | Typ`boolean` | PožadavekVolitelné | Hodnoty a limity | Výchozífalse |
| Pole`temperature` | Typ`number` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`top_p` | Typ`number` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`stop_sequences` | Typ`string[]` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`tools` | Typ`tool[]` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`tools[].name` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Platí, když: nástroj je dodán | Výchozí— |
| Pole`tools[].description` | Typ`string` | PožadavekVolitelné | Hodnoty a limity | Výchozí— |
| Pole`tools[].input_schema` | Typ`JSON_schema` | PožadavekVolitelné | Hodnoty a limity | Výchozí— |
| Pole`tool_choice` | Typ`object` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`thinking.type` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`thinking.budget_tokens` | Typ`integer` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`output_config.effort` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`metadata` | Typ`object` | PožadavekVolitelné | Hodnoty a limity | Výchozí— |
| Pole`cache_control` | Typ`object` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
Kombinace vstupních materiálů
**Text** · text UTF8
`messages[].content nebo blok type=text`
**Text + obrázek**
`{type:image,source:{type:base64,media_type,data}} nebo zdroj type=url`
Parametry a životní cyklus metody
| Parametr | Kontrakt |
| --- | --- |
| Parametr`material_types` | Kontrakttext, image |
| Parametr`required` | Kontraktmodel, messages, max\_tokens |
| Parametr`optional_controls` | Kontraktnull |
| Parametr`content_type` | Kontraktapplication/json |
| Parametr`text_file_material` | Kontraktskutečný obsah UTF-8 vložený jako text; ID/URLs souborů vyžadují samostatnou přesně vymezenou podporu |
Životní cyklus: `exact retained published method`
Struktury metod a ID jsou přesné; schopnosti dodavatele jsou oddělené od připuštění požadavku.
### Tarify
#### Sazby metod Ailoot
Vstup
0,0003 US$ */ 1K*
Výstup
0,0012 US$ */ 1K*
Čtení z mezipaměti
≈0,00006 US$ */ 1K*
Zápis do mezipaměti
0,0003 US$ */ 1K*
Zápis do mezipaměti, 5 min
0,0003 US$ */ 1K tokens*
#### Ceny podle délky požadavku · Anthropic Messages
| Velikost požadavku v tokenech | Vstup | Výstup | Čtení z mezipaměti | Zápis do mezipaměti | Mezipaměť 5 min | Mezipaměť 1 hodina |
| --- | --- | --- | --- | --- | --- | --- |
| Velikost požadavku v tokenech(0; 524 288\] | Vstup0,0003 US$ | Výstup0,0012 US$ | Čtení z mezipaměti≈0,00006 US$ | Zápis do mezipaměti0,0003 US$ | Mezipaměť 5 min0,0003 US$ | Mezipaměť 1 hodinaZákladní: — |
| Velikost požadavku v tokenech(524 288; 1 000 000\] | Vstup0,0006 US$ | Výstup0,0024 US$ | Čtení z mezipaměti≈0,00012 US$ | Zápis do mezipaměti0,0006 US$ | Mezipaměť 5 min0,0006 US$ | Mezipaměť 1 hodinaZákladní: — |
Sazby v USD za 1K tokenů. Není-li sazba nastavena, použije se zděděná základní sazba této metody; «—» znamená, že základní sazba není nastavena.
Ailoot před požadavkem rezervuje odhadovanou částku. Po výsledku vyúčtuje konečný poplatek podle naměřeného využití. Při streamování se účtování řídí konečným záznamem využití. [Jak funguje rezervace a vyúčtování →](https://ailoot.ai/docs/cs/billing/reserve/)
#### Podrobnosti referenčního tarifu
Referenční tabulky modelu nemění výběr metody, cenové nabídky ani poplatky. Skutečné poplatky používají sazby vybrané metody Ailoot.
Referenční tabulky modelu
#### Ceny podle konfigurace
Přiřaďte každý poplatek k uvedeným podmínkám. Pro každou sadu alternativních konfigurací použijte jednu sazbu.
| Konfigurace | Tabulka sazeb | Tokeny kontextu, více než | Tokeny kontextu, do uvedené hodnoty včetně | Poplatek |
| --- | --- | --- | --- | --- |
| KonfiguraceOpenAI Chat · Základní sazby za tokeny | Tabulka sazebZákladní sazba | Tokeny kontextu, více než— | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.0006** / 1K tokenů Výstup · Výstupní tokeny **$0.0024** / 1K tokenů Vstup · Čtení z mezipaměti **$0.00012** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguraceOpenAI Chat · Úroveň 1 podle délky požadavku | Tabulka sazeb— | Tokeny kontextu, více než0 | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.0006** / 1K tokenů Výstup · Výstupní tokeny **$0.0024** / 1K tokenů Vstup · Čtení z mezipaměti **$0.00012** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguraceAnthropic Messages · Základní sazby za tokeny | Tabulka sazebZákladní sazba | Tokeny kontextu, více než— | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.0006** / 1K tokenů Výstup · Výstupní tokeny **$0.0024** / 1K tokenů Vstup · Čtení z mezipaměti **$0.00012** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguraceAnthropic Messages · Úroveň 1 podle délky požadavku | Tabulka sazeb— | Tokeny kontextu, více než0 | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.0006** / 1K tokenů Výstup · Výstupní tokeny **$0.0024** / 1K tokenů Vstup · Čtení z mezipaměti **$0.00012** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
### Příklady požadavků
#### Ailoot · Anthropic Messages
Textový příkladVstup, obrázekPython SDKNode.js SDKStreamování v Pythonu
```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_TEXT_FILE:?Set your actual UTF-8 source-material file}"
export AILOOT_TEXT_FILE
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model": "minimax", "max_tokens": 1024, "messages": []}')
f=Path(os.environ["AILOOT_TEXT_FILE"])
if not f.is_file():raise SystemExit("Choose your actual UTF-8 source material")
text=f.read_text(encoding="utf-8")
if not text.strip():raise SystemExit("Source material must contain text")
p["messages"]=[{"role":"user","content":"Summarize this material and quote supporting source passages.\n\n"+text}]
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/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
print(json.dumps(json.loads(Path("result.json").read_text()),ensure_ascii=False,indent=2))
PY_RESULT
```
```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_IMAGE_FILE:?Set your actual PNG JPEG or WebP image}"
export AILOOT_IMAGE_FILE
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model": "minimax", "max_tokens": 1024, "messages": [{"role": "user", "content": [{"type": "text", "text": "Read labels and numbers in this image; flag unreadable text."}]}]}')
import base64
f=Path(os.environ["AILOOT_IMAGE_FILE"])
if not f.is_file():raise SystemExit("Choose an actual PNG JPEG or WebP image")
raw=f.read_bytes()
mime="image/png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "image/jpeg" if raw.startswith(b"\xff\xd8") else "image/webp" if raw[:4]==b"RIFF" and raw[8:12]==b"WEBP" else None
if not mime:raise SystemExit("Use PNG JPEG or WebP")
b64=base64.b64encode(raw).decode()
p["messages"][0]["content"].append({"type":"image","source":{"type":"base64","media_type":mime,"data":b64}})
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/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
print(json.dumps(json.loads(Path("result.json").read_text()),ensure_ascii=False,indent=2))
PY_RESULT
```
```python
import anthropic
import os
if not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")
client = anthropic.Anthropic(base_url="https://api.ailoot.ai", api_key=os.environ["AILOOT_API_KEY"], max_retries=0)
msg = client.messages.create(
model="minimax",
max_tokens=1024,
messages=[{"role": "user", "content": "Explain the difference between an observation and a hypothesis 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(msg.to_dict(mode="json"))
```
```js
import Anthropic from "@anthropic-ai/sdk";
if (!process.env.AILOOT_API_KEY?.trim()) throw new Error("Set AILOOT_API_KEY before making a request");
const client = new Anthropic({ baseURL: "https://api.ailoot.ai", apiKey: process.env.AILOOT_API_KEY, maxRetries: 0 });
const msg = await client.messages.create({
model: "minimax",
max_tokens: 1024,
messages: [{ role: "user", content: "Explain the difference between an observation and a hypothesis in three sentences." }],
});
import { writeFileSync } from "node:fs";
function saveResult(data, stem = "result") {
writeFileSync(stem + ".json", JSON.stringify(data, null, 2));
console.log(JSON.stringify(data, null, 2));
const saveBlob = (encoded, suffix, label) => {
const raw = Buffer.from(encoded, "base64");
const ext = raw.subarray(0,8).equals(Buffer.from([137,80,78,71,13,10,26,10])) ? "png" : raw[0]===255 && raw[1]===216 ? "jpg" : raw.subarray(0,4).toString()==="RIFF" && raw.subarray(8,12).toString()==="WEBP" ? "webp" : suffix;
const file = `${stem}-${label}.${ext}`;
writeFileSync(file, raw); console.log("Saved", file);
};
for (const [i, block] of (data.content || []).entries()) console.log("Content", i, JSON.stringify(block));
for (const choice of data.choices || []) console.log("Choice", choice.index, JSON.stringify(choice.message || choice.delta || {}));
for (const [i, item] of (data.output || []).entries()) {
console.log("Output", i, JSON.stringify(item));
if (item.type === "image_generation_call" && item.result) saveBlob(item.result, item.output_format || "bin", `output-${i}`);
}
for (const [ci, candidate] of (data.candidates || []).entries()) {
for (const [pi, part] of (candidate.content?.parts || []).entries()) {
console.log("Candidate/part", ci, pi, JSON.stringify(part));
const blob = part.inlineData || part.inline_data;
if (blob?.data) {
const mime = blob.mimeType || blob.mime_type;
const suffix = ({"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"})[mime] || "bin";
saveBlob(blob.data, suffix, `candidate-${ci}-part-${pi}`);
}
}
}
}
saveResult(msg);
```
```python
import anthropic,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=anthropic.Anthropic(base_url="https://api.ailoot.ai",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.messages.stream(model='minimax',max_tokens=1024,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_message()
save_result(final.to_dict(mode="json"),"stream-result")
```
### Přijímání a ukládání výsledků
#### Ailoot · Anthropic Messages
json nebo SSE
##### Uchovejte všechny dokončené výsledky
Uchovejte každou úplnou vrácenou odpověď, soubor i část obsahu.
Zachovejte všechny bloky obsahu, podpisy uvažování a skutečná ID použití nástrojů. Sestavte všechny přírůstky bloků SSE; první textový blok není úplný výstup.
##### Pokud je nutné ověřit původní odpověď
Zachovejte ID požadavků/odpovědí a hlavičky. Není dodána obecná URL pro načtení textové úlohy.
Pole odpovědi
| Pole | Typ |
| --- | --- |
| Pole`id` | Typstring |
| Pole`model` | Typstring |
| Pole`content[]` | Typtext\|thinking\|tool\_use\|other content block |
| Pole`stop_reason` | Typstring\|null |
| Pole`usage` | Typobject |
Chyby a další kroky
| Odpověď | Podmínka | Další krok |
| --- | --- | --- |
| Odpověď400 · `invalid_request_error` | PodmínkaNeplatná povinná pole, reprezentace podkladů nebo hodnota parametru | Další krokPřed novým požadavkem na vytvoření opravte uvedená pole. |
### Aliasy
#### Aliasy modelu
Ailoot [`MiniMax-M3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=MiniMax-M3&fmt=messages), [`minimax`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax&fmt=messages), [`minimax-latest`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-latest&fmt=messages), [`minimax-text`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-text&fmt=messages), [`minimax-text-latest`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-text-latest&fmt=messages), [`minimax/minimax-m3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax%2Fminimax-m3&fmt=messages)
**Ailoot Ultra** [`MiniMax-M3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Ultra&caller=MiniMax-M3&fmt=messages), [`minimax/minimax-m3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Ultra&caller=minimax%2Fminimax-m3&fmt=messages)
#### Aliasy cest metod
`/chat/completions`
#### Související ID modelů
[`minimax/minimax-m3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax%2Fminimax-m3&fmt=messages), [`minimax/minimax-m3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Ultra&caller=minimax%2Fminimax-m3&fmt=messages), [`minimax`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax&fmt=messages), [`minimax-latest`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-latest&fmt=messages), [`minimax-text`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-text&fmt=messages), [`minimax-text-latest`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-text-latest&fmt=messages), [`MiniMax-M3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=MiniMax-M3&fmt=messages), [`MiniMax-M3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Ultra&caller=MiniMax-M3&fmt=messages)
**Ailoot · OpenAI Responses** `POST /v1/responses` `minimax`
[`minimax`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax&fmt=responses)
MiniMax /`minimax`
ID modelu
- `MiniMax-M3`
- `minimax`
- `minimax-latest`
- `minimax-text`
- `minimax-text-latest`
- `minimax/minimax-m3`
### Úvod
MiniMax M3 je multimodální model pro dlouhodobou práci na kódu a agentní úlohy, který využívá MiniMax Sparse Attention a návrh pro dlouhý kontext. Uvedená chatová rozhraní Ultra přijímají text a vracejí textové odpovědi.
Přijímané vstupy
Text · Obrázky
Výsledky
Text
### Dostupné v Ailoot · vstupy a metody
**Ailoot · OpenAI Responses** `POST /v1/responses`
Vstup
`text`, `image`
Výstup
`text`
Kontext
1 000 000 tokens
Maximální výstup
1 000 000 tokens
Výstupní formát
json nebo SSE
| Pole | Typ | Požadavek | Hodnoty a limity | Výchozí |
| --- | --- | --- | --- | --- |
| Pole`model` | Typ`string` | PožadavekPovinné | Hodnoty a limity minimax | Výchozí— |
| Pole`input` | Typ`string\|input_item[]` | PožadavekPovinné | Hodnoty a limity | Výchozí— |
| Pole`instructions` | Typ`string` | PožadavekVolitelné | Hodnoty a limity | Výchozí— |
| Pole`input[].type` | Typ`string` | PožadavekVolitelné | Hodnoty a limity message, reasoning, function\_call, function\_call\_output | Výchozí— |
| Pole`input[].content` | Typ`string\|content_part[]` | PožadavekVolitelné | Hodnoty a limity | Výchozí— |
| Pole`input[].call_id` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Platí, když: function\_call\_output; zachovejte skutečně vrácené call\_id | Výchozí— |
| Pole`input[].output` | Typ`string\|content_part[]` | PožadavekVolitelné | Hodnoty a limity Platí, když: function\_call\_output | Výchozí— |
| Pole`max_output_tokens` | Typ`integer` | PožadavekVolitelné | Hodnoty a limity Minimum: 1 Závisí na modelu | Výchozí— |
| Pole`stream` | Typ`boolean` | PožadavekVolitelné | Hodnoty a limity | Výchozífalse |
| Pole`temperature` | Typ`number` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`top_p` | Typ`number` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`tools` | Typ`tool[]` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`tool_choice` | Typ`string\|object` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`parallel_tool_calls` | Typ`boolean` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`reasoning.effort` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`reasoning.summary` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`text.format` | Typ`object` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`text.verbosity` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`include` | Typ`string[]` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`store` | Typ`boolean` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`previous_response_id` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Požadavek na ID: Pouze skutečné ID odpovědi z podporovaného pokračování Závisí na modelu | Výchozí— |
| Pole`service_tier` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`prompt_cache_key` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`prompt_cache_options` | Typ`object` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
Kombinace vstupních materiálů
**Text** · text UTF8
`vstupní text nebo část input_text`
**Text + obrázek**
`{type:input_image,image_url}`
Parametry a životní cyklus metody
| Parametr | Kontrakt |
| --- | --- |
| Parametr`material_types` | Kontrakttext, image |
| Parametr`required` | Kontraktmodel, input |
| Parametr`optional_controls` | Kontraktnull |
| Parametr`content_type` | Kontraktapplication/json |
| Parametr`text_file_material` | Kontraktskutečný obsah UTF-8 vložený jako text; ID/URLs souborů vyžadují samostatnou přesně vymezenou podporu |
Životní cyklus: `exact retained published method`
Struktury metod a ID jsou přesné; schopnosti dodavatele jsou oddělené od připuštění požadavku.
### Tarify
#### Sazby metod Ailoot
Vstup
0,0003 US$ */ 1K*
Výstup
0,0012 US$ */ 1K*
Čtení z mezipaměti
≈0,00006 US$ */ 1K*
Zápis do mezipaměti
0,0003 US$ */ 1K*
Zápis do mezipaměti, 5 min
0,0003 US$ */ 1K tokens*
#### Ceny podle délky požadavku · OpenAI Responses
| Velikost požadavku v tokenech | Vstup | Výstup | Čtení z mezipaměti | Zápis do mezipaměti | Mezipaměť 5 min | Mezipaměť 1 hodina |
| --- | --- | --- | --- | --- | --- | --- |
| Velikost požadavku v tokenech(0; 524 288\] | Vstup0,0003 US$ | Výstup0,0012 US$ | Čtení z mezipaměti≈0,00006 US$ | Zápis do mezipaměti0,0003 US$ | Mezipaměť 5 min0,0003 US$ | Mezipaměť 1 hodinaZákladní: — |
| Velikost požadavku v tokenech(524 288; 1 000 000\] | Vstup0,0006 US$ | Výstup0,0024 US$ | Čtení z mezipaměti≈0,00012 US$ | Zápis do mezipaměti0,0006 US$ | Mezipaměť 5 min0,0006 US$ | Mezipaměť 1 hodinaZákladní: — |
Sazby v USD za 1K tokenů. Není-li sazba nastavena, použije se zděděná základní sazba této metody; «—» znamená, že základní sazba není nastavena.
Ailoot před požadavkem rezervuje odhadovanou částku. Po výsledku vyúčtuje konečný poplatek podle naměřeného využití. Při streamování se účtování řídí konečným záznamem využití. [Jak funguje rezervace a vyúčtování →](https://ailoot.ai/docs/cs/billing/reserve/)
#### Podrobnosti referenčního tarifu
Referenční tabulky modelu nemění výběr metody, cenové nabídky ani poplatky. Skutečné poplatky používají sazby vybrané metody Ailoot.
Referenční tabulky modelu
#### Ceny podle konfigurace
Přiřaďte každý poplatek k uvedeným podmínkám. Pro každou sadu alternativních konfigurací použijte jednu sazbu.
| Konfigurace | Tabulka sazeb | Tokeny kontextu, více než | Tokeny kontextu, do uvedené hodnoty včetně | Poplatek |
| --- | --- | --- | --- | --- |
| KonfiguraceOpenAI Chat · Základní sazby za tokeny | Tabulka sazebZákladní sazba | Tokeny kontextu, více než— | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.0006** / 1K tokenů Výstup · Výstupní tokeny **$0.0024** / 1K tokenů Vstup · Čtení z mezipaměti **$0.00012** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguraceOpenAI Chat · Úroveň 1 podle délky požadavku | Tabulka sazeb— | Tokeny kontextu, více než0 | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.0006** / 1K tokenů Výstup · Výstupní tokeny **$0.0024** / 1K tokenů Vstup · Čtení z mezipaměti **$0.00012** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguraceAnthropic Messages · Základní sazby za tokeny | Tabulka sazebZákladní sazba | Tokeny kontextu, více než— | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.0006** / 1K tokenů Výstup · Výstupní tokeny **$0.0024** / 1K tokenů Vstup · Čtení z mezipaměti **$0.00012** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguraceAnthropic Messages · Úroveň 1 podle délky požadavku | Tabulka sazeb— | Tokeny kontextu, více než0 | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.0006** / 1K tokenů Výstup · Výstupní tokeny **$0.0024** / 1K tokenů Vstup · Čtení z mezipaměti **$0.00012** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
### Příklady požadavků
#### Ailoot · OpenAI Responses
Textový příkladVstup, obrázekPython SDKNode.js SDKStreamování v Pythonu
```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_TEXT_FILE:?Set your actual UTF-8 source-material file}"
export AILOOT_TEXT_FILE
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model": "minimax", "input": ""}')
f=Path(os.environ["AILOOT_TEXT_FILE"])
if not f.is_file():raise SystemExit("Choose your actual UTF-8 source material")
text=f.read_text(encoding="utf-8")
if not text.strip():raise SystemExit("Source material must contain text")
p["input"]="Summarize this material and quote supporting source passages.\n\n"+text
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/responses \
-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 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(json.loads(Path("result.json").read_text(encoding="utf-8")))
PY_RESULT
```
```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_IMAGE_FILE:?Set your actual PNG JPEG or WebP image}"
export AILOOT_IMAGE_FILE
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model": "minimax", "input": [{"role": "user", "content": [{"type": "input_text", "text": "Read labels and numbers in this image; flag unreadable text."}]}]}')
import base64
f=Path(os.environ["AILOOT_IMAGE_FILE"])
if not f.is_file():raise SystemExit("Choose an actual PNG JPEG or WebP image")
raw=f.read_bytes()
mime="image/png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "image/jpeg" if raw.startswith(b"\xff\xd8") else "image/webp" if raw[:4]==b"RIFF" and raw[8:12]==b"WEBP" else None
if not mime:raise SystemExit("Use PNG JPEG or WebP")
b64=base64.b64encode(raw).decode()
p["input"][0]["content"].append({"type":"input_image","image_url":"data:"+mime+";base64,"+b64})
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/responses \
-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 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(json.loads(Path("result.json").read_text(encoding="utf-8")))
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)
resp = client.responses.create(model="minimax", input="Explain the difference between an observation and a hypothesis 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(resp.to_dict(mode="json"))
```
```js
import OpenAI from "openai";
if (!process.env.AILOOT_API_KEY?.trim()) throw new Error("Set AILOOT_API_KEY before making a request");
const client = new OpenAI({ baseURL: "https://api.ailoot.ai/v1", apiKey: process.env.AILOOT_API_KEY, maxRetries: 0 });
const resp = await client.responses.create({ model: "minimax", input: "Explain the difference between an observation and a hypothesis in three sentences." });
import { writeFileSync } from "node:fs";
function saveResult(data, stem = "result") {
writeFileSync(stem + ".json", JSON.stringify(data, null, 2));
console.log(JSON.stringify(data, null, 2));
const saveBlob = (encoded, suffix, label) => {
const raw = Buffer.from(encoded, "base64");
const ext = raw.subarray(0,8).equals(Buffer.from([137,80,78,71,13,10,26,10])) ? "png" : raw[0]===255 && raw[1]===216 ? "jpg" : raw.subarray(0,4).toString()==="RIFF" && raw.subarray(8,12).toString()==="WEBP" ? "webp" : suffix;
const file = `${stem}-${label}.${ext}`;
writeFileSync(file, raw); console.log("Saved", file);
};
for (const [i, block] of (data.content || []).entries()) console.log("Content", i, JSON.stringify(block));
for (const choice of data.choices || []) console.log("Choice", choice.index, JSON.stringify(choice.message || choice.delta || {}));
for (const [i, item] of (data.output || []).entries()) {
console.log("Output", i, JSON.stringify(item));
if (item.type === "image_generation_call" && item.result) saveBlob(item.result, item.output_format || "bin", `output-${i}`);
}
for (const [ci, candidate] of (data.candidates || []).entries()) {
for (const [pi, part] of (candidate.content?.parts || []).entries()) {
console.log("Candidate/part", ci, pi, JSON.stringify(part));
const blob = part.inlineData || part.inline_data;
if (blob?.data) {
const mime = blob.mimeType || blob.mime_type;
const suffix = ({"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"})[mime] || "bin";
saveBlob(blob.data, suffix, `candidate-${ci}-part-${pi}`);
}
}
}
}
saveResult(resp);
```
```python
from openai import OpenAI
import os
from pathlib import Path
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))
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)
with client.responses.stream(model="minimax", input="Explain the difference between an observation and a hypothesis 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_response()
save_result(final.to_dict(mode="json"),"stream-result")
```
### Přijímání a ukládání výsledků
#### Ailoot · OpenAI Responses
json nebo SSE
##### Uchovejte všechny dokončené výsledky
Uchovejte každou úplnou vrácenou odpověď, soubor i část obsahu.
Zachovejte každou výstupní položku a část obsahu, skutečné call\_id funkce, šifrované uvažování a údaje o využití. Při streamování uchovejte úplnou identitu události/položky.
##### Pokud je nutné ověřit původní odpověď
Zachovejte ID požadavků/odpovědí a hlavičky. Není dodána obecná URL pro načtení textové úlohy.
Pole odpovědi
| Pole | Typ |
| --- | --- |
| Pole`id` | Typstring |
| Pole`status` | Typstring |
| Pole`output[]` | Typmessage\|reasoning\|function\_call\|other item |
| Pole`output[].content[]` | Typcontent part |
| Pole`usage` | Typobject |
Chyby a další kroky
| Odpověď | Podmínka | Další krok |
| --- | --- | --- |
| Odpověď400 · `invalid_request_error` | PodmínkaNeplatná povinná pole, reprezentace podkladů nebo hodnota parametru | Další krokPřed novým požadavkem na vytvoření opravte uvedená pole. |
### Aliasy
#### Aliasy modelu
Ailoot [`MiniMax-M3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=MiniMax-M3&fmt=responses), [`minimax`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax&fmt=responses), [`minimax-latest`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-latest&fmt=responses), [`minimax-text`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-text&fmt=responses), [`minimax-text-latest`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-text-latest&fmt=responses), [`minimax/minimax-m3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax%2Fminimax-m3&fmt=responses)
**Ailoot Ultra** [`MiniMax-M3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Ultra&caller=MiniMax-M3), [`minimax/minimax-m3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Ultra&caller=minimax%2Fminimax-m3)
#### Aliasy cest metod
`/chat/completions`
#### Související ID modelů
[`minimax/minimax-m3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax%2Fminimax-m3&fmt=responses), [`minimax/minimax-m3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Ultra&caller=minimax%2Fminimax-m3), [`minimax`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax&fmt=responses), [`minimax-latest`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-latest&fmt=responses), [`minimax-text`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-text&fmt=responses), [`minimax-text-latest`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-text-latest&fmt=responses), [`MiniMax-M3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=MiniMax-M3&fmt=responses), [`MiniMax-M3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Ultra&caller=MiniMax-M3)
**Ailoot · OpenAI Chat** `POST /v1/chat/completions` `minimax`
[`minimax`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax&fmt=chat)
MiniMax /`minimax`
ID modelu
- `MiniMax-M3`
- `minimax`
- `minimax-latest`
- `minimax-text`
- `minimax-text-latest`
- `minimax/minimax-m3`
### Úvod
MiniMax M3 je multimodální model pro dlouhodobou práci na kódu a agentní úlohy, který využívá MiniMax Sparse Attention a návrh pro dlouhý kontext. Uvedená chatová rozhraní Ultra přijímají text a vracejí textové odpovědi.
Přijímané vstupy
Text · Obrázky
Výsledky
Text
### Dostupné v Ailoot · vstupy a metody
**Ailoot · OpenAI Chat** `POST /v1/chat/completions`
Vstup
`text`, `image`
Výstup
`text`
Kontext
1 000 000 tokens
Maximální výstup
524 288 tokens
Výstupní formát
json nebo SSE
| Pole | Typ | Požadavek | Hodnoty a limity | Výchozí |
| --- | --- | --- | --- | --- |
| Pole`model` | Typ`string` | PožadavekPovinné | Hodnoty a limity minimax | Výchozí— |
| Pole`messages` | Typ`message[]` | PožadavekPovinné | Hodnoty a limity Minimální počet položek: 1 | Výchozí— |
| Pole`messages[].role` | Typ`string` | PožadavekPovinné | Hodnoty a limity Příklady: system, user, assistant, tool, function Podmínky: Tyto role jsou výslovně zastoupeny typy kompatibility zdrojového kódu; přesná sada rolí zůstává specifická pro daný model. Závisí na modelu | Výchozí— |
| Pole`messages[].content` | Typ`string\|content_part[]\|null` | PožadavekVolitelné | Hodnoty a limity | Výchozí— |
| Pole`messages[].tool_calls` | Typ`tool_call[]` | PožadavekVolitelné | Hodnoty a limity | Výchozí— |
| Pole`messages[].tool_call_id` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Platí, když: role=tool; použijte skutečně vrácené ID | Výchozí— |
| Pole`messages[].name` | Typ`string` | PožadavekVolitelné | Hodnoty a limity | Výchozí— |
| Pole`messages[].reasoning_content` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Platí, když: Předávejte zpět skutečně vrácené uvažování tam, kde je tento model používá | Výchozí— |
| Pole`messages[].reasoning_details` | Typ`object\|array` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`max_tokens` | Typ`integer` | PožadavekVolitelné | Hodnoty a limity Minimum: 1 Závisí na modelu | Výchozí— |
| Pole`max_completion_tokens` | Typ`integer` | PožadavekVolitelné | Hodnoty a limity Minimum: 1 Závisí na modelu | Výchozí— |
| Pole`stream` | Typ`boolean` | PožadavekVolitelné | Hodnoty a limity | Výchozífalse |
| Pole`stream_options.include_usage` | Typ`boolean` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`temperature` | Typ`number` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`top_p` | Typ`number` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`stop` | Typ`string\|string[]` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`tools` | Typ`function_tool[]` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`tools[].type` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`tools[].function.name` | Typ`string` | PožadavekPovinné | Hodnoty a limity Platí, když: nástroj typu funkce je dodán | Výchozí— |
| Pole`tools[].function.description` | Typ`string` | PožadavekVolitelné | Hodnoty a limity | Výchozí— |
| Pole`tools[].function.parameters` | Typ`JSON_schema` | PožadavekVolitelné | Hodnoty a limity | Výchozí— |
| Pole`tool_choice` | Typ`string\|object` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`parallel_tool_calls` | Typ`boolean` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`response_format` | Typ`object` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`reasoning_effort` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`reasoning` | Typ`object` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`service_tier` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`instructions` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Pole kompatibility | Výchozí— |
| Pole`functions` | Typ`function[]` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`function_call` | Typ`string\|object` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`prompt_cache_options` | Typ`object` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
Kombinace vstupních materiálů
**Text** · text UTF8
`messages[].content`
**Text + obrázek**
`{type:image_url,image_url:{url,detail}}`
Parametry a životní cyklus metody
| Parametr | Kontrakt |
| --- | --- |
| Parametr`material_types` | Kontrakttext, image |
| Parametr`required` | Kontraktmodel, messages |
| Parametr`optional_controls` | Kontraktnull |
| Parametr`content_type` | Kontraktapplication/json |
| Parametr`text_file_material` | Kontraktskutečný obsah UTF-8 vložený jako text; ID/URLs souborů vyžadují samostatnou přesně vymezenou podporu |
Životní cyklus: `exact retained published method`
Struktury metod a ID jsou přesné; schopnosti dodavatele jsou oddělené od připuštění požadavku.
### Tarify
#### Sazby metod Ailoot
Vstup
0,0003 US$ */ 1K*
Výstup
0,0012 US$ */ 1K*
Čtení z mezipaměti
≈0,00006 US$ */ 1K*
Zápis do mezipaměti
0,0003 US$ */ 1K*
Zápis do mezipaměti, 5 min
0,0003 US$ */ 1K tokens*
#### Ceny podle délky požadavku · OpenAI Chat
| Velikost požadavku v tokenech | Vstup | Výstup | Čtení z mezipaměti | Zápis do mezipaměti | Mezipaměť 5 min | Mezipaměť 1 hodina |
| --- | --- | --- | --- | --- | --- | --- |
| Velikost požadavku v tokenech(0; 524 288\] | Vstup0,0003 US$ | Výstup0,0012 US$ | Čtení z mezipaměti≈0,00006 US$ | Zápis do mezipaměti0,0003 US$ | Mezipaměť 5 min0,0003 US$ | Mezipaměť 1 hodinaZákladní: — |
| Velikost požadavku v tokenech(524 288; 1 000 000\] | Vstup0,0006 US$ | Výstup0,0024 US$ | Čtení z mezipaměti≈0,00012 US$ | Zápis do mezipaměti0,0006 US$ | Mezipaměť 5 min0,0006 US$ | Mezipaměť 1 hodinaZákladní: — |
Sazby v USD za 1K tokenů. Není-li sazba nastavena, použije se zděděná základní sazba této metody; «—» znamená, že základní sazba není nastavena.
Ailoot před požadavkem rezervuje odhadovanou částku. Po výsledku vyúčtuje konečný poplatek podle naměřeného využití. Při streamování se účtování řídí konečným záznamem využití. [Jak funguje rezervace a vyúčtování →](https://ailoot.ai/docs/cs/billing/reserve/)
#### Podrobnosti referenčního tarifu
Referenční tabulky modelu nemění výběr metody, cenové nabídky ani poplatky. Skutečné poplatky používají sazby vybrané metody Ailoot.
Referenční tabulky modelu
#### Ceny podle konfigurace
Přiřaďte každý poplatek k uvedeným podmínkám. Pro každou sadu alternativních konfigurací použijte jednu sazbu.
| Konfigurace | Tabulka sazeb | Tokeny kontextu, více než | Tokeny kontextu, do uvedené hodnoty včetně | Poplatek |
| --- | --- | --- | --- | --- |
| KonfiguraceOpenAI Chat · Základní sazby za tokeny | Tabulka sazebZákladní sazba | Tokeny kontextu, více než— | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.0006** / 1K tokenů Výstup · Výstupní tokeny **$0.0024** / 1K tokenů Vstup · Čtení z mezipaměti **$0.00012** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguraceOpenAI Chat · Úroveň 1 podle délky požadavku | Tabulka sazeb— | Tokeny kontextu, více než0 | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.0006** / 1K tokenů Výstup · Výstupní tokeny **$0.0024** / 1K tokenů Vstup · Čtení z mezipaměti **$0.00012** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguraceAnthropic Messages · Základní sazby za tokeny | Tabulka sazebZákladní sazba | Tokeny kontextu, více než— | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.0006** / 1K tokenů Výstup · Výstupní tokeny **$0.0024** / 1K tokenů Vstup · Čtení z mezipaměti **$0.00012** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguraceAnthropic Messages · Úroveň 1 podle délky požadavku | Tabulka sazeb— | Tokeny kontextu, více než0 | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.0006** / 1K tokenů Výstup · Výstupní tokeny **$0.0024** / 1K tokenů Vstup · Čtení z mezipaměti **$0.00012** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
### Příklady požadavků
#### Ailoot · OpenAI Chat
Textový příkladVstup, obrázekPython SDKNode.js SDKStreamování v Pythonu
```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_TEXT_FILE:?Set your actual UTF-8 source-material file}"
export AILOOT_TEXT_FILE
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model": "minimax", "messages": []}')
f=Path(os.environ["AILOOT_TEXT_FILE"])
if not f.is_file():raise SystemExit("Choose your actual UTF-8 source material")
text=f.read_text(encoding="utf-8")
if not text.strip():raise SystemExit("Source material must contain text")
p["messages"]=[{"role":"user","content":"Summarize this material and quote supporting source passages.\n\n"+text}]
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
print(json.dumps(json.loads(Path("result.json").read_text()),ensure_ascii=False,indent=2))
PY_RESULT
```
```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_IMAGE_FILE:?Set your actual PNG JPEG or WebP image}"
export AILOOT_IMAGE_FILE
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model": "minimax", "messages": [{"role": "user", "content": [{"type": "text", "text": "Read labels and numbers in this image; flag unreadable text."}]}]}')
import base64
f=Path(os.environ["AILOOT_IMAGE_FILE"])
if not f.is_file():raise SystemExit("Choose an actual PNG JPEG or WebP image")
raw=f.read_bytes()
mime="image/png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "image/jpeg" if raw.startswith(b"\xff\xd8") else "image/webp" if raw[:4]==b"RIFF" and raw[8:12]==b"WEBP" else None
if not mime:raise SystemExit("Use PNG JPEG or WebP")
b64=base64.b64encode(raw).decode()
p["messages"][0]["content"].append({"type":"image_url","image_url":{"url":"data:"+mime+";base64,"+b64}})
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
print(json.dumps(json.loads(Path("result.json").read_text()),ensure_ascii=False,indent=2))
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)
resp = client.chat.completions.create(
model="minimax",
messages=[{"role": "user", "content": "Explain the difference between an observation and a hypothesis 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(resp.to_dict(mode="json"))
```
```js
import OpenAI from "openai";
if (!process.env.AILOOT_API_KEY?.trim()) throw new Error("Set AILOOT_API_KEY before making a request");
const client = new OpenAI({ baseURL: "https://api.ailoot.ai/v1", apiKey: process.env.AILOOT_API_KEY, maxRetries: 0 });
const resp = await client.chat.completions.create({
model: "minimax",
messages: [{ role: "user", content: "Explain the difference between an observation and a hypothesis in three sentences." }],
});
import { writeFileSync } from "node:fs";
function saveResult(data, stem = "result") {
writeFileSync(stem + ".json", JSON.stringify(data, null, 2));
console.log(JSON.stringify(data, null, 2));
const saveBlob = (encoded, suffix, label) => {
const raw = Buffer.from(encoded, "base64");
const ext = raw.subarray(0,8).equals(Buffer.from([137,80,78,71,13,10,26,10])) ? "png" : raw[0]===255 && raw[1]===216 ? "jpg" : raw.subarray(0,4).toString()==="RIFF" && raw.subarray(8,12).toString()==="WEBP" ? "webp" : suffix;
const file = `${stem}-${label}.${ext}`;
writeFileSync(file, raw); console.log("Saved", file);
};
for (const [i, block] of (data.content || []).entries()) console.log("Content", i, JSON.stringify(block));
for (const choice of data.choices || []) console.log("Choice", choice.index, JSON.stringify(choice.message || choice.delta || {}));
for (const [i, item] of (data.output || []).entries()) {
console.log("Output", i, JSON.stringify(item));
if (item.type === "image_generation_call" && item.result) saveBlob(item.result, item.output_format || "bin", `output-${i}`);
}
for (const [ci, candidate] of (data.candidates || []).entries()) {
for (const [pi, part] of (candidate.content?.parts || []).entries()) {
console.log("Candidate/part", ci, pi, JSON.stringify(part));
const blob = part.inlineData || part.inline_data;
if (blob?.data) {
const mime = blob.mimeType || blob.mime_type;
const suffix = ({"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"})[mime] || "bin";
saveBlob(blob.data, suffix, `candidate-${ci}-part-${pi}`);
}
}
}
}
saveResult(resp);
```
```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='minimax',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")
```
### Přijímání a ukládání výsledků
#### Ailoot · OpenAI Chat
json nebo SSE
##### Uchovejte všechny dokončené výsledky
Uchovejte každou úplnou vrácenou odpověď, soubor i část obsahu.
Zachovejte každou volbu a její obsah/volání nástrojů/uvažování. V SSE sestavujte přírůstky podle indexu volby/nástroje a zachovejte konečný důvod ukončení i údaje o využití.
##### Pokud je nutné ověřit původní odpověď
Zachovejte ID požadavků/odpovědí a hlavičky. Není dodána obecná URL pro načtení textové úlohy.
Pole odpovědi
| Pole | Typ |
| --- | --- |
| Pole`choices[].index` | Typinteger |
| Pole`choices[].message.content` | Typstring\|null |
| Pole`choices[].message.tool_calls` | Typtool\_call\[\] |
| Pole`choices[].message.reasoning_content` | Typstring |
| Pole`choices[].message.reasoning_details` | Typobject\|array |
| Pole`choices[].finish_reason` | Typstring\|null |
| Pole`usage` | Typobject |
Chyby a další kroky
| Odpověď | Podmínka | Další krok |
| --- | --- | --- |
| Odpověď400 · `invalid_request_error` | PodmínkaNeplatná povinná pole, reprezentace podkladů nebo hodnota parametru | Další krokPřed novým požadavkem na vytvoření opravte uvedená pole. |
### Aliasy
#### Aliasy modelu
Ailoot [`MiniMax-M3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=MiniMax-M3&fmt=chat), [`minimax`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax&fmt=chat), [`minimax-latest`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-latest&fmt=chat), [`minimax-text`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-text&fmt=chat), [`minimax-text-latest`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-text-latest&fmt=chat), [`minimax/minimax-m3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax%2Fminimax-m3&fmt=chat)
**Ailoot Ultra** [`MiniMax-M3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Ultra&caller=MiniMax-M3&fmt=chat), [`minimax/minimax-m3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Ultra&caller=minimax%2Fminimax-m3&fmt=chat)
#### Aliasy cest metod
`/chat/completions`
#### Související ID modelů
[`minimax/minimax-m3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax%2Fminimax-m3&fmt=chat), [`minimax/minimax-m3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Ultra&caller=minimax%2Fminimax-m3&fmt=chat), [`minimax`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax&fmt=chat), [`minimax-latest`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-latest&fmt=chat), [`minimax-text`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-text&fmt=chat), [`minimax-text-latest`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-text-latest&fmt=chat), [`MiniMax-M3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=MiniMax-M3&fmt=chat), [`MiniMax-M3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Ultra&caller=MiniMax-M3&fmt=chat)
**Ailoot · Anthropic Messages** `POST /v1/messages` `minimax-latest`
[`minimax-latest`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-latest&fmt=messages)
MiniMax /`minimax-latest`
ID modelu
- `MiniMax-M3`
- `minimax`
- `minimax-latest`
- `minimax-text`
- `minimax-text-latest`
- `minimax/minimax-m3`
### Úvod
MiniMax M3 je multimodální model pro dlouhodobou práci na kódu a agentní úlohy, který využívá MiniMax Sparse Attention a návrh pro dlouhý kontext. Uvedená chatová rozhraní Ultra přijímají text a vracejí textové odpovědi.
Přijímané vstupy
Text · Obrázky
Výsledky
Text
### Dostupné v Ailoot · vstupy a metody
**Ailoot · Anthropic Messages** `POST /v1/messages`
Vstup
`text`, `image`
Výstup
`text`
Kontext
1 000 000 tokens
Maximální výstup
524 288 tokens
Výstupní formát
json nebo SSE
| Pole | Typ | Požadavek | Hodnoty a limity | Výchozí |
| --- | --- | --- | --- | --- |
| Pole`model` | Typ`string` | PožadavekPovinné | Hodnoty a limity minimax-latest | Výchozí— |
| Pole`messages` | Typ`message[]` | PožadavekPovinné | Hodnoty a limity Minimální počet položek: 1 | Výchozí— |
| Pole`messages[].role` | Typ`string` | PožadavekPovinné | Hodnoty a limity user, assistant | Výchozí— |
| Pole`messages[].content` | Typ`string\|content_block[]` | PožadavekPovinné | Hodnoty a limity | Výchozí— |
| Pole`system` | Typ`string\|content_block[]` | PožadavekVolitelné | Hodnoty a limity | Výchozí— |
| Pole`max_tokens` | Typ`integer` | PožadavekPovinné | Hodnoty a limity Minimum: 1 Limit platí pro: přesný limit vybraného modelu/karty | Výchozí— |
| Pole`stream` | Typ`boolean` | PožadavekVolitelné | Hodnoty a limity | Výchozífalse |
| Pole`temperature` | Typ`number` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`top_p` | Typ`number` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`stop_sequences` | Typ`string[]` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`tools` | Typ`tool[]` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`tools[].name` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Platí, když: nástroj je dodán | Výchozí— |
| Pole`tools[].description` | Typ`string` | PožadavekVolitelné | Hodnoty a limity | Výchozí— |
| Pole`tools[].input_schema` | Typ`JSON_schema` | PožadavekVolitelné | Hodnoty a limity | Výchozí— |
| Pole`tool_choice` | Typ`object` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`thinking.type` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`thinking.budget_tokens` | Typ`integer` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`output_config.effort` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`metadata` | Typ`object` | PožadavekVolitelné | Hodnoty a limity | Výchozí— |
| Pole`cache_control` | Typ`object` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
Kombinace vstupních materiálů
**Text** · text UTF8
`messages[].content nebo blok type=text`
**Text + obrázek**
`{type:image,source:{type:base64,media_type,data}} nebo zdroj type=url`
Parametry a životní cyklus metody
| Parametr | Kontrakt |
| --- | --- |
| Parametr`material_types` | Kontrakttext, image |
| Parametr`required` | Kontraktmodel, messages, max\_tokens |
| Parametr`optional_controls` | Kontraktnull |
| Parametr`content_type` | Kontraktapplication/json |
| Parametr`text_file_material` | Kontraktskutečný obsah UTF-8 vložený jako text; ID/URLs souborů vyžadují samostatnou přesně vymezenou podporu |
Životní cyklus: `exact retained published method`
Struktury metod a ID jsou přesné; schopnosti dodavatele jsou oddělené od připuštění požadavku.
### Tarify
#### Sazby metod Ailoot
Vstup
0,0003 US$ */ 1K*
Výstup
0,0012 US$ */ 1K*
Čtení z mezipaměti
≈0,00006 US$ */ 1K*
Zápis do mezipaměti
0,0003 US$ */ 1K*
Zápis do mezipaměti, 5 min
0,0003 US$ */ 1K tokens*
#### Ceny podle délky požadavku · Anthropic Messages
| Velikost požadavku v tokenech | Vstup | Výstup | Čtení z mezipaměti | Zápis do mezipaměti | Mezipaměť 5 min | Mezipaměť 1 hodina |
| --- | --- | --- | --- | --- | --- | --- |
| Velikost požadavku v tokenech(0; 524 288\] | Vstup0,0003 US$ | Výstup0,0012 US$ | Čtení z mezipaměti≈0,00006 US$ | Zápis do mezipaměti0,0003 US$ | Mezipaměť 5 min0,0003 US$ | Mezipaměť 1 hodinaZákladní: — |
| Velikost požadavku v tokenech(524 288; 1 000 000\] | Vstup0,0006 US$ | Výstup0,0024 US$ | Čtení z mezipaměti≈0,00012 US$ | Zápis do mezipaměti0,0006 US$ | Mezipaměť 5 min0,0006 US$ | Mezipaměť 1 hodinaZákladní: — |
Sazby v USD za 1K tokenů. Není-li sazba nastavena, použije se zděděná základní sazba této metody; «—» znamená, že základní sazba není nastavena.
Ailoot před požadavkem rezervuje odhadovanou částku. Po výsledku vyúčtuje konečný poplatek podle naměřeného využití. Při streamování se účtování řídí konečným záznamem využití. [Jak funguje rezervace a vyúčtování →](https://ailoot.ai/docs/cs/billing/reserve/)
#### Podrobnosti referenčního tarifu
Referenční tabulky modelu nemění výběr metody, cenové nabídky ani poplatky. Skutečné poplatky používají sazby vybrané metody Ailoot.
Referenční tabulky modelu
#### Ceny podle konfigurace
Přiřaďte každý poplatek k uvedeným podmínkám. Pro každou sadu alternativních konfigurací použijte jednu sazbu.
| Konfigurace | Tabulka sazeb | Tokeny kontextu, více než | Tokeny kontextu, do uvedené hodnoty včetně | Poplatek |
| --- | --- | --- | --- | --- |
| KonfiguraceOpenAI Chat · Základní sazby za tokeny | Tabulka sazebZákladní sazba | Tokeny kontextu, více než— | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.0006** / 1K tokenů Výstup · Výstupní tokeny **$0.0024** / 1K tokenů Vstup · Čtení z mezipaměti **$0.00012** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguraceOpenAI Chat · Úroveň 1 podle délky požadavku | Tabulka sazeb— | Tokeny kontextu, více než0 | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.0006** / 1K tokenů Výstup · Výstupní tokeny **$0.0024** / 1K tokenů Vstup · Čtení z mezipaměti **$0.00012** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguraceAnthropic Messages · Základní sazby za tokeny | Tabulka sazebZákladní sazba | Tokeny kontextu, více než— | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.0006** / 1K tokenů Výstup · Výstupní tokeny **$0.0024** / 1K tokenů Vstup · Čtení z mezipaměti **$0.00012** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguraceAnthropic Messages · Úroveň 1 podle délky požadavku | Tabulka sazeb— | Tokeny kontextu, více než0 | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.0006** / 1K tokenů Výstup · Výstupní tokeny **$0.0024** / 1K tokenů Vstup · Čtení z mezipaměti **$0.00012** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
### Příklady požadavků
#### Ailoot · Anthropic Messages
Textový příkladVstup, obrázekPython SDKNode.js SDKStreamování v Pythonu
```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_TEXT_FILE:?Set your actual UTF-8 source-material file}"
export AILOOT_TEXT_FILE
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model": "minimax-latest", "max_tokens": 1024, "messages": []}')
f=Path(os.environ["AILOOT_TEXT_FILE"])
if not f.is_file():raise SystemExit("Choose your actual UTF-8 source material")
text=f.read_text(encoding="utf-8")
if not text.strip():raise SystemExit("Source material must contain text")
p["messages"]=[{"role":"user","content":"Summarize this material and quote supporting source passages.\n\n"+text}]
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/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
print(json.dumps(json.loads(Path("result.json").read_text()),ensure_ascii=False,indent=2))
PY_RESULT
```
```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_IMAGE_FILE:?Set your actual PNG JPEG or WebP image}"
export AILOOT_IMAGE_FILE
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model": "minimax-latest", "max_tokens": 1024, "messages": [{"role": "user", "content": [{"type": "text", "text": "Read labels and numbers in this image; flag unreadable text."}]}]}')
import base64
f=Path(os.environ["AILOOT_IMAGE_FILE"])
if not f.is_file():raise SystemExit("Choose an actual PNG JPEG or WebP image")
raw=f.read_bytes()
mime="image/png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "image/jpeg" if raw.startswith(b"\xff\xd8") else "image/webp" if raw[:4]==b"RIFF" and raw[8:12]==b"WEBP" else None
if not mime:raise SystemExit("Use PNG JPEG or WebP")
b64=base64.b64encode(raw).decode()
p["messages"][0]["content"].append({"type":"image","source":{"type":"base64","media_type":mime,"data":b64}})
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/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
print(json.dumps(json.loads(Path("result.json").read_text()),ensure_ascii=False,indent=2))
PY_RESULT
```
```python
import anthropic
import os
if not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")
client = anthropic.Anthropic(base_url="https://api.ailoot.ai", api_key=os.environ["AILOOT_API_KEY"], max_retries=0)
msg = client.messages.create(
model="minimax-latest",
max_tokens=1024,
messages=[{"role": "user", "content": "Explain the difference between an observation and a hypothesis 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(msg.to_dict(mode="json"))
```
```js
import Anthropic from "@anthropic-ai/sdk";
if (!process.env.AILOOT_API_KEY?.trim()) throw new Error("Set AILOOT_API_KEY before making a request");
const client = new Anthropic({ baseURL: "https://api.ailoot.ai", apiKey: process.env.AILOOT_API_KEY, maxRetries: 0 });
const msg = await client.messages.create({
model: "minimax-latest",
max_tokens: 1024,
messages: [{ role: "user", content: "Explain the difference between an observation and a hypothesis in three sentences." }],
});
import { writeFileSync } from "node:fs";
function saveResult(data, stem = "result") {
writeFileSync(stem + ".json", JSON.stringify(data, null, 2));
console.log(JSON.stringify(data, null, 2));
const saveBlob = (encoded, suffix, label) => {
const raw = Buffer.from(encoded, "base64");
const ext = raw.subarray(0,8).equals(Buffer.from([137,80,78,71,13,10,26,10])) ? "png" : raw[0]===255 && raw[1]===216 ? "jpg" : raw.subarray(0,4).toString()==="RIFF" && raw.subarray(8,12).toString()==="WEBP" ? "webp" : suffix;
const file = `${stem}-${label}.${ext}`;
writeFileSync(file, raw); console.log("Saved", file);
};
for (const [i, block] of (data.content || []).entries()) console.log("Content", i, JSON.stringify(block));
for (const choice of data.choices || []) console.log("Choice", choice.index, JSON.stringify(choice.message || choice.delta || {}));
for (const [i, item] of (data.output || []).entries()) {
console.log("Output", i, JSON.stringify(item));
if (item.type === "image_generation_call" && item.result) saveBlob(item.result, item.output_format || "bin", `output-${i}`);
}
for (const [ci, candidate] of (data.candidates || []).entries()) {
for (const [pi, part] of (candidate.content?.parts || []).entries()) {
console.log("Candidate/part", ci, pi, JSON.stringify(part));
const blob = part.inlineData || part.inline_data;
if (blob?.data) {
const mime = blob.mimeType || blob.mime_type;
const suffix = ({"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"})[mime] || "bin";
saveBlob(blob.data, suffix, `candidate-${ci}-part-${pi}`);
}
}
}
}
saveResult(msg);
```
```python
import anthropic,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=anthropic.Anthropic(base_url="https://api.ailoot.ai",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.messages.stream(model='minimax-latest',max_tokens=1024,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_message()
save_result(final.to_dict(mode="json"),"stream-result")
```
### Přijímání a ukládání výsledků
#### Ailoot · Anthropic Messages
json nebo SSE
##### Uchovejte všechny dokončené výsledky
Uchovejte každou úplnou vrácenou odpověď, soubor i část obsahu.
Zachovejte všechny bloky obsahu, podpisy uvažování a skutečná ID použití nástrojů. Sestavte všechny přírůstky bloků SSE; první textový blok není úplný výstup.
##### Pokud je nutné ověřit původní odpověď
Zachovejte ID požadavků/odpovědí a hlavičky. Není dodána obecná URL pro načtení textové úlohy.
Pole odpovědi
| Pole | Typ |
| --- | --- |
| Pole`id` | Typstring |
| Pole`model` | Typstring |
| Pole`content[]` | Typtext\|thinking\|tool\_use\|other content block |
| Pole`stop_reason` | Typstring\|null |
| Pole`usage` | Typobject |
Chyby a další kroky
| Odpověď | Podmínka | Další krok |
| --- | --- | --- |
| Odpověď400 · `invalid_request_error` | PodmínkaNeplatná povinná pole, reprezentace podkladů nebo hodnota parametru | Další krokPřed novým požadavkem na vytvoření opravte uvedená pole. |
### Aliasy
#### Aliasy modelu
Ailoot [`MiniMax-M3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=MiniMax-M3&fmt=messages), [`minimax`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax&fmt=messages), [`minimax-latest`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-latest&fmt=messages), [`minimax-text`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-text&fmt=messages), [`minimax-text-latest`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-text-latest&fmt=messages), [`minimax/minimax-m3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax%2Fminimax-m3&fmt=messages)
**Ailoot Ultra** [`MiniMax-M3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Ultra&caller=MiniMax-M3&fmt=messages), [`minimax/minimax-m3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Ultra&caller=minimax%2Fminimax-m3&fmt=messages)
#### Aliasy cest metod
`/chat/completions`
#### Související ID modelů
[`minimax/minimax-m3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax%2Fminimax-m3&fmt=messages), [`minimax/minimax-m3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Ultra&caller=minimax%2Fminimax-m3&fmt=messages), [`minimax`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax&fmt=messages), [`minimax-latest`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-latest&fmt=messages), [`minimax-text`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-text&fmt=messages), [`minimax-text-latest`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-text-latest&fmt=messages), [`MiniMax-M3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=MiniMax-M3&fmt=messages), [`MiniMax-M3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Ultra&caller=MiniMax-M3&fmt=messages)
**Ailoot · OpenAI Responses** `POST /v1/responses` `minimax-latest`
[`minimax-latest`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-latest&fmt=responses)
MiniMax /`minimax-latest`
ID modelu
- `MiniMax-M3`
- `minimax`
- `minimax-latest`
- `minimax-text`
- `minimax-text-latest`
- `minimax/minimax-m3`
### Úvod
MiniMax M3 je multimodální model pro dlouhodobou práci na kódu a agentní úlohy, který využívá MiniMax Sparse Attention a návrh pro dlouhý kontext. Uvedená chatová rozhraní Ultra přijímají text a vracejí textové odpovědi.
Přijímané vstupy
Text · Obrázky
Výsledky
Text
### Dostupné v Ailoot · vstupy a metody
**Ailoot · OpenAI Responses** `POST /v1/responses`
Vstup
`text`, `image`
Výstup
`text`
Kontext
1 000 000 tokens
Maximální výstup
1 000 000 tokens
Výstupní formát
json nebo SSE
| Pole | Typ | Požadavek | Hodnoty a limity | Výchozí |
| --- | --- | --- | --- | --- |
| Pole`model` | Typ`string` | PožadavekPovinné | Hodnoty a limity minimax-latest | Výchozí— |
| Pole`input` | Typ`string\|input_item[]` | PožadavekPovinné | Hodnoty a limity | Výchozí— |
| Pole`instructions` | Typ`string` | PožadavekVolitelné | Hodnoty a limity | Výchozí— |
| Pole`input[].type` | Typ`string` | PožadavekVolitelné | Hodnoty a limity message, reasoning, function\_call, function\_call\_output | Výchozí— |
| Pole`input[].content` | Typ`string\|content_part[]` | PožadavekVolitelné | Hodnoty a limity | Výchozí— |
| Pole`input[].call_id` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Platí, když: function\_call\_output; zachovejte skutečně vrácené call\_id | Výchozí— |
| Pole`input[].output` | Typ`string\|content_part[]` | PožadavekVolitelné | Hodnoty a limity Platí, když: function\_call\_output | Výchozí— |
| Pole`max_output_tokens` | Typ`integer` | PožadavekVolitelné | Hodnoty a limity Minimum: 1 Závisí na modelu | Výchozí— |
| Pole`stream` | Typ`boolean` | PožadavekVolitelné | Hodnoty a limity | Výchozífalse |
| Pole`temperature` | Typ`number` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`top_p` | Typ`number` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`tools` | Typ`tool[]` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`tool_choice` | Typ`string\|object` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`parallel_tool_calls` | Typ`boolean` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`reasoning.effort` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`reasoning.summary` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`text.format` | Typ`object` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`text.verbosity` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`include` | Typ`string[]` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`store` | Typ`boolean` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`previous_response_id` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Požadavek na ID: Pouze skutečné ID odpovědi z podporovaného pokračování Závisí na modelu | Výchozí— |
| Pole`service_tier` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`prompt_cache_key` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`prompt_cache_options` | Typ`object` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
Kombinace vstupních materiálů
**Text** · text UTF8
`vstupní text nebo část input_text`
**Text + obrázek**
`{type:input_image,image_url}`
Parametry a životní cyklus metody
| Parametr | Kontrakt |
| --- | --- |
| Parametr`material_types` | Kontrakttext, image |
| Parametr`required` | Kontraktmodel, input |
| Parametr`optional_controls` | Kontraktnull |
| Parametr`content_type` | Kontraktapplication/json |
| Parametr`text_file_material` | Kontraktskutečný obsah UTF-8 vložený jako text; ID/URLs souborů vyžadují samostatnou přesně vymezenou podporu |
Životní cyklus: `exact retained published method`
Struktury metod a ID jsou přesné; schopnosti dodavatele jsou oddělené od připuštění požadavku.
### Tarify
#### Sazby metod Ailoot
Vstup
0,0003 US$ */ 1K*
Výstup
0,0012 US$ */ 1K*
Čtení z mezipaměti
≈0,00006 US$ */ 1K*
Zápis do mezipaměti
0,0003 US$ */ 1K*
Zápis do mezipaměti, 5 min
0,0003 US$ */ 1K tokens*
#### Ceny podle délky požadavku · OpenAI Responses
| Velikost požadavku v tokenech | Vstup | Výstup | Čtení z mezipaměti | Zápis do mezipaměti | Mezipaměť 5 min | Mezipaměť 1 hodina |
| --- | --- | --- | --- | --- | --- | --- |
| Velikost požadavku v tokenech(0; 524 288\] | Vstup0,0003 US$ | Výstup0,0012 US$ | Čtení z mezipaměti≈0,00006 US$ | Zápis do mezipaměti0,0003 US$ | Mezipaměť 5 min0,0003 US$ | Mezipaměť 1 hodinaZákladní: — |
| Velikost požadavku v tokenech(524 288; 1 000 000\] | Vstup0,0006 US$ | Výstup0,0024 US$ | Čtení z mezipaměti≈0,00012 US$ | Zápis do mezipaměti0,0006 US$ | Mezipaměť 5 min0,0006 US$ | Mezipaměť 1 hodinaZákladní: — |
Sazby v USD za 1K tokenů. Není-li sazba nastavena, použije se zděděná základní sazba této metody; «—» znamená, že základní sazba není nastavena.
Ailoot před požadavkem rezervuje odhadovanou částku. Po výsledku vyúčtuje konečný poplatek podle naměřeného využití. Při streamování se účtování řídí konečným záznamem využití. [Jak funguje rezervace a vyúčtování →](https://ailoot.ai/docs/cs/billing/reserve/)
#### Podrobnosti referenčního tarifu
Referenční tabulky modelu nemění výběr metody, cenové nabídky ani poplatky. Skutečné poplatky používají sazby vybrané metody Ailoot.
Referenční tabulky modelu
#### Ceny podle konfigurace
Přiřaďte každý poplatek k uvedeným podmínkám. Pro každou sadu alternativních konfigurací použijte jednu sazbu.
| Konfigurace | Tabulka sazeb | Tokeny kontextu, více než | Tokeny kontextu, do uvedené hodnoty včetně | Poplatek |
| --- | --- | --- | --- | --- |
| KonfiguraceOpenAI Chat · Základní sazby za tokeny | Tabulka sazebZákladní sazba | Tokeny kontextu, více než— | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.0006** / 1K tokenů Výstup · Výstupní tokeny **$0.0024** / 1K tokenů Vstup · Čtení z mezipaměti **$0.00012** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguraceOpenAI Chat · Úroveň 1 podle délky požadavku | Tabulka sazeb— | Tokeny kontextu, více než0 | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.0006** / 1K tokenů Výstup · Výstupní tokeny **$0.0024** / 1K tokenů Vstup · Čtení z mezipaměti **$0.00012** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguraceAnthropic Messages · Základní sazby za tokeny | Tabulka sazebZákladní sazba | Tokeny kontextu, více než— | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.0006** / 1K tokenů Výstup · Výstupní tokeny **$0.0024** / 1K tokenů Vstup · Čtení z mezipaměti **$0.00012** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguraceAnthropic Messages · Úroveň 1 podle délky požadavku | Tabulka sazeb— | Tokeny kontextu, více než0 | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.0006** / 1K tokenů Výstup · Výstupní tokeny **$0.0024** / 1K tokenů Vstup · Čtení z mezipaměti **$0.00012** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
### Příklady požadavků
#### Ailoot · OpenAI Responses
Textový příkladVstup, obrázekPython SDKNode.js SDKStreamování v Pythonu
```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_TEXT_FILE:?Set your actual UTF-8 source-material file}"
export AILOOT_TEXT_FILE
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model": "minimax-latest", "input": ""}')
f=Path(os.environ["AILOOT_TEXT_FILE"])
if not f.is_file():raise SystemExit("Choose your actual UTF-8 source material")
text=f.read_text(encoding="utf-8")
if not text.strip():raise SystemExit("Source material must contain text")
p["input"]="Summarize this material and quote supporting source passages.\n\n"+text
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/responses \
-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 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(json.loads(Path("result.json").read_text(encoding="utf-8")))
PY_RESULT
```
```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_IMAGE_FILE:?Set your actual PNG JPEG or WebP image}"
export AILOOT_IMAGE_FILE
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model": "minimax-latest", "input": [{"role": "user", "content": [{"type": "input_text", "text": "Read labels and numbers in this image; flag unreadable text."}]}]}')
import base64
f=Path(os.environ["AILOOT_IMAGE_FILE"])
if not f.is_file():raise SystemExit("Choose an actual PNG JPEG or WebP image")
raw=f.read_bytes()
mime="image/png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "image/jpeg" if raw.startswith(b"\xff\xd8") else "image/webp" if raw[:4]==b"RIFF" and raw[8:12]==b"WEBP" else None
if not mime:raise SystemExit("Use PNG JPEG or WebP")
b64=base64.b64encode(raw).decode()
p["input"][0]["content"].append({"type":"input_image","image_url":"data:"+mime+";base64,"+b64})
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/responses \
-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 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(json.loads(Path("result.json").read_text(encoding="utf-8")))
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)
resp = client.responses.create(model="minimax-latest", input="Explain the difference between an observation and a hypothesis 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(resp.to_dict(mode="json"))
```
```js
import OpenAI from "openai";
if (!process.env.AILOOT_API_KEY?.trim()) throw new Error("Set AILOOT_API_KEY before making a request");
const client = new OpenAI({ baseURL: "https://api.ailoot.ai/v1", apiKey: process.env.AILOOT_API_KEY, maxRetries: 0 });
const resp = await client.responses.create({ model: "minimax-latest", input: "Explain the difference between an observation and a hypothesis in three sentences." });
import { writeFileSync } from "node:fs";
function saveResult(data, stem = "result") {
writeFileSync(stem + ".json", JSON.stringify(data, null, 2));
console.log(JSON.stringify(data, null, 2));
const saveBlob = (encoded, suffix, label) => {
const raw = Buffer.from(encoded, "base64");
const ext = raw.subarray(0,8).equals(Buffer.from([137,80,78,71,13,10,26,10])) ? "png" : raw[0]===255 && raw[1]===216 ? "jpg" : raw.subarray(0,4).toString()==="RIFF" && raw.subarray(8,12).toString()==="WEBP" ? "webp" : suffix;
const file = `${stem}-${label}.${ext}`;
writeFileSync(file, raw); console.log("Saved", file);
};
for (const [i, block] of (data.content || []).entries()) console.log("Content", i, JSON.stringify(block));
for (const choice of data.choices || []) console.log("Choice", choice.index, JSON.stringify(choice.message || choice.delta || {}));
for (const [i, item] of (data.output || []).entries()) {
console.log("Output", i, JSON.stringify(item));
if (item.type === "image_generation_call" && item.result) saveBlob(item.result, item.output_format || "bin", `output-${i}`);
}
for (const [ci, candidate] of (data.candidates || []).entries()) {
for (const [pi, part] of (candidate.content?.parts || []).entries()) {
console.log("Candidate/part", ci, pi, JSON.stringify(part));
const blob = part.inlineData || part.inline_data;
if (blob?.data) {
const mime = blob.mimeType || blob.mime_type;
const suffix = ({"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"})[mime] || "bin";
saveBlob(blob.data, suffix, `candidate-${ci}-part-${pi}`);
}
}
}
}
saveResult(resp);
```
```python
from openai import OpenAI
import os
from pathlib import Path
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))
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)
with client.responses.stream(model="minimax-latest", input="Explain the difference between an observation and a hypothesis 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_response()
save_result(final.to_dict(mode="json"),"stream-result")
```
### Přijímání a ukládání výsledků
#### Ailoot · OpenAI Responses
json nebo SSE
##### Uchovejte všechny dokončené výsledky
Uchovejte každou úplnou vrácenou odpověď, soubor i část obsahu.
Zachovejte každou výstupní položku a část obsahu, skutečné call\_id funkce, šifrované uvažování a údaje o využití. Při streamování uchovejte úplnou identitu události/položky.
##### Pokud je nutné ověřit původní odpověď
Zachovejte ID požadavků/odpovědí a hlavičky. Není dodána obecná URL pro načtení textové úlohy.
Pole odpovědi
| Pole | Typ |
| --- | --- |
| Pole`id` | Typstring |
| Pole`status` | Typstring |
| Pole`output[]` | Typmessage\|reasoning\|function\_call\|other item |
| Pole`output[].content[]` | Typcontent part |
| Pole`usage` | Typobject |
Chyby a další kroky
| Odpověď | Podmínka | Další krok |
| --- | --- | --- |
| Odpověď400 · `invalid_request_error` | PodmínkaNeplatná povinná pole, reprezentace podkladů nebo hodnota parametru | Další krokPřed novým požadavkem na vytvoření opravte uvedená pole. |
### Aliasy
#### Aliasy modelu
Ailoot [`MiniMax-M3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=MiniMax-M3&fmt=responses), [`minimax`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax&fmt=responses), [`minimax-latest`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-latest&fmt=responses), [`minimax-text`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-text&fmt=responses), [`minimax-text-latest`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-text-latest&fmt=responses), [`minimax/minimax-m3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax%2Fminimax-m3&fmt=responses)
**Ailoot Ultra** [`MiniMax-M3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Ultra&caller=MiniMax-M3), [`minimax/minimax-m3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Ultra&caller=minimax%2Fminimax-m3)
#### Aliasy cest metod
`/chat/completions`
#### Související ID modelů
[`minimax/minimax-m3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax%2Fminimax-m3&fmt=responses), [`minimax/minimax-m3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Ultra&caller=minimax%2Fminimax-m3), [`minimax`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax&fmt=responses), [`minimax-latest`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-latest&fmt=responses), [`minimax-text`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-text&fmt=responses), [`minimax-text-latest`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-text-latest&fmt=responses), [`MiniMax-M3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=MiniMax-M3&fmt=responses), [`MiniMax-M3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Ultra&caller=MiniMax-M3)
**Ailoot · OpenAI Chat** `POST /v1/chat/completions` `minimax-latest`
[`minimax-latest`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-latest&fmt=chat)
MiniMax /`minimax-latest`
ID modelu
- `MiniMax-M3`
- `minimax`
- `minimax-latest`
- `minimax-text`
- `minimax-text-latest`
- `minimax/minimax-m3`
### Úvod
MiniMax M3 je multimodální model pro dlouhodobou práci na kódu a agentní úlohy, který využívá MiniMax Sparse Attention a návrh pro dlouhý kontext. Uvedená chatová rozhraní Ultra přijímají text a vracejí textové odpovědi.
Přijímané vstupy
Text · Obrázky
Výsledky
Text
### Dostupné v Ailoot · vstupy a metody
**Ailoot · OpenAI Chat** `POST /v1/chat/completions`
Vstup
`text`, `image`
Výstup
`text`
Kontext
1 000 000 tokens
Maximální výstup
524 288 tokens
Výstupní formát
json nebo SSE
| Pole | Typ | Požadavek | Hodnoty a limity | Výchozí |
| --- | --- | --- | --- | --- |
| Pole`model` | Typ`string` | PožadavekPovinné | Hodnoty a limity minimax-latest | Výchozí— |
| Pole`messages` | Typ`message[]` | PožadavekPovinné | Hodnoty a limity Minimální počet položek: 1 | Výchozí— |
| Pole`messages[].role` | Typ`string` | PožadavekPovinné | Hodnoty a limity Příklady: system, user, assistant, tool, function Podmínky: Tyto role jsou výslovně zastoupeny typy kompatibility zdrojového kódu; přesná sada rolí zůstává specifická pro daný model. Závisí na modelu | Výchozí— |
| Pole`messages[].content` | Typ`string\|content_part[]\|null` | PožadavekVolitelné | Hodnoty a limity | Výchozí— |
| Pole`messages[].tool_calls` | Typ`tool_call[]` | PožadavekVolitelné | Hodnoty a limity | Výchozí— |
| Pole`messages[].tool_call_id` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Platí, když: role=tool; použijte skutečně vrácené ID | Výchozí— |
| Pole`messages[].name` | Typ`string` | PožadavekVolitelné | Hodnoty a limity | Výchozí— |
| Pole`messages[].reasoning_content` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Platí, když: Předávejte zpět skutečně vrácené uvažování tam, kde je tento model používá | Výchozí— |
| Pole`messages[].reasoning_details` | Typ`object\|array` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`max_tokens` | Typ`integer` | PožadavekVolitelné | Hodnoty a limity Minimum: 1 Závisí na modelu | Výchozí— |
| Pole`max_completion_tokens` | Typ`integer` | PožadavekVolitelné | Hodnoty a limity Minimum: 1 Závisí na modelu | Výchozí— |
| Pole`stream` | Typ`boolean` | PožadavekVolitelné | Hodnoty a limity | Výchozífalse |
| Pole`stream_options.include_usage` | Typ`boolean` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`temperature` | Typ`number` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`top_p` | Typ`number` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`stop` | Typ`string\|string[]` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`tools` | Typ`function_tool[]` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`tools[].type` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`tools[].function.name` | Typ`string` | PožadavekPovinné | Hodnoty a limity Platí, když: nástroj typu funkce je dodán | Výchozí— |
| Pole`tools[].function.description` | Typ`string` | PožadavekVolitelné | Hodnoty a limity | Výchozí— |
| Pole`tools[].function.parameters` | Typ`JSON_schema` | PožadavekVolitelné | Hodnoty a limity | Výchozí— |
| Pole`tool_choice` | Typ`string\|object` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`parallel_tool_calls` | Typ`boolean` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`response_format` | Typ`object` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`reasoning_effort` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`reasoning` | Typ`object` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`service_tier` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`instructions` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Pole kompatibility | Výchozí— |
| Pole`functions` | Typ`function[]` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`function_call` | Typ`string\|object` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`prompt_cache_options` | Typ`object` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
Kombinace vstupních materiálů
**Text** · text UTF8
`messages[].content`
**Text + obrázek**
`{type:image_url,image_url:{url,detail}}`
Parametry a životní cyklus metody
| Parametr | Kontrakt |
| --- | --- |
| Parametr`material_types` | Kontrakttext, image |
| Parametr`required` | Kontraktmodel, messages |
| Parametr`optional_controls` | Kontraktnull |
| Parametr`content_type` | Kontraktapplication/json |
| Parametr`text_file_material` | Kontraktskutečný obsah UTF-8 vložený jako text; ID/URLs souborů vyžadují samostatnou přesně vymezenou podporu |
Životní cyklus: `exact retained published method`
Struktury metod a ID jsou přesné; schopnosti dodavatele jsou oddělené od připuštění požadavku.
### Tarify
#### Sazby metod Ailoot
Vstup
0,0003 US$ */ 1K*
Výstup
0,0012 US$ */ 1K*
Čtení z mezipaměti
≈0,00006 US$ */ 1K*
Zápis do mezipaměti
0,0003 US$ */ 1K*
Zápis do mezipaměti, 5 min
0,0003 US$ */ 1K tokens*
#### Ceny podle délky požadavku · OpenAI Chat
| Velikost požadavku v tokenech | Vstup | Výstup | Čtení z mezipaměti | Zápis do mezipaměti | Mezipaměť 5 min | Mezipaměť 1 hodina |
| --- | --- | --- | --- | --- | --- | --- |
| Velikost požadavku v tokenech(0; 524 288\] | Vstup0,0003 US$ | Výstup0,0012 US$ | Čtení z mezipaměti≈0,00006 US$ | Zápis do mezipaměti0,0003 US$ | Mezipaměť 5 min0,0003 US$ | Mezipaměť 1 hodinaZákladní: — |
| Velikost požadavku v tokenech(524 288; 1 000 000\] | Vstup0,0006 US$ | Výstup0,0024 US$ | Čtení z mezipaměti≈0,00012 US$ | Zápis do mezipaměti0,0006 US$ | Mezipaměť 5 min0,0006 US$ | Mezipaměť 1 hodinaZákladní: — |
Sazby v USD za 1K tokenů. Není-li sazba nastavena, použije se zděděná základní sazba této metody; «—» znamená, že základní sazba není nastavena.
Ailoot před požadavkem rezervuje odhadovanou částku. Po výsledku vyúčtuje konečný poplatek podle naměřeného využití. Při streamování se účtování řídí konečným záznamem využití. [Jak funguje rezervace a vyúčtování →](https://ailoot.ai/docs/cs/billing/reserve/)
#### Podrobnosti referenčního tarifu
Referenční tabulky modelu nemění výběr metody, cenové nabídky ani poplatky. Skutečné poplatky používají sazby vybrané metody Ailoot.
Referenční tabulky modelu
#### Ceny podle konfigurace
Přiřaďte každý poplatek k uvedeným podmínkám. Pro každou sadu alternativních konfigurací použijte jednu sazbu.
| Konfigurace | Tabulka sazeb | Tokeny kontextu, více než | Tokeny kontextu, do uvedené hodnoty včetně | Poplatek |
| --- | --- | --- | --- | --- |
| KonfiguraceOpenAI Chat · Základní sazby za tokeny | Tabulka sazebZákladní sazba | Tokeny kontextu, více než— | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.0006** / 1K tokenů Výstup · Výstupní tokeny **$0.0024** / 1K tokenů Vstup · Čtení z mezipaměti **$0.00012** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguraceOpenAI Chat · Úroveň 1 podle délky požadavku | Tabulka sazeb— | Tokeny kontextu, více než0 | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.0006** / 1K tokenů Výstup · Výstupní tokeny **$0.0024** / 1K tokenů Vstup · Čtení z mezipaměti **$0.00012** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguraceAnthropic Messages · Základní sazby za tokeny | Tabulka sazebZákladní sazba | Tokeny kontextu, více než— | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.0006** / 1K tokenů Výstup · Výstupní tokeny **$0.0024** / 1K tokenů Vstup · Čtení z mezipaměti **$0.00012** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguraceAnthropic Messages · Úroveň 1 podle délky požadavku | Tabulka sazeb— | Tokeny kontextu, více než0 | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.0006** / 1K tokenů Výstup · Výstupní tokeny **$0.0024** / 1K tokenů Vstup · Čtení z mezipaměti **$0.00012** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
### Příklady požadavků
#### Ailoot · OpenAI Chat
Textový příkladVstup, obrázekPython SDKNode.js SDKStreamování v Pythonu
```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_TEXT_FILE:?Set your actual UTF-8 source-material file}"
export AILOOT_TEXT_FILE
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model": "minimax-latest", "messages": []}')
f=Path(os.environ["AILOOT_TEXT_FILE"])
if not f.is_file():raise SystemExit("Choose your actual UTF-8 source material")
text=f.read_text(encoding="utf-8")
if not text.strip():raise SystemExit("Source material must contain text")
p["messages"]=[{"role":"user","content":"Summarize this material and quote supporting source passages.\n\n"+text}]
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
print(json.dumps(json.loads(Path("result.json").read_text()),ensure_ascii=False,indent=2))
PY_RESULT
```
```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_IMAGE_FILE:?Set your actual PNG JPEG or WebP image}"
export AILOOT_IMAGE_FILE
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model": "minimax-latest", "messages": [{"role": "user", "content": [{"type": "text", "text": "Read labels and numbers in this image; flag unreadable text."}]}]}')
import base64
f=Path(os.environ["AILOOT_IMAGE_FILE"])
if not f.is_file():raise SystemExit("Choose an actual PNG JPEG or WebP image")
raw=f.read_bytes()
mime="image/png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "image/jpeg" if raw.startswith(b"\xff\xd8") else "image/webp" if raw[:4]==b"RIFF" and raw[8:12]==b"WEBP" else None
if not mime:raise SystemExit("Use PNG JPEG or WebP")
b64=base64.b64encode(raw).decode()
p["messages"][0]["content"].append({"type":"image_url","image_url":{"url":"data:"+mime+";base64,"+b64}})
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
print(json.dumps(json.loads(Path("result.json").read_text()),ensure_ascii=False,indent=2))
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)
resp = client.chat.completions.create(
model="minimax-latest",
messages=[{"role": "user", "content": "Explain the difference between an observation and a hypothesis 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(resp.to_dict(mode="json"))
```
```js
import OpenAI from "openai";
if (!process.env.AILOOT_API_KEY?.trim()) throw new Error("Set AILOOT_API_KEY before making a request");
const client = new OpenAI({ baseURL: "https://api.ailoot.ai/v1", apiKey: process.env.AILOOT_API_KEY, maxRetries: 0 });
const resp = await client.chat.completions.create({
model: "minimax-latest",
messages: [{ role: "user", content: "Explain the difference between an observation and a hypothesis in three sentences." }],
});
import { writeFileSync } from "node:fs";
function saveResult(data, stem = "result") {
writeFileSync(stem + ".json", JSON.stringify(data, null, 2));
console.log(JSON.stringify(data, null, 2));
const saveBlob = (encoded, suffix, label) => {
const raw = Buffer.from(encoded, "base64");
const ext = raw.subarray(0,8).equals(Buffer.from([137,80,78,71,13,10,26,10])) ? "png" : raw[0]===255 && raw[1]===216 ? "jpg" : raw.subarray(0,4).toString()==="RIFF" && raw.subarray(8,12).toString()==="WEBP" ? "webp" : suffix;
const file = `${stem}-${label}.${ext}`;
writeFileSync(file, raw); console.log("Saved", file);
};
for (const [i, block] of (data.content || []).entries()) console.log("Content", i, JSON.stringify(block));
for (const choice of data.choices || []) console.log("Choice", choice.index, JSON.stringify(choice.message || choice.delta || {}));
for (const [i, item] of (data.output || []).entries()) {
console.log("Output", i, JSON.stringify(item));
if (item.type === "image_generation_call" && item.result) saveBlob(item.result, item.output_format || "bin", `output-${i}`);
}
for (const [ci, candidate] of (data.candidates || []).entries()) {
for (const [pi, part] of (candidate.content?.parts || []).entries()) {
console.log("Candidate/part", ci, pi, JSON.stringify(part));
const blob = part.inlineData || part.inline_data;
if (blob?.data) {
const mime = blob.mimeType || blob.mime_type;
const suffix = ({"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"})[mime] || "bin";
saveBlob(blob.data, suffix, `candidate-${ci}-part-${pi}`);
}
}
}
}
saveResult(resp);
```
```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='minimax-latest',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")
```
### Přijímání a ukládání výsledků
#### Ailoot · OpenAI Chat
json nebo SSE
##### Uchovejte všechny dokončené výsledky
Uchovejte každou úplnou vrácenou odpověď, soubor i část obsahu.
Zachovejte každou volbu a její obsah/volání nástrojů/uvažování. V SSE sestavujte přírůstky podle indexu volby/nástroje a zachovejte konečný důvod ukončení i údaje o využití.
##### Pokud je nutné ověřit původní odpověď
Zachovejte ID požadavků/odpovědí a hlavičky. Není dodána obecná URL pro načtení textové úlohy.
Pole odpovědi
| Pole | Typ |
| --- | --- |
| Pole`choices[].index` | Typinteger |
| Pole`choices[].message.content` | Typstring\|null |
| Pole`choices[].message.tool_calls` | Typtool\_call\[\] |
| Pole`choices[].message.reasoning_content` | Typstring |
| Pole`choices[].message.reasoning_details` | Typobject\|array |
| Pole`choices[].finish_reason` | Typstring\|null |
| Pole`usage` | Typobject |
Chyby a další kroky
| Odpověď | Podmínka | Další krok |
| --- | --- | --- |
| Odpověď400 · `invalid_request_error` | PodmínkaNeplatná povinná pole, reprezentace podkladů nebo hodnota parametru | Další krokPřed novým požadavkem na vytvoření opravte uvedená pole. |
### Aliasy
#### Aliasy modelu
Ailoot [`MiniMax-M3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=MiniMax-M3&fmt=chat), [`minimax`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax&fmt=chat), [`minimax-latest`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-latest&fmt=chat), [`minimax-text`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-text&fmt=chat), [`minimax-text-latest`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-text-latest&fmt=chat), [`minimax/minimax-m3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax%2Fminimax-m3&fmt=chat)
**Ailoot Ultra** [`MiniMax-M3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Ultra&caller=MiniMax-M3&fmt=chat), [`minimax/minimax-m3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Ultra&caller=minimax%2Fminimax-m3&fmt=chat)
#### Aliasy cest metod
`/chat/completions`
#### Související ID modelů
[`minimax/minimax-m3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax%2Fminimax-m3&fmt=chat), [`minimax/minimax-m3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Ultra&caller=minimax%2Fminimax-m3&fmt=chat), [`minimax`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax&fmt=chat), [`minimax-latest`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-latest&fmt=chat), [`minimax-text`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-text&fmt=chat), [`minimax-text-latest`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-text-latest&fmt=chat), [`MiniMax-M3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=MiniMax-M3&fmt=chat), [`MiniMax-M3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Ultra&caller=MiniMax-M3&fmt=chat)
**Ailoot · Anthropic Messages** `POST /v1/messages` `minimax-text`
[`minimax-text`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-text&fmt=messages)
MiniMax /`minimax-text`
ID modelu
- `MiniMax-M3`
- `minimax`
- `minimax-latest`
- `minimax-text`
- `minimax-text-latest`
- `minimax/minimax-m3`
### Úvod
MiniMax M3 je multimodální model pro dlouhodobou práci na kódu a agentní úlohy, který využívá MiniMax Sparse Attention a návrh pro dlouhý kontext. Uvedená chatová rozhraní Ultra přijímají text a vracejí textové odpovědi.
Přijímané vstupy
Text · Obrázky
Výsledky
Text
### Dostupné v Ailoot · vstupy a metody
**Ailoot · Anthropic Messages** `POST /v1/messages`
Vstup
`text`, `image`
Výstup
`text`
Kontext
1 000 000 tokens
Maximální výstup
524 288 tokens
Výstupní formát
json nebo SSE
| Pole | Typ | Požadavek | Hodnoty a limity | Výchozí |
| --- | --- | --- | --- | --- |
| Pole`model` | Typ`string` | PožadavekPovinné | Hodnoty a limity minimax-text | Výchozí— |
| Pole`messages` | Typ`message[]` | PožadavekPovinné | Hodnoty a limity Minimální počet položek: 1 | Výchozí— |
| Pole`messages[].role` | Typ`string` | PožadavekPovinné | Hodnoty a limity user, assistant | Výchozí— |
| Pole`messages[].content` | Typ`string\|content_block[]` | PožadavekPovinné | Hodnoty a limity | Výchozí— |
| Pole`system` | Typ`string\|content_block[]` | PožadavekVolitelné | Hodnoty a limity | Výchozí— |
| Pole`max_tokens` | Typ`integer` | PožadavekPovinné | Hodnoty a limity Minimum: 1 Limit platí pro: přesný limit vybraného modelu/karty | Výchozí— |
| Pole`stream` | Typ`boolean` | PožadavekVolitelné | Hodnoty a limity | Výchozífalse |
| Pole`temperature` | Typ`number` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`top_p` | Typ`number` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`stop_sequences` | Typ`string[]` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`tools` | Typ`tool[]` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`tools[].name` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Platí, když: nástroj je dodán | Výchozí— |
| Pole`tools[].description` | Typ`string` | PožadavekVolitelné | Hodnoty a limity | Výchozí— |
| Pole`tools[].input_schema` | Typ`JSON_schema` | PožadavekVolitelné | Hodnoty a limity | Výchozí— |
| Pole`tool_choice` | Typ`object` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`thinking.type` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`thinking.budget_tokens` | Typ`integer` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`output_config.effort` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`metadata` | Typ`object` | PožadavekVolitelné | Hodnoty a limity | Výchozí— |
| Pole`cache_control` | Typ`object` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
Kombinace vstupních materiálů
**Text** · text UTF8
`messages[].content nebo blok type=text`
**Text + obrázek**
`{type:image,source:{type:base64,media_type,data}} nebo zdroj type=url`
Parametry a životní cyklus metody
| Parametr | Kontrakt |
| --- | --- |
| Parametr`material_types` | Kontrakttext, image |
| Parametr`required` | Kontraktmodel, messages, max\_tokens |
| Parametr`optional_controls` | Kontraktnull |
| Parametr`content_type` | Kontraktapplication/json |
| Parametr`text_file_material` | Kontraktskutečný obsah UTF-8 vložený jako text; ID/URLs souborů vyžadují samostatnou přesně vymezenou podporu |
Životní cyklus: `exact retained published method`
Struktury metod a ID jsou přesné; schopnosti dodavatele jsou oddělené od připuštění požadavku.
### Tarify
#### Sazby metod Ailoot
Vstup
0,0003 US$ */ 1K*
Výstup
0,0012 US$ */ 1K*
Čtení z mezipaměti
≈0,00006 US$ */ 1K*
Zápis do mezipaměti
0,0003 US$ */ 1K*
Zápis do mezipaměti, 5 min
0,0003 US$ */ 1K tokens*
#### Ceny podle délky požadavku · Anthropic Messages
| Velikost požadavku v tokenech | Vstup | Výstup | Čtení z mezipaměti | Zápis do mezipaměti | Mezipaměť 5 min | Mezipaměť 1 hodina |
| --- | --- | --- | --- | --- | --- | --- |
| Velikost požadavku v tokenech(0; 524 288\] | Vstup0,0003 US$ | Výstup0,0012 US$ | Čtení z mezipaměti≈0,00006 US$ | Zápis do mezipaměti0,0003 US$ | Mezipaměť 5 min0,0003 US$ | Mezipaměť 1 hodinaZákladní: — |
| Velikost požadavku v tokenech(524 288; 1 000 000\] | Vstup0,0006 US$ | Výstup0,0024 US$ | Čtení z mezipaměti≈0,00012 US$ | Zápis do mezipaměti0,0006 US$ | Mezipaměť 5 min0,0006 US$ | Mezipaměť 1 hodinaZákladní: — |
Sazby v USD za 1K tokenů. Není-li sazba nastavena, použije se zděděná základní sazba této metody; «—» znamená, že základní sazba není nastavena.
Ailoot před požadavkem rezervuje odhadovanou částku. Po výsledku vyúčtuje konečný poplatek podle naměřeného využití. Při streamování se účtování řídí konečným záznamem využití. [Jak funguje rezervace a vyúčtování →](https://ailoot.ai/docs/cs/billing/reserve/)
#### Podrobnosti referenčního tarifu
Referenční tabulky modelu nemění výběr metody, cenové nabídky ani poplatky. Skutečné poplatky používají sazby vybrané metody Ailoot.
Referenční tabulky modelu
#### Ceny podle konfigurace
Přiřaďte každý poplatek k uvedeným podmínkám. Pro každou sadu alternativních konfigurací použijte jednu sazbu.
| Konfigurace | Tabulka sazeb | Tokeny kontextu, více než | Tokeny kontextu, do uvedené hodnoty včetně | Poplatek |
| --- | --- | --- | --- | --- |
| KonfiguraceOpenAI Chat · Základní sazby za tokeny | Tabulka sazebZákladní sazba | Tokeny kontextu, více než— | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.0006** / 1K tokenů Výstup · Výstupní tokeny **$0.0024** / 1K tokenů Vstup · Čtení z mezipaměti **$0.00012** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguraceOpenAI Chat · Úroveň 1 podle délky požadavku | Tabulka sazeb— | Tokeny kontextu, více než0 | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.0006** / 1K tokenů Výstup · Výstupní tokeny **$0.0024** / 1K tokenů Vstup · Čtení z mezipaměti **$0.00012** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguraceAnthropic Messages · Základní sazby za tokeny | Tabulka sazebZákladní sazba | Tokeny kontextu, více než— | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.0006** / 1K tokenů Výstup · Výstupní tokeny **$0.0024** / 1K tokenů Vstup · Čtení z mezipaměti **$0.00012** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguraceAnthropic Messages · Úroveň 1 podle délky požadavku | Tabulka sazeb— | Tokeny kontextu, více než0 | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.0006** / 1K tokenů Výstup · Výstupní tokeny **$0.0024** / 1K tokenů Vstup · Čtení z mezipaměti **$0.00012** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
### Příklady požadavků
#### Ailoot · Anthropic Messages
Textový příkladVstup, obrázekPython SDKNode.js SDKStreamování v Pythonu
```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_TEXT_FILE:?Set your actual UTF-8 source-material file}"
export AILOOT_TEXT_FILE
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model": "minimax-text", "max_tokens": 1024, "messages": []}')
f=Path(os.environ["AILOOT_TEXT_FILE"])
if not f.is_file():raise SystemExit("Choose your actual UTF-8 source material")
text=f.read_text(encoding="utf-8")
if not text.strip():raise SystemExit("Source material must contain text")
p["messages"]=[{"role":"user","content":"Summarize this material and quote supporting source passages.\n\n"+text}]
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/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
print(json.dumps(json.loads(Path("result.json").read_text()),ensure_ascii=False,indent=2))
PY_RESULT
```
```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_IMAGE_FILE:?Set your actual PNG JPEG or WebP image}"
export AILOOT_IMAGE_FILE
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model": "minimax-text", "max_tokens": 1024, "messages": [{"role": "user", "content": [{"type": "text", "text": "Read labels and numbers in this image; flag unreadable text."}]}]}')
import base64
f=Path(os.environ["AILOOT_IMAGE_FILE"])
if not f.is_file():raise SystemExit("Choose an actual PNG JPEG or WebP image")
raw=f.read_bytes()
mime="image/png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "image/jpeg" if raw.startswith(b"\xff\xd8") else "image/webp" if raw[:4]==b"RIFF" and raw[8:12]==b"WEBP" else None
if not mime:raise SystemExit("Use PNG JPEG or WebP")
b64=base64.b64encode(raw).decode()
p["messages"][0]["content"].append({"type":"image","source":{"type":"base64","media_type":mime,"data":b64}})
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/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
print(json.dumps(json.loads(Path("result.json").read_text()),ensure_ascii=False,indent=2))
PY_RESULT
```
```python
import anthropic
import os
if not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")
client = anthropic.Anthropic(base_url="https://api.ailoot.ai", api_key=os.environ["AILOOT_API_KEY"], max_retries=0)
msg = client.messages.create(
model="minimax-text",
max_tokens=1024,
messages=[{"role": "user", "content": "Explain the difference between an observation and a hypothesis 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(msg.to_dict(mode="json"))
```
```js
import Anthropic from "@anthropic-ai/sdk";
if (!process.env.AILOOT_API_KEY?.trim()) throw new Error("Set AILOOT_API_KEY before making a request");
const client = new Anthropic({ baseURL: "https://api.ailoot.ai", apiKey: process.env.AILOOT_API_KEY, maxRetries: 0 });
const msg = await client.messages.create({
model: "minimax-text",
max_tokens: 1024,
messages: [{ role: "user", content: "Explain the difference between an observation and a hypothesis in three sentences." }],
});
import { writeFileSync } from "node:fs";
function saveResult(data, stem = "result") {
writeFileSync(stem + ".json", JSON.stringify(data, null, 2));
console.log(JSON.stringify(data, null, 2));
const saveBlob = (encoded, suffix, label) => {
const raw = Buffer.from(encoded, "base64");
const ext = raw.subarray(0,8).equals(Buffer.from([137,80,78,71,13,10,26,10])) ? "png" : raw[0]===255 && raw[1]===216 ? "jpg" : raw.subarray(0,4).toString()==="RIFF" && raw.subarray(8,12).toString()==="WEBP" ? "webp" : suffix;
const file = `${stem}-${label}.${ext}`;
writeFileSync(file, raw); console.log("Saved", file);
};
for (const [i, block] of (data.content || []).entries()) console.log("Content", i, JSON.stringify(block));
for (const choice of data.choices || []) console.log("Choice", choice.index, JSON.stringify(choice.message || choice.delta || {}));
for (const [i, item] of (data.output || []).entries()) {
console.log("Output", i, JSON.stringify(item));
if (item.type === "image_generation_call" && item.result) saveBlob(item.result, item.output_format || "bin", `output-${i}`);
}
for (const [ci, candidate] of (data.candidates || []).entries()) {
for (const [pi, part] of (candidate.content?.parts || []).entries()) {
console.log("Candidate/part", ci, pi, JSON.stringify(part));
const blob = part.inlineData || part.inline_data;
if (blob?.data) {
const mime = blob.mimeType || blob.mime_type;
const suffix = ({"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"})[mime] || "bin";
saveBlob(blob.data, suffix, `candidate-${ci}-part-${pi}`);
}
}
}
}
saveResult(msg);
```
```python
import anthropic,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=anthropic.Anthropic(base_url="https://api.ailoot.ai",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.messages.stream(model='minimax-text',max_tokens=1024,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_message()
save_result(final.to_dict(mode="json"),"stream-result")
```
### Přijímání a ukládání výsledků
#### Ailoot · Anthropic Messages
json nebo SSE
##### Uchovejte všechny dokončené výsledky
Uchovejte každou úplnou vrácenou odpověď, soubor i část obsahu.
Zachovejte všechny bloky obsahu, podpisy uvažování a skutečná ID použití nástrojů. Sestavte všechny přírůstky bloků SSE; první textový blok není úplný výstup.
##### Pokud je nutné ověřit původní odpověď
Zachovejte ID požadavků/odpovědí a hlavičky. Není dodána obecná URL pro načtení textové úlohy.
Pole odpovědi
| Pole | Typ |
| --- | --- |
| Pole`id` | Typstring |
| Pole`model` | Typstring |
| Pole`content[]` | Typtext\|thinking\|tool\_use\|other content block |
| Pole`stop_reason` | Typstring\|null |
| Pole`usage` | Typobject |
Chyby a další kroky
| Odpověď | Podmínka | Další krok |
| --- | --- | --- |
| Odpověď400 · `invalid_request_error` | PodmínkaNeplatná povinná pole, reprezentace podkladů nebo hodnota parametru | Další krokPřed novým požadavkem na vytvoření opravte uvedená pole. |
### Aliasy
#### Aliasy modelu
Ailoot [`MiniMax-M3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=MiniMax-M3&fmt=messages), [`minimax`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax&fmt=messages), [`minimax-latest`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-latest&fmt=messages), [`minimax-text`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-text&fmt=messages), [`minimax-text-latest`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-text-latest&fmt=messages), [`minimax/minimax-m3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax%2Fminimax-m3&fmt=messages)
**Ailoot Ultra** [`MiniMax-M3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Ultra&caller=MiniMax-M3&fmt=messages), [`minimax/minimax-m3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Ultra&caller=minimax%2Fminimax-m3&fmt=messages)
#### Aliasy cest metod
`/chat/completions`
#### Související ID modelů
[`minimax/minimax-m3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax%2Fminimax-m3&fmt=messages), [`minimax/minimax-m3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Ultra&caller=minimax%2Fminimax-m3&fmt=messages), [`minimax`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax&fmt=messages), [`minimax-latest`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-latest&fmt=messages), [`minimax-text`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-text&fmt=messages), [`minimax-text-latest`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-text-latest&fmt=messages), [`MiniMax-M3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=MiniMax-M3&fmt=messages), [`MiniMax-M3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Ultra&caller=MiniMax-M3&fmt=messages)
**Ailoot · OpenAI Responses** `POST /v1/responses` `minimax-text`
[`minimax-text`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-text&fmt=responses)
MiniMax /`minimax-text`
ID modelu
- `MiniMax-M3`
- `minimax`
- `minimax-latest`
- `minimax-text`
- `minimax-text-latest`
- `minimax/minimax-m3`
### Úvod
MiniMax M3 je multimodální model pro dlouhodobou práci na kódu a agentní úlohy, který využívá MiniMax Sparse Attention a návrh pro dlouhý kontext. Uvedená chatová rozhraní Ultra přijímají text a vracejí textové odpovědi.
Přijímané vstupy
Text · Obrázky
Výsledky
Text
### Dostupné v Ailoot · vstupy a metody
**Ailoot · OpenAI Responses** `POST /v1/responses`
Vstup
`text`, `image`
Výstup
`text`
Kontext
1 000 000 tokens
Maximální výstup
1 000 000 tokens
Výstupní formát
json nebo SSE
| Pole | Typ | Požadavek | Hodnoty a limity | Výchozí |
| --- | --- | --- | --- | --- |
| Pole`model` | Typ`string` | PožadavekPovinné | Hodnoty a limity minimax-text | Výchozí— |
| Pole`input` | Typ`string\|input_item[]` | PožadavekPovinné | Hodnoty a limity | Výchozí— |
| Pole`instructions` | Typ`string` | PožadavekVolitelné | Hodnoty a limity | Výchozí— |
| Pole`input[].type` | Typ`string` | PožadavekVolitelné | Hodnoty a limity message, reasoning, function\_call, function\_call\_output | Výchozí— |
| Pole`input[].content` | Typ`string\|content_part[]` | PožadavekVolitelné | Hodnoty a limity | Výchozí— |
| Pole`input[].call_id` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Platí, když: function\_call\_output; zachovejte skutečně vrácené call\_id | Výchozí— |
| Pole`input[].output` | Typ`string\|content_part[]` | PožadavekVolitelné | Hodnoty a limity Platí, když: function\_call\_output | Výchozí— |
| Pole`max_output_tokens` | Typ`integer` | PožadavekVolitelné | Hodnoty a limity Minimum: 1 Závisí na modelu | Výchozí— |
| Pole`stream` | Typ`boolean` | PožadavekVolitelné | Hodnoty a limity | Výchozífalse |
| Pole`temperature` | Typ`number` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`top_p` | Typ`number` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`tools` | Typ`tool[]` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`tool_choice` | Typ`string\|object` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`parallel_tool_calls` | Typ`boolean` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`reasoning.effort` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`reasoning.summary` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`text.format` | Typ`object` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`text.verbosity` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`include` | Typ`string[]` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`store` | Typ`boolean` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`previous_response_id` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Požadavek na ID: Pouze skutečné ID odpovědi z podporovaného pokračování Závisí na modelu | Výchozí— |
| Pole`service_tier` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`prompt_cache_key` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`prompt_cache_options` | Typ`object` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
Kombinace vstupních materiálů
**Text** · text UTF8
`vstupní text nebo část input_text`
**Text + obrázek**
`{type:input_image,image_url}`
Parametry a životní cyklus metody
| Parametr | Kontrakt |
| --- | --- |
| Parametr`material_types` | Kontrakttext, image |
| Parametr`required` | Kontraktmodel, input |
| Parametr`optional_controls` | Kontraktnull |
| Parametr`content_type` | Kontraktapplication/json |
| Parametr`text_file_material` | Kontraktskutečný obsah UTF-8 vložený jako text; ID/URLs souborů vyžadují samostatnou přesně vymezenou podporu |
Životní cyklus: `exact retained published method`
Struktury metod a ID jsou přesné; schopnosti dodavatele jsou oddělené od připuštění požadavku.
### Tarify
#### Sazby metod Ailoot
Vstup
0,0003 US$ */ 1K*
Výstup
0,0012 US$ */ 1K*
Čtení z mezipaměti
≈0,00006 US$ */ 1K*
Zápis do mezipaměti
0,0003 US$ */ 1K*
Zápis do mezipaměti, 5 min
0,0003 US$ */ 1K tokens*
#### Ceny podle délky požadavku · OpenAI Responses
| Velikost požadavku v tokenech | Vstup | Výstup | Čtení z mezipaměti | Zápis do mezipaměti | Mezipaměť 5 min | Mezipaměť 1 hodina |
| --- | --- | --- | --- | --- | --- | --- |
| Velikost požadavku v tokenech(0; 524 288\] | Vstup0,0003 US$ | Výstup0,0012 US$ | Čtení z mezipaměti≈0,00006 US$ | Zápis do mezipaměti0,0003 US$ | Mezipaměť 5 min0,0003 US$ | Mezipaměť 1 hodinaZákladní: — |
| Velikost požadavku v tokenech(524 288; 1 000 000\] | Vstup0,0006 US$ | Výstup0,0024 US$ | Čtení z mezipaměti≈0,00012 US$ | Zápis do mezipaměti0,0006 US$ | Mezipaměť 5 min0,0006 US$ | Mezipaměť 1 hodinaZákladní: — |
Sazby v USD za 1K tokenů. Není-li sazba nastavena, použije se zděděná základní sazba této metody; «—» znamená, že základní sazba není nastavena.
Ailoot před požadavkem rezervuje odhadovanou částku. Po výsledku vyúčtuje konečný poplatek podle naměřeného využití. Při streamování se účtování řídí konečným záznamem využití. [Jak funguje rezervace a vyúčtování →](https://ailoot.ai/docs/cs/billing/reserve/)
#### Podrobnosti referenčního tarifu
Referenční tabulky modelu nemění výběr metody, cenové nabídky ani poplatky. Skutečné poplatky používají sazby vybrané metody Ailoot.
Referenční tabulky modelu
#### Ceny podle konfigurace
Přiřaďte každý poplatek k uvedeným podmínkám. Pro každou sadu alternativních konfigurací použijte jednu sazbu.
| Konfigurace | Tabulka sazeb | Tokeny kontextu, více než | Tokeny kontextu, do uvedené hodnoty včetně | Poplatek |
| --- | --- | --- | --- | --- |
| KonfiguraceOpenAI Chat · Základní sazby za tokeny | Tabulka sazebZákladní sazba | Tokeny kontextu, více než— | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.0006** / 1K tokenů Výstup · Výstupní tokeny **$0.0024** / 1K tokenů Vstup · Čtení z mezipaměti **$0.00012** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguraceOpenAI Chat · Úroveň 1 podle délky požadavku | Tabulka sazeb— | Tokeny kontextu, více než0 | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.0006** / 1K tokenů Výstup · Výstupní tokeny **$0.0024** / 1K tokenů Vstup · Čtení z mezipaměti **$0.00012** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguraceAnthropic Messages · Základní sazby za tokeny | Tabulka sazebZákladní sazba | Tokeny kontextu, více než— | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.0006** / 1K tokenů Výstup · Výstupní tokeny **$0.0024** / 1K tokenů Vstup · Čtení z mezipaměti **$0.00012** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguraceAnthropic Messages · Úroveň 1 podle délky požadavku | Tabulka sazeb— | Tokeny kontextu, více než0 | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.0006** / 1K tokenů Výstup · Výstupní tokeny **$0.0024** / 1K tokenů Vstup · Čtení z mezipaměti **$0.00012** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
### Příklady požadavků
#### Ailoot · OpenAI Responses
Textový příkladVstup, obrázekPython SDKNode.js SDKStreamování v Pythonu
```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_TEXT_FILE:?Set your actual UTF-8 source-material file}"
export AILOOT_TEXT_FILE
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model": "minimax-text", "input": ""}')
f=Path(os.environ["AILOOT_TEXT_FILE"])
if not f.is_file():raise SystemExit("Choose your actual UTF-8 source material")
text=f.read_text(encoding="utf-8")
if not text.strip():raise SystemExit("Source material must contain text")
p["input"]="Summarize this material and quote supporting source passages.\n\n"+text
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/responses \
-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 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(json.loads(Path("result.json").read_text(encoding="utf-8")))
PY_RESULT
```
```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_IMAGE_FILE:?Set your actual PNG JPEG or WebP image}"
export AILOOT_IMAGE_FILE
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model": "minimax-text", "input": [{"role": "user", "content": [{"type": "input_text", "text": "Read labels and numbers in this image; flag unreadable text."}]}]}')
import base64
f=Path(os.environ["AILOOT_IMAGE_FILE"])
if not f.is_file():raise SystemExit("Choose an actual PNG JPEG or WebP image")
raw=f.read_bytes()
mime="image/png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "image/jpeg" if raw.startswith(b"\xff\xd8") else "image/webp" if raw[:4]==b"RIFF" and raw[8:12]==b"WEBP" else None
if not mime:raise SystemExit("Use PNG JPEG or WebP")
b64=base64.b64encode(raw).decode()
p["input"][0]["content"].append({"type":"input_image","image_url":"data:"+mime+";base64,"+b64})
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/responses \
-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 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(json.loads(Path("result.json").read_text(encoding="utf-8")))
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)
resp = client.responses.create(model="minimax-text", input="Explain the difference between an observation and a hypothesis 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(resp.to_dict(mode="json"))
```
```js
import OpenAI from "openai";
if (!process.env.AILOOT_API_KEY?.trim()) throw new Error("Set AILOOT_API_KEY before making a request");
const client = new OpenAI({ baseURL: "https://api.ailoot.ai/v1", apiKey: process.env.AILOOT_API_KEY, maxRetries: 0 });
const resp = await client.responses.create({ model: "minimax-text", input: "Explain the difference between an observation and a hypothesis in three sentences." });
import { writeFileSync } from "node:fs";
function saveResult(data, stem = "result") {
writeFileSync(stem + ".json", JSON.stringify(data, null, 2));
console.log(JSON.stringify(data, null, 2));
const saveBlob = (encoded, suffix, label) => {
const raw = Buffer.from(encoded, "base64");
const ext = raw.subarray(0,8).equals(Buffer.from([137,80,78,71,13,10,26,10])) ? "png" : raw[0]===255 && raw[1]===216 ? "jpg" : raw.subarray(0,4).toString()==="RIFF" && raw.subarray(8,12).toString()==="WEBP" ? "webp" : suffix;
const file = `${stem}-${label}.${ext}`;
writeFileSync(file, raw); console.log("Saved", file);
};
for (const [i, block] of (data.content || []).entries()) console.log("Content", i, JSON.stringify(block));
for (const choice of data.choices || []) console.log("Choice", choice.index, JSON.stringify(choice.message || choice.delta || {}));
for (const [i, item] of (data.output || []).entries()) {
console.log("Output", i, JSON.stringify(item));
if (item.type === "image_generation_call" && item.result) saveBlob(item.result, item.output_format || "bin", `output-${i}`);
}
for (const [ci, candidate] of (data.candidates || []).entries()) {
for (const [pi, part] of (candidate.content?.parts || []).entries()) {
console.log("Candidate/part", ci, pi, JSON.stringify(part));
const blob = part.inlineData || part.inline_data;
if (blob?.data) {
const mime = blob.mimeType || blob.mime_type;
const suffix = ({"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"})[mime] || "bin";
saveBlob(blob.data, suffix, `candidate-${ci}-part-${pi}`);
}
}
}
}
saveResult(resp);
```
```python
from openai import OpenAI
import os
from pathlib import Path
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))
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)
with client.responses.stream(model="minimax-text", input="Explain the difference between an observation and a hypothesis 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_response()
save_result(final.to_dict(mode="json"),"stream-result")
```
### Přijímání a ukládání výsledků
#### Ailoot · OpenAI Responses
json nebo SSE
##### Uchovejte všechny dokončené výsledky
Uchovejte každou úplnou vrácenou odpověď, soubor i část obsahu.
Zachovejte každou výstupní položku a část obsahu, skutečné call\_id funkce, šifrované uvažování a údaje o využití. Při streamování uchovejte úplnou identitu události/položky.
##### Pokud je nutné ověřit původní odpověď
Zachovejte ID požadavků/odpovědí a hlavičky. Není dodána obecná URL pro načtení textové úlohy.
Pole odpovědi
| Pole | Typ |
| --- | --- |
| Pole`id` | Typstring |
| Pole`status` | Typstring |
| Pole`output[]` | Typmessage\|reasoning\|function\_call\|other item |
| Pole`output[].content[]` | Typcontent part |
| Pole`usage` | Typobject |
Chyby a další kroky
| Odpověď | Podmínka | Další krok |
| --- | --- | --- |
| Odpověď400 · `invalid_request_error` | PodmínkaNeplatná povinná pole, reprezentace podkladů nebo hodnota parametru | Další krokPřed novým požadavkem na vytvoření opravte uvedená pole. |
### Aliasy
#### Aliasy modelu
Ailoot [`MiniMax-M3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=MiniMax-M3&fmt=responses), [`minimax`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax&fmt=responses), [`minimax-latest`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-latest&fmt=responses), [`minimax-text`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-text&fmt=responses), [`minimax-text-latest`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-text-latest&fmt=responses), [`minimax/minimax-m3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax%2Fminimax-m3&fmt=responses)
**Ailoot Ultra** [`MiniMax-M3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Ultra&caller=MiniMax-M3), [`minimax/minimax-m3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Ultra&caller=minimax%2Fminimax-m3)
#### Aliasy cest metod
`/chat/completions`
#### Související ID modelů
[`minimax/minimax-m3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax%2Fminimax-m3&fmt=responses), [`minimax/minimax-m3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Ultra&caller=minimax%2Fminimax-m3), [`minimax`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax&fmt=responses), [`minimax-latest`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-latest&fmt=responses), [`minimax-text`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-text&fmt=responses), [`minimax-text-latest`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-text-latest&fmt=responses), [`MiniMax-M3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=MiniMax-M3&fmt=responses), [`MiniMax-M3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Ultra&caller=MiniMax-M3)
**Ailoot · OpenAI Chat** `POST /v1/chat/completions` `minimax-text`
[`minimax-text`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-text&fmt=chat)
MiniMax /`minimax-text`
ID modelu
- `MiniMax-M3`
- `minimax`
- `minimax-latest`
- `minimax-text`
- `minimax-text-latest`
- `minimax/minimax-m3`
### Úvod
MiniMax M3 je multimodální model pro dlouhodobou práci na kódu a agentní úlohy, který využívá MiniMax Sparse Attention a návrh pro dlouhý kontext. Uvedená chatová rozhraní Ultra přijímají text a vracejí textové odpovědi.
Přijímané vstupy
Text · Obrázky
Výsledky
Text
### Dostupné v Ailoot · vstupy a metody
**Ailoot · OpenAI Chat** `POST /v1/chat/completions`
Vstup
`text`, `image`
Výstup
`text`
Kontext
1 000 000 tokens
Maximální výstup
524 288 tokens
Výstupní formát
json nebo SSE
| Pole | Typ | Požadavek | Hodnoty a limity | Výchozí |
| --- | --- | --- | --- | --- |
| Pole`model` | Typ`string` | PožadavekPovinné | Hodnoty a limity minimax-text | Výchozí— |
| Pole`messages` | Typ`message[]` | PožadavekPovinné | Hodnoty a limity Minimální počet položek: 1 | Výchozí— |
| Pole`messages[].role` | Typ`string` | PožadavekPovinné | Hodnoty a limity Příklady: system, user, assistant, tool, function Podmínky: Tyto role jsou výslovně zastoupeny typy kompatibility zdrojového kódu; přesná sada rolí zůstává specifická pro daný model. Závisí na modelu | Výchozí— |
| Pole`messages[].content` | Typ`string\|content_part[]\|null` | PožadavekVolitelné | Hodnoty a limity | Výchozí— |
| Pole`messages[].tool_calls` | Typ`tool_call[]` | PožadavekVolitelné | Hodnoty a limity | Výchozí— |
| Pole`messages[].tool_call_id` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Platí, když: role=tool; použijte skutečně vrácené ID | Výchozí— |
| Pole`messages[].name` | Typ`string` | PožadavekVolitelné | Hodnoty a limity | Výchozí— |
| Pole`messages[].reasoning_content` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Platí, když: Předávejte zpět skutečně vrácené uvažování tam, kde je tento model používá | Výchozí— |
| Pole`messages[].reasoning_details` | Typ`object\|array` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`max_tokens` | Typ`integer` | PožadavekVolitelné | Hodnoty a limity Minimum: 1 Závisí na modelu | Výchozí— |
| Pole`max_completion_tokens` | Typ`integer` | PožadavekVolitelné | Hodnoty a limity Minimum: 1 Závisí na modelu | Výchozí— |
| Pole`stream` | Typ`boolean` | PožadavekVolitelné | Hodnoty a limity | Výchozífalse |
| Pole`stream_options.include_usage` | Typ`boolean` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`temperature` | Typ`number` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`top_p` | Typ`number` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`stop` | Typ`string\|string[]` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`tools` | Typ`function_tool[]` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`tools[].type` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`tools[].function.name` | Typ`string` | PožadavekPovinné | Hodnoty a limity Platí, když: nástroj typu funkce je dodán | Výchozí— |
| Pole`tools[].function.description` | Typ`string` | PožadavekVolitelné | Hodnoty a limity | Výchozí— |
| Pole`tools[].function.parameters` | Typ`JSON_schema` | PožadavekVolitelné | Hodnoty a limity | Výchozí— |
| Pole`tool_choice` | Typ`string\|object` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`parallel_tool_calls` | Typ`boolean` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`response_format` | Typ`object` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`reasoning_effort` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`reasoning` | Typ`object` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`service_tier` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`instructions` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Pole kompatibility | Výchozí— |
| Pole`functions` | Typ`function[]` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`function_call` | Typ`string\|object` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`prompt_cache_options` | Typ`object` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
Kombinace vstupních materiálů
**Text** · text UTF8
`messages[].content`
**Text + obrázek**
`{type:image_url,image_url:{url,detail}}`
Parametry a životní cyklus metody
| Parametr | Kontrakt |
| --- | --- |
| Parametr`material_types` | Kontrakttext, image |
| Parametr`required` | Kontraktmodel, messages |
| Parametr`optional_controls` | Kontraktnull |
| Parametr`content_type` | Kontraktapplication/json |
| Parametr`text_file_material` | Kontraktskutečný obsah UTF-8 vložený jako text; ID/URLs souborů vyžadují samostatnou přesně vymezenou podporu |
Životní cyklus: `exact retained published method`
Struktury metod a ID jsou přesné; schopnosti dodavatele jsou oddělené od připuštění požadavku.
### Tarify
#### Sazby metod Ailoot
Vstup
0,0003 US$ */ 1K*
Výstup
0,0012 US$ */ 1K*
Čtení z mezipaměti
≈0,00006 US$ */ 1K*
Zápis do mezipaměti
0,0003 US$ */ 1K*
Zápis do mezipaměti, 5 min
0,0003 US$ */ 1K tokens*
#### Ceny podle délky požadavku · OpenAI Chat
| Velikost požadavku v tokenech | Vstup | Výstup | Čtení z mezipaměti | Zápis do mezipaměti | Mezipaměť 5 min | Mezipaměť 1 hodina |
| --- | --- | --- | --- | --- | --- | --- |
| Velikost požadavku v tokenech(0; 524 288\] | Vstup0,0003 US$ | Výstup0,0012 US$ | Čtení z mezipaměti≈0,00006 US$ | Zápis do mezipaměti0,0003 US$ | Mezipaměť 5 min0,0003 US$ | Mezipaměť 1 hodinaZákladní: — |
| Velikost požadavku v tokenech(524 288; 1 000 000\] | Vstup0,0006 US$ | Výstup0,0024 US$ | Čtení z mezipaměti≈0,00012 US$ | Zápis do mezipaměti0,0006 US$ | Mezipaměť 5 min0,0006 US$ | Mezipaměť 1 hodinaZákladní: — |
Sazby v USD za 1K tokenů. Není-li sazba nastavena, použije se zděděná základní sazba této metody; «—» znamená, že základní sazba není nastavena.
Ailoot před požadavkem rezervuje odhadovanou částku. Po výsledku vyúčtuje konečný poplatek podle naměřeného využití. Při streamování se účtování řídí konečným záznamem využití. [Jak funguje rezervace a vyúčtování →](https://ailoot.ai/docs/cs/billing/reserve/)
#### Podrobnosti referenčního tarifu
Referenční tabulky modelu nemění výběr metody, cenové nabídky ani poplatky. Skutečné poplatky používají sazby vybrané metody Ailoot.
Referenční tabulky modelu
#### Ceny podle konfigurace
Přiřaďte každý poplatek k uvedeným podmínkám. Pro každou sadu alternativních konfigurací použijte jednu sazbu.
| Konfigurace | Tabulka sazeb | Tokeny kontextu, více než | Tokeny kontextu, do uvedené hodnoty včetně | Poplatek |
| --- | --- | --- | --- | --- |
| KonfiguraceOpenAI Chat · Základní sazby za tokeny | Tabulka sazebZákladní sazba | Tokeny kontextu, více než— | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.0006** / 1K tokenů Výstup · Výstupní tokeny **$0.0024** / 1K tokenů Vstup · Čtení z mezipaměti **$0.00012** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguraceOpenAI Chat · Úroveň 1 podle délky požadavku | Tabulka sazeb— | Tokeny kontextu, více než0 | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.0006** / 1K tokenů Výstup · Výstupní tokeny **$0.0024** / 1K tokenů Vstup · Čtení z mezipaměti **$0.00012** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguraceAnthropic Messages · Základní sazby za tokeny | Tabulka sazebZákladní sazba | Tokeny kontextu, více než— | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.0006** / 1K tokenů Výstup · Výstupní tokeny **$0.0024** / 1K tokenů Vstup · Čtení z mezipaměti **$0.00012** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguraceAnthropic Messages · Úroveň 1 podle délky požadavku | Tabulka sazeb— | Tokeny kontextu, více než0 | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.0006** / 1K tokenů Výstup · Výstupní tokeny **$0.0024** / 1K tokenů Vstup · Čtení z mezipaměti **$0.00012** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
### Příklady požadavků
#### Ailoot · OpenAI Chat
Textový příkladVstup, obrázekPython SDKNode.js SDKStreamování v Pythonu
```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_TEXT_FILE:?Set your actual UTF-8 source-material file}"
export AILOOT_TEXT_FILE
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model": "minimax-text", "messages": []}')
f=Path(os.environ["AILOOT_TEXT_FILE"])
if not f.is_file():raise SystemExit("Choose your actual UTF-8 source material")
text=f.read_text(encoding="utf-8")
if not text.strip():raise SystemExit("Source material must contain text")
p["messages"]=[{"role":"user","content":"Summarize this material and quote supporting source passages.\n\n"+text}]
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
print(json.dumps(json.loads(Path("result.json").read_text()),ensure_ascii=False,indent=2))
PY_RESULT
```
```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_IMAGE_FILE:?Set your actual PNG JPEG or WebP image}"
export AILOOT_IMAGE_FILE
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model": "minimax-text", "messages": [{"role": "user", "content": [{"type": "text", "text": "Read labels and numbers in this image; flag unreadable text."}]}]}')
import base64
f=Path(os.environ["AILOOT_IMAGE_FILE"])
if not f.is_file():raise SystemExit("Choose an actual PNG JPEG or WebP image")
raw=f.read_bytes()
mime="image/png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "image/jpeg" if raw.startswith(b"\xff\xd8") else "image/webp" if raw[:4]==b"RIFF" and raw[8:12]==b"WEBP" else None
if not mime:raise SystemExit("Use PNG JPEG or WebP")
b64=base64.b64encode(raw).decode()
p["messages"][0]["content"].append({"type":"image_url","image_url":{"url":"data:"+mime+";base64,"+b64}})
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
print(json.dumps(json.loads(Path("result.json").read_text()),ensure_ascii=False,indent=2))
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)
resp = client.chat.completions.create(
model="minimax-text",
messages=[{"role": "user", "content": "Explain the difference between an observation and a hypothesis 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(resp.to_dict(mode="json"))
```
```js
import OpenAI from "openai";
if (!process.env.AILOOT_API_KEY?.trim()) throw new Error("Set AILOOT_API_KEY before making a request");
const client = new OpenAI({ baseURL: "https://api.ailoot.ai/v1", apiKey: process.env.AILOOT_API_KEY, maxRetries: 0 });
const resp = await client.chat.completions.create({
model: "minimax-text",
messages: [{ role: "user", content: "Explain the difference between an observation and a hypothesis in three sentences." }],
});
import { writeFileSync } from "node:fs";
function saveResult(data, stem = "result") {
writeFileSync(stem + ".json", JSON.stringify(data, null, 2));
console.log(JSON.stringify(data, null, 2));
const saveBlob = (encoded, suffix, label) => {
const raw = Buffer.from(encoded, "base64");
const ext = raw.subarray(0,8).equals(Buffer.from([137,80,78,71,13,10,26,10])) ? "png" : raw[0]===255 && raw[1]===216 ? "jpg" : raw.subarray(0,4).toString()==="RIFF" && raw.subarray(8,12).toString()==="WEBP" ? "webp" : suffix;
const file = `${stem}-${label}.${ext}`;
writeFileSync(file, raw); console.log("Saved", file);
};
for (const [i, block] of (data.content || []).entries()) console.log("Content", i, JSON.stringify(block));
for (const choice of data.choices || []) console.log("Choice", choice.index, JSON.stringify(choice.message || choice.delta || {}));
for (const [i, item] of (data.output || []).entries()) {
console.log("Output", i, JSON.stringify(item));
if (item.type === "image_generation_call" && item.result) saveBlob(item.result, item.output_format || "bin", `output-${i}`);
}
for (const [ci, candidate] of (data.candidates || []).entries()) {
for (const [pi, part] of (candidate.content?.parts || []).entries()) {
console.log("Candidate/part", ci, pi, JSON.stringify(part));
const blob = part.inlineData || part.inline_data;
if (blob?.data) {
const mime = blob.mimeType || blob.mime_type;
const suffix = ({"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"})[mime] || "bin";
saveBlob(blob.data, suffix, `candidate-${ci}-part-${pi}`);
}
}
}
}
saveResult(resp);
```
```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='minimax-text',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")
```
### Přijímání a ukládání výsledků
#### Ailoot · OpenAI Chat
json nebo SSE
##### Uchovejte všechny dokončené výsledky
Uchovejte každou úplnou vrácenou odpověď, soubor i část obsahu.
Zachovejte každou volbu a její obsah/volání nástrojů/uvažování. V SSE sestavujte přírůstky podle indexu volby/nástroje a zachovejte konečný důvod ukončení i údaje o využití.
##### Pokud je nutné ověřit původní odpověď
Zachovejte ID požadavků/odpovědí a hlavičky. Není dodána obecná URL pro načtení textové úlohy.
Pole odpovědi
| Pole | Typ |
| --- | --- |
| Pole`choices[].index` | Typinteger |
| Pole`choices[].message.content` | Typstring\|null |
| Pole`choices[].message.tool_calls` | Typtool\_call\[\] |
| Pole`choices[].message.reasoning_content` | Typstring |
| Pole`choices[].message.reasoning_details` | Typobject\|array |
| Pole`choices[].finish_reason` | Typstring\|null |
| Pole`usage` | Typobject |
Chyby a další kroky
| Odpověď | Podmínka | Další krok |
| --- | --- | --- |
| Odpověď400 · `invalid_request_error` | PodmínkaNeplatná povinná pole, reprezentace podkladů nebo hodnota parametru | Další krokPřed novým požadavkem na vytvoření opravte uvedená pole. |
### Aliasy
#### Aliasy modelu
Ailoot [`MiniMax-M3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=MiniMax-M3&fmt=chat), [`minimax`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax&fmt=chat), [`minimax-latest`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-latest&fmt=chat), [`minimax-text`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-text&fmt=chat), [`minimax-text-latest`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-text-latest&fmt=chat), [`minimax/minimax-m3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax%2Fminimax-m3&fmt=chat)
**Ailoot Ultra** [`MiniMax-M3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Ultra&caller=MiniMax-M3&fmt=chat), [`minimax/minimax-m3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Ultra&caller=minimax%2Fminimax-m3&fmt=chat)
#### Aliasy cest metod
`/chat/completions`
#### Související ID modelů
[`minimax/minimax-m3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax%2Fminimax-m3&fmt=chat), [`minimax/minimax-m3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Ultra&caller=minimax%2Fminimax-m3&fmt=chat), [`minimax`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax&fmt=chat), [`minimax-latest`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-latest&fmt=chat), [`minimax-text`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-text&fmt=chat), [`minimax-text-latest`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-text-latest&fmt=chat), [`MiniMax-M3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=MiniMax-M3&fmt=chat), [`MiniMax-M3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Ultra&caller=MiniMax-M3&fmt=chat)
**Ailoot · Anthropic Messages** `POST /v1/messages` `minimax-text-latest`
[`minimax-text-latest`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-text-latest&fmt=messages)
MiniMax /`minimax-text-latest`
ID modelu
- `MiniMax-M3`
- `minimax`
- `minimax-latest`
- `minimax-text`
- `minimax-text-latest`
- `minimax/minimax-m3`
### Úvod
MiniMax M3 je multimodální model pro dlouhodobou práci na kódu a agentní úlohy, který využívá MiniMax Sparse Attention a návrh pro dlouhý kontext. Uvedená chatová rozhraní Ultra přijímají text a vracejí textové odpovědi.
Přijímané vstupy
Text · Obrázky
Výsledky
Text
### Dostupné v Ailoot · vstupy a metody
**Ailoot · Anthropic Messages** `POST /v1/messages`
Vstup
`text`, `image`
Výstup
`text`
Kontext
1 000 000 tokens
Maximální výstup
524 288 tokens
Výstupní formát
json nebo SSE
| Pole | Typ | Požadavek | Hodnoty a limity | Výchozí |
| --- | --- | --- | --- | --- |
| Pole`model` | Typ`string` | PožadavekPovinné | Hodnoty a limity minimax-text-latest | Výchozí— |
| Pole`messages` | Typ`message[]` | PožadavekPovinné | Hodnoty a limity Minimální počet položek: 1 | Výchozí— |
| Pole`messages[].role` | Typ`string` | PožadavekPovinné | Hodnoty a limity user, assistant | Výchozí— |
| Pole`messages[].content` | Typ`string\|content_block[]` | PožadavekPovinné | Hodnoty a limity | Výchozí— |
| Pole`system` | Typ`string\|content_block[]` | PožadavekVolitelné | Hodnoty a limity | Výchozí— |
| Pole`max_tokens` | Typ`integer` | PožadavekPovinné | Hodnoty a limity Minimum: 1 Limit platí pro: přesný limit vybraného modelu/karty | Výchozí— |
| Pole`stream` | Typ`boolean` | PožadavekVolitelné | Hodnoty a limity | Výchozífalse |
| Pole`temperature` | Typ`number` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`top_p` | Typ`number` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`stop_sequences` | Typ`string[]` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`tools` | Typ`tool[]` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`tools[].name` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Platí, když: nástroj je dodán | Výchozí— |
| Pole`tools[].description` | Typ`string` | PožadavekVolitelné | Hodnoty a limity | Výchozí— |
| Pole`tools[].input_schema` | Typ`JSON_schema` | PožadavekVolitelné | Hodnoty a limity | Výchozí— |
| Pole`tool_choice` | Typ`object` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`thinking.type` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`thinking.budget_tokens` | Typ`integer` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`output_config.effort` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`metadata` | Typ`object` | PožadavekVolitelné | Hodnoty a limity | Výchozí— |
| Pole`cache_control` | Typ`object` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
Kombinace vstupních materiálů
**Text** · text UTF8
`messages[].content nebo blok type=text`
**Text + obrázek**
`{type:image,source:{type:base64,media_type,data}} nebo zdroj type=url`
Parametry a životní cyklus metody
| Parametr | Kontrakt |
| --- | --- |
| Parametr`material_types` | Kontrakttext, image |
| Parametr`required` | Kontraktmodel, messages, max\_tokens |
| Parametr`optional_controls` | Kontraktnull |
| Parametr`content_type` | Kontraktapplication/json |
| Parametr`text_file_material` | Kontraktskutečný obsah UTF-8 vložený jako text; ID/URLs souborů vyžadují samostatnou přesně vymezenou podporu |
Životní cyklus: `exact retained published method`
Struktury metod a ID jsou přesné; schopnosti dodavatele jsou oddělené od připuštění požadavku.
### Tarify
#### Sazby metod Ailoot
Vstup
0,0003 US$ */ 1K*
Výstup
0,0012 US$ */ 1K*
Čtení z mezipaměti
≈0,00006 US$ */ 1K*
Zápis do mezipaměti
0,0003 US$ */ 1K*
Zápis do mezipaměti, 5 min
0,0003 US$ */ 1K tokens*
#### Ceny podle délky požadavku · Anthropic Messages
| Velikost požadavku v tokenech | Vstup | Výstup | Čtení z mezipaměti | Zápis do mezipaměti | Mezipaměť 5 min | Mezipaměť 1 hodina |
| --- | --- | --- | --- | --- | --- | --- |
| Velikost požadavku v tokenech(0; 524 288\] | Vstup0,0003 US$ | Výstup0,0012 US$ | Čtení z mezipaměti≈0,00006 US$ | Zápis do mezipaměti0,0003 US$ | Mezipaměť 5 min0,0003 US$ | Mezipaměť 1 hodinaZákladní: — |
| Velikost požadavku v tokenech(524 288; 1 000 000\] | Vstup0,0006 US$ | Výstup0,0024 US$ | Čtení z mezipaměti≈0,00012 US$ | Zápis do mezipaměti0,0006 US$ | Mezipaměť 5 min0,0006 US$ | Mezipaměť 1 hodinaZákladní: — |
Sazby v USD za 1K tokenů. Není-li sazba nastavena, použije se zděděná základní sazba této metody; «—» znamená, že základní sazba není nastavena.
Ailoot před požadavkem rezervuje odhadovanou částku. Po výsledku vyúčtuje konečný poplatek podle naměřeného využití. Při streamování se účtování řídí konečným záznamem využití. [Jak funguje rezervace a vyúčtování →](https://ailoot.ai/docs/cs/billing/reserve/)
#### Podrobnosti referenčního tarifu
Referenční tabulky modelu nemění výběr metody, cenové nabídky ani poplatky. Skutečné poplatky používají sazby vybrané metody Ailoot.
Referenční tabulky modelu
#### Ceny podle konfigurace
Přiřaďte každý poplatek k uvedeným podmínkám. Pro každou sadu alternativních konfigurací použijte jednu sazbu.
| Konfigurace | Tabulka sazeb | Tokeny kontextu, více než | Tokeny kontextu, do uvedené hodnoty včetně | Poplatek |
| --- | --- | --- | --- | --- |
| KonfiguraceOpenAI Chat · Základní sazby za tokeny | Tabulka sazebZákladní sazba | Tokeny kontextu, více než— | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.0006** / 1K tokenů Výstup · Výstupní tokeny **$0.0024** / 1K tokenů Vstup · Čtení z mezipaměti **$0.00012** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguraceOpenAI Chat · Úroveň 1 podle délky požadavku | Tabulka sazeb— | Tokeny kontextu, více než0 | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.0006** / 1K tokenů Výstup · Výstupní tokeny **$0.0024** / 1K tokenů Vstup · Čtení z mezipaměti **$0.00012** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguraceAnthropic Messages · Základní sazby za tokeny | Tabulka sazebZákladní sazba | Tokeny kontextu, více než— | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.0006** / 1K tokenů Výstup · Výstupní tokeny **$0.0024** / 1K tokenů Vstup · Čtení z mezipaměti **$0.00012** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguraceAnthropic Messages · Úroveň 1 podle délky požadavku | Tabulka sazeb— | Tokeny kontextu, více než0 | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.0006** / 1K tokenů Výstup · Výstupní tokeny **$0.0024** / 1K tokenů Vstup · Čtení z mezipaměti **$0.00012** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
### Příklady požadavků
#### Ailoot · Anthropic Messages
Textový příkladVstup, obrázekPython SDKNode.js SDKStreamování v Pythonu
```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_TEXT_FILE:?Set your actual UTF-8 source-material file}"
export AILOOT_TEXT_FILE
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model": "minimax-text-latest", "max_tokens": 1024, "messages": []}')
f=Path(os.environ["AILOOT_TEXT_FILE"])
if not f.is_file():raise SystemExit("Choose your actual UTF-8 source material")
text=f.read_text(encoding="utf-8")
if not text.strip():raise SystemExit("Source material must contain text")
p["messages"]=[{"role":"user","content":"Summarize this material and quote supporting source passages.\n\n"+text}]
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/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
print(json.dumps(json.loads(Path("result.json").read_text()),ensure_ascii=False,indent=2))
PY_RESULT
```
```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_IMAGE_FILE:?Set your actual PNG JPEG or WebP image}"
export AILOOT_IMAGE_FILE
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model": "minimax-text-latest", "max_tokens": 1024, "messages": [{"role": "user", "content": [{"type": "text", "text": "Read labels and numbers in this image; flag unreadable text."}]}]}')
import base64
f=Path(os.environ["AILOOT_IMAGE_FILE"])
if not f.is_file():raise SystemExit("Choose an actual PNG JPEG or WebP image")
raw=f.read_bytes()
mime="image/png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "image/jpeg" if raw.startswith(b"\xff\xd8") else "image/webp" if raw[:4]==b"RIFF" and raw[8:12]==b"WEBP" else None
if not mime:raise SystemExit("Use PNG JPEG or WebP")
b64=base64.b64encode(raw).decode()
p["messages"][0]["content"].append({"type":"image","source":{"type":"base64","media_type":mime,"data":b64}})
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/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
print(json.dumps(json.loads(Path("result.json").read_text()),ensure_ascii=False,indent=2))
PY_RESULT
```
```python
import anthropic
import os
if not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")
client = anthropic.Anthropic(base_url="https://api.ailoot.ai", api_key=os.environ["AILOOT_API_KEY"], max_retries=0)
msg = client.messages.create(
model="minimax-text-latest",
max_tokens=1024,
messages=[{"role": "user", "content": "Explain the difference between an observation and a hypothesis 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(msg.to_dict(mode="json"))
```
```js
import Anthropic from "@anthropic-ai/sdk";
if (!process.env.AILOOT_API_KEY?.trim()) throw new Error("Set AILOOT_API_KEY before making a request");
const client = new Anthropic({ baseURL: "https://api.ailoot.ai", apiKey: process.env.AILOOT_API_KEY, maxRetries: 0 });
const msg = await client.messages.create({
model: "minimax-text-latest",
max_tokens: 1024,
messages: [{ role: "user", content: "Explain the difference between an observation and a hypothesis in three sentences." }],
});
import { writeFileSync } from "node:fs";
function saveResult(data, stem = "result") {
writeFileSync(stem + ".json", JSON.stringify(data, null, 2));
console.log(JSON.stringify(data, null, 2));
const saveBlob = (encoded, suffix, label) => {
const raw = Buffer.from(encoded, "base64");
const ext = raw.subarray(0,8).equals(Buffer.from([137,80,78,71,13,10,26,10])) ? "png" : raw[0]===255 && raw[1]===216 ? "jpg" : raw.subarray(0,4).toString()==="RIFF" && raw.subarray(8,12).toString()==="WEBP" ? "webp" : suffix;
const file = `${stem}-${label}.${ext}`;
writeFileSync(file, raw); console.log("Saved", file);
};
for (const [i, block] of (data.content || []).entries()) console.log("Content", i, JSON.stringify(block));
for (const choice of data.choices || []) console.log("Choice", choice.index, JSON.stringify(choice.message || choice.delta || {}));
for (const [i, item] of (data.output || []).entries()) {
console.log("Output", i, JSON.stringify(item));
if (item.type === "image_generation_call" && item.result) saveBlob(item.result, item.output_format || "bin", `output-${i}`);
}
for (const [ci, candidate] of (data.candidates || []).entries()) {
for (const [pi, part] of (candidate.content?.parts || []).entries()) {
console.log("Candidate/part", ci, pi, JSON.stringify(part));
const blob = part.inlineData || part.inline_data;
if (blob?.data) {
const mime = blob.mimeType || blob.mime_type;
const suffix = ({"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"})[mime] || "bin";
saveBlob(blob.data, suffix, `candidate-${ci}-part-${pi}`);
}
}
}
}
saveResult(msg);
```
```python
import anthropic,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=anthropic.Anthropic(base_url="https://api.ailoot.ai",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.messages.stream(model='minimax-text-latest',max_tokens=1024,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_message()
save_result(final.to_dict(mode="json"),"stream-result")
```
### Přijímání a ukládání výsledků
#### Ailoot · Anthropic Messages
json nebo SSE
##### Uchovejte všechny dokončené výsledky
Uchovejte každou úplnou vrácenou odpověď, soubor i část obsahu.
Zachovejte všechny bloky obsahu, podpisy uvažování a skutečná ID použití nástrojů. Sestavte všechny přírůstky bloků SSE; první textový blok není úplný výstup.
##### Pokud je nutné ověřit původní odpověď
Zachovejte ID požadavků/odpovědí a hlavičky. Není dodána obecná URL pro načtení textové úlohy.
Pole odpovědi
| Pole | Typ |
| --- | --- |
| Pole`id` | Typstring |
| Pole`model` | Typstring |
| Pole`content[]` | Typtext\|thinking\|tool\_use\|other content block |
| Pole`stop_reason` | Typstring\|null |
| Pole`usage` | Typobject |
Chyby a další kroky
| Odpověď | Podmínka | Další krok |
| --- | --- | --- |
| Odpověď400 · `invalid_request_error` | PodmínkaNeplatná povinná pole, reprezentace podkladů nebo hodnota parametru | Další krokPřed novým požadavkem na vytvoření opravte uvedená pole. |
### Aliasy
#### Aliasy modelu
Ailoot [`MiniMax-M3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=MiniMax-M3&fmt=messages), [`minimax`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax&fmt=messages), [`minimax-latest`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-latest&fmt=messages), [`minimax-text`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-text&fmt=messages), [`minimax-text-latest`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-text-latest&fmt=messages), [`minimax/minimax-m3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax%2Fminimax-m3&fmt=messages)
**Ailoot Ultra** [`MiniMax-M3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Ultra&caller=MiniMax-M3&fmt=messages), [`minimax/minimax-m3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Ultra&caller=minimax%2Fminimax-m3&fmt=messages)
#### Aliasy cest metod
`/chat/completions`
#### Související ID modelů
[`minimax/minimax-m3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax%2Fminimax-m3&fmt=messages), [`minimax/minimax-m3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Ultra&caller=minimax%2Fminimax-m3&fmt=messages), [`minimax`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax&fmt=messages), [`minimax-latest`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-latest&fmt=messages), [`minimax-text`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-text&fmt=messages), [`minimax-text-latest`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-text-latest&fmt=messages), [`MiniMax-M3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=MiniMax-M3&fmt=messages), [`MiniMax-M3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Ultra&caller=MiniMax-M3&fmt=messages)
**Ailoot · OpenAI Responses** `POST /v1/responses` `minimax-text-latest`
[`minimax-text-latest`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-text-latest&fmt=responses)
MiniMax /`minimax-text-latest`
ID modelu
- `MiniMax-M3`
- `minimax`
- `minimax-latest`
- `minimax-text`
- `minimax-text-latest`
- `minimax/minimax-m3`
### Úvod
MiniMax M3 je multimodální model pro dlouhodobou práci na kódu a agentní úlohy, který využívá MiniMax Sparse Attention a návrh pro dlouhý kontext. Uvedená chatová rozhraní Ultra přijímají text a vracejí textové odpovědi.
Přijímané vstupy
Text · Obrázky
Výsledky
Text
### Dostupné v Ailoot · vstupy a metody
**Ailoot · OpenAI Responses** `POST /v1/responses`
Vstup
`text`, `image`
Výstup
`text`
Kontext
1 000 000 tokens
Maximální výstup
1 000 000 tokens
Výstupní formát
json nebo SSE
| Pole | Typ | Požadavek | Hodnoty a limity | Výchozí |
| --- | --- | --- | --- | --- |
| Pole`model` | Typ`string` | PožadavekPovinné | Hodnoty a limity minimax-text-latest | Výchozí— |
| Pole`input` | Typ`string\|input_item[]` | PožadavekPovinné | Hodnoty a limity | Výchozí— |
| Pole`instructions` | Typ`string` | PožadavekVolitelné | Hodnoty a limity | Výchozí— |
| Pole`input[].type` | Typ`string` | PožadavekVolitelné | Hodnoty a limity message, reasoning, function\_call, function\_call\_output | Výchozí— |
| Pole`input[].content` | Typ`string\|content_part[]` | PožadavekVolitelné | Hodnoty a limity | Výchozí— |
| Pole`input[].call_id` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Platí, když: function\_call\_output; zachovejte skutečně vrácené call\_id | Výchozí— |
| Pole`input[].output` | Typ`string\|content_part[]` | PožadavekVolitelné | Hodnoty a limity Platí, když: function\_call\_output | Výchozí— |
| Pole`max_output_tokens` | Typ`integer` | PožadavekVolitelné | Hodnoty a limity Minimum: 1 Závisí na modelu | Výchozí— |
| Pole`stream` | Typ`boolean` | PožadavekVolitelné | Hodnoty a limity | Výchozífalse |
| Pole`temperature` | Typ`number` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`top_p` | Typ`number` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`tools` | Typ`tool[]` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`tool_choice` | Typ`string\|object` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`parallel_tool_calls` | Typ`boolean` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`reasoning.effort` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`reasoning.summary` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`text.format` | Typ`object` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`text.verbosity` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`include` | Typ`string[]` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`store` | Typ`boolean` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`previous_response_id` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Požadavek na ID: Pouze skutečné ID odpovědi z podporovaného pokračování Závisí na modelu | Výchozí— |
| Pole`service_tier` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`prompt_cache_key` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`prompt_cache_options` | Typ`object` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
Kombinace vstupních materiálů
**Text** · text UTF8
`vstupní text nebo část input_text`
**Text + obrázek**
`{type:input_image,image_url}`
Parametry a životní cyklus metody
| Parametr | Kontrakt |
| --- | --- |
| Parametr`material_types` | Kontrakttext, image |
| Parametr`required` | Kontraktmodel, input |
| Parametr`optional_controls` | Kontraktnull |
| Parametr`content_type` | Kontraktapplication/json |
| Parametr`text_file_material` | Kontraktskutečný obsah UTF-8 vložený jako text; ID/URLs souborů vyžadují samostatnou přesně vymezenou podporu |
Životní cyklus: `exact retained published method`
Struktury metod a ID jsou přesné; schopnosti dodavatele jsou oddělené od připuštění požadavku.
### Tarify
#### Sazby metod Ailoot
Vstup
0,0003 US$ */ 1K*
Výstup
0,0012 US$ */ 1K*
Čtení z mezipaměti
≈0,00006 US$ */ 1K*
Zápis do mezipaměti
0,0003 US$ */ 1K*
Zápis do mezipaměti, 5 min
0,0003 US$ */ 1K tokens*
#### Ceny podle délky požadavku · OpenAI Responses
| Velikost požadavku v tokenech | Vstup | Výstup | Čtení z mezipaměti | Zápis do mezipaměti | Mezipaměť 5 min | Mezipaměť 1 hodina |
| --- | --- | --- | --- | --- | --- | --- |
| Velikost požadavku v tokenech(0; 524 288\] | Vstup0,0003 US$ | Výstup0,0012 US$ | Čtení z mezipaměti≈0,00006 US$ | Zápis do mezipaměti0,0003 US$ | Mezipaměť 5 min0,0003 US$ | Mezipaměť 1 hodinaZákladní: — |
| Velikost požadavku v tokenech(524 288; 1 000 000\] | Vstup0,0006 US$ | Výstup0,0024 US$ | Čtení z mezipaměti≈0,00012 US$ | Zápis do mezipaměti0,0006 US$ | Mezipaměť 5 min0,0006 US$ | Mezipaměť 1 hodinaZákladní: — |
Sazby v USD za 1K tokenů. Není-li sazba nastavena, použije se zděděná základní sazba této metody; «—» znamená, že základní sazba není nastavena.
Ailoot před požadavkem rezervuje odhadovanou částku. Po výsledku vyúčtuje konečný poplatek podle naměřeného využití. Při streamování se účtování řídí konečným záznamem využití. [Jak funguje rezervace a vyúčtování →](https://ailoot.ai/docs/cs/billing/reserve/)
#### Podrobnosti referenčního tarifu
Referenční tabulky modelu nemění výběr metody, cenové nabídky ani poplatky. Skutečné poplatky používají sazby vybrané metody Ailoot.
Referenční tabulky modelu
#### Ceny podle konfigurace
Přiřaďte každý poplatek k uvedeným podmínkám. Pro každou sadu alternativních konfigurací použijte jednu sazbu.
| Konfigurace | Tabulka sazeb | Tokeny kontextu, více než | Tokeny kontextu, do uvedené hodnoty včetně | Poplatek |
| --- | --- | --- | --- | --- |
| KonfiguraceOpenAI Chat · Základní sazby za tokeny | Tabulka sazebZákladní sazba | Tokeny kontextu, více než— | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.0006** / 1K tokenů Výstup · Výstupní tokeny **$0.0024** / 1K tokenů Vstup · Čtení z mezipaměti **$0.00012** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguraceOpenAI Chat · Úroveň 1 podle délky požadavku | Tabulka sazeb— | Tokeny kontextu, více než0 | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.0006** / 1K tokenů Výstup · Výstupní tokeny **$0.0024** / 1K tokenů Vstup · Čtení z mezipaměti **$0.00012** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguraceAnthropic Messages · Základní sazby za tokeny | Tabulka sazebZákladní sazba | Tokeny kontextu, více než— | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.0006** / 1K tokenů Výstup · Výstupní tokeny **$0.0024** / 1K tokenů Vstup · Čtení z mezipaměti **$0.00012** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguraceAnthropic Messages · Úroveň 1 podle délky požadavku | Tabulka sazeb— | Tokeny kontextu, více než0 | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.0006** / 1K tokenů Výstup · Výstupní tokeny **$0.0024** / 1K tokenů Vstup · Čtení z mezipaměti **$0.00012** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
### Příklady požadavků
#### Ailoot · OpenAI Responses
Textový příkladVstup, obrázekPython SDKNode.js SDKStreamování v Pythonu
```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_TEXT_FILE:?Set your actual UTF-8 source-material file}"
export AILOOT_TEXT_FILE
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model": "minimax-text-latest", "input": ""}')
f=Path(os.environ["AILOOT_TEXT_FILE"])
if not f.is_file():raise SystemExit("Choose your actual UTF-8 source material")
text=f.read_text(encoding="utf-8")
if not text.strip():raise SystemExit("Source material must contain text")
p["input"]="Summarize this material and quote supporting source passages.\n\n"+text
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/responses \
-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 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(json.loads(Path("result.json").read_text(encoding="utf-8")))
PY_RESULT
```
```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_IMAGE_FILE:?Set your actual PNG JPEG or WebP image}"
export AILOOT_IMAGE_FILE
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model": "minimax-text-latest", "input": [{"role": "user", "content": [{"type": "input_text", "text": "Read labels and numbers in this image; flag unreadable text."}]}]}')
import base64
f=Path(os.environ["AILOOT_IMAGE_FILE"])
if not f.is_file():raise SystemExit("Choose an actual PNG JPEG or WebP image")
raw=f.read_bytes()
mime="image/png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "image/jpeg" if raw.startswith(b"\xff\xd8") else "image/webp" if raw[:4]==b"RIFF" and raw[8:12]==b"WEBP" else None
if not mime:raise SystemExit("Use PNG JPEG or WebP")
b64=base64.b64encode(raw).decode()
p["input"][0]["content"].append({"type":"input_image","image_url":"data:"+mime+";base64,"+b64})
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/responses \
-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 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(json.loads(Path("result.json").read_text(encoding="utf-8")))
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)
resp = client.responses.create(model="minimax-text-latest", input="Explain the difference between an observation and a hypothesis 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(resp.to_dict(mode="json"))
```
```js
import OpenAI from "openai";
if (!process.env.AILOOT_API_KEY?.trim()) throw new Error("Set AILOOT_API_KEY before making a request");
const client = new OpenAI({ baseURL: "https://api.ailoot.ai/v1", apiKey: process.env.AILOOT_API_KEY, maxRetries: 0 });
const resp = await client.responses.create({ model: "minimax-text-latest", input: "Explain the difference between an observation and a hypothesis in three sentences." });
import { writeFileSync } from "node:fs";
function saveResult(data, stem = "result") {
writeFileSync(stem + ".json", JSON.stringify(data, null, 2));
console.log(JSON.stringify(data, null, 2));
const saveBlob = (encoded, suffix, label) => {
const raw = Buffer.from(encoded, "base64");
const ext = raw.subarray(0,8).equals(Buffer.from([137,80,78,71,13,10,26,10])) ? "png" : raw[0]===255 && raw[1]===216 ? "jpg" : raw.subarray(0,4).toString()==="RIFF" && raw.subarray(8,12).toString()==="WEBP" ? "webp" : suffix;
const file = `${stem}-${label}.${ext}`;
writeFileSync(file, raw); console.log("Saved", file);
};
for (const [i, block] of (data.content || []).entries()) console.log("Content", i, JSON.stringify(block));
for (const choice of data.choices || []) console.log("Choice", choice.index, JSON.stringify(choice.message || choice.delta || {}));
for (const [i, item] of (data.output || []).entries()) {
console.log("Output", i, JSON.stringify(item));
if (item.type === "image_generation_call" && item.result) saveBlob(item.result, item.output_format || "bin", `output-${i}`);
}
for (const [ci, candidate] of (data.candidates || []).entries()) {
for (const [pi, part] of (candidate.content?.parts || []).entries()) {
console.log("Candidate/part", ci, pi, JSON.stringify(part));
const blob = part.inlineData || part.inline_data;
if (blob?.data) {
const mime = blob.mimeType || blob.mime_type;
const suffix = ({"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"})[mime] || "bin";
saveBlob(blob.data, suffix, `candidate-${ci}-part-${pi}`);
}
}
}
}
saveResult(resp);
```
```python
from openai import OpenAI
import os
from pathlib import Path
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))
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)
with client.responses.stream(model="minimax-text-latest", input="Explain the difference between an observation and a hypothesis 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_response()
save_result(final.to_dict(mode="json"),"stream-result")
```
### Přijímání a ukládání výsledků
#### Ailoot · OpenAI Responses
json nebo SSE
##### Uchovejte všechny dokončené výsledky
Uchovejte každou úplnou vrácenou odpověď, soubor i část obsahu.
Zachovejte každou výstupní položku a část obsahu, skutečné call\_id funkce, šifrované uvažování a údaje o využití. Při streamování uchovejte úplnou identitu události/položky.
##### Pokud je nutné ověřit původní odpověď
Zachovejte ID požadavků/odpovědí a hlavičky. Není dodána obecná URL pro načtení textové úlohy.
Pole odpovědi
| Pole | Typ |
| --- | --- |
| Pole`id` | Typstring |
| Pole`status` | Typstring |
| Pole`output[]` | Typmessage\|reasoning\|function\_call\|other item |
| Pole`output[].content[]` | Typcontent part |
| Pole`usage` | Typobject |
Chyby a další kroky
| Odpověď | Podmínka | Další krok |
| --- | --- | --- |
| Odpověď400 · `invalid_request_error` | PodmínkaNeplatná povinná pole, reprezentace podkladů nebo hodnota parametru | Další krokPřed novým požadavkem na vytvoření opravte uvedená pole. |
### Aliasy
#### Aliasy modelu
Ailoot [`MiniMax-M3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=MiniMax-M3&fmt=responses), [`minimax`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax&fmt=responses), [`minimax-latest`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-latest&fmt=responses), [`minimax-text`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-text&fmt=responses), [`minimax-text-latest`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-text-latest&fmt=responses), [`minimax/minimax-m3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax%2Fminimax-m3&fmt=responses)
**Ailoot Ultra** [`MiniMax-M3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Ultra&caller=MiniMax-M3), [`minimax/minimax-m3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Ultra&caller=minimax%2Fminimax-m3)
#### Aliasy cest metod
`/chat/completions`
#### Související ID modelů
[`minimax/minimax-m3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax%2Fminimax-m3&fmt=responses), [`minimax/minimax-m3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Ultra&caller=minimax%2Fminimax-m3), [`minimax`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax&fmt=responses), [`minimax-latest`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-latest&fmt=responses), [`minimax-text`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-text&fmt=responses), [`minimax-text-latest`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-text-latest&fmt=responses), [`MiniMax-M3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=MiniMax-M3&fmt=responses), [`MiniMax-M3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Ultra&caller=MiniMax-M3)
**Ailoot · OpenAI Chat** `POST /v1/chat/completions` `minimax-text-latest`
[`minimax-text-latest`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-text-latest&fmt=chat)
MiniMax /`minimax-text-latest`
ID modelu
- `MiniMax-M3`
- `minimax`
- `minimax-latest`
- `minimax-text`
- `minimax-text-latest`
- `minimax/minimax-m3`
### Úvod
MiniMax M3 je multimodální model pro dlouhodobou práci na kódu a agentní úlohy, který využívá MiniMax Sparse Attention a návrh pro dlouhý kontext. Uvedená chatová rozhraní Ultra přijímají text a vracejí textové odpovědi.
Přijímané vstupy
Text · Obrázky
Výsledky
Text
### Dostupné v Ailoot · vstupy a metody
**Ailoot · OpenAI Chat** `POST /v1/chat/completions`
Vstup
`text`, `image`
Výstup
`text`
Kontext
1 000 000 tokens
Maximální výstup
524 288 tokens
Výstupní formát
json nebo SSE
| Pole | Typ | Požadavek | Hodnoty a limity | Výchozí |
| --- | --- | --- | --- | --- |
| Pole`model` | Typ`string` | PožadavekPovinné | Hodnoty a limity minimax-text-latest | Výchozí— |
| Pole`messages` | Typ`message[]` | PožadavekPovinné | Hodnoty a limity Minimální počet položek: 1 | Výchozí— |
| Pole`messages[].role` | Typ`string` | PožadavekPovinné | Hodnoty a limity Příklady: system, user, assistant, tool, function Podmínky: Tyto role jsou výslovně zastoupeny typy kompatibility zdrojového kódu; přesná sada rolí zůstává specifická pro daný model. Závisí na modelu | Výchozí— |
| Pole`messages[].content` | Typ`string\|content_part[]\|null` | PožadavekVolitelné | Hodnoty a limity | Výchozí— |
| Pole`messages[].tool_calls` | Typ`tool_call[]` | PožadavekVolitelné | Hodnoty a limity | Výchozí— |
| Pole`messages[].tool_call_id` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Platí, když: role=tool; použijte skutečně vrácené ID | Výchozí— |
| Pole`messages[].name` | Typ`string` | PožadavekVolitelné | Hodnoty a limity | Výchozí— |
| Pole`messages[].reasoning_content` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Platí, když: Předávejte zpět skutečně vrácené uvažování tam, kde je tento model používá | Výchozí— |
| Pole`messages[].reasoning_details` | Typ`object\|array` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`max_tokens` | Typ`integer` | PožadavekVolitelné | Hodnoty a limity Minimum: 1 Závisí na modelu | Výchozí— |
| Pole`max_completion_tokens` | Typ`integer` | PožadavekVolitelné | Hodnoty a limity Minimum: 1 Závisí na modelu | Výchozí— |
| Pole`stream` | Typ`boolean` | PožadavekVolitelné | Hodnoty a limity | Výchozífalse |
| Pole`stream_options.include_usage` | Typ`boolean` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`temperature` | Typ`number` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`top_p` | Typ`number` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`stop` | Typ`string\|string[]` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`tools` | Typ`function_tool[]` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`tools[].type` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`tools[].function.name` | Typ`string` | PožadavekPovinné | Hodnoty a limity Platí, když: nástroj typu funkce je dodán | Výchozí— |
| Pole`tools[].function.description` | Typ`string` | PožadavekVolitelné | Hodnoty a limity | Výchozí— |
| Pole`tools[].function.parameters` | Typ`JSON_schema` | PožadavekVolitelné | Hodnoty a limity | Výchozí— |
| Pole`tool_choice` | Typ`string\|object` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`parallel_tool_calls` | Typ`boolean` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`response_format` | Typ`object` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`reasoning_effort` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`reasoning` | Typ`object` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`service_tier` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`instructions` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Pole kompatibility | Výchozí— |
| Pole`functions` | Typ`function[]` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`function_call` | Typ`string\|object` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`prompt_cache_options` | Typ`object` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
Kombinace vstupních materiálů
**Text** · text UTF8
`messages[].content`
**Text + obrázek**
`{type:image_url,image_url:{url,detail}}`
Parametry a životní cyklus metody
| Parametr | Kontrakt |
| --- | --- |
| Parametr`material_types` | Kontrakttext, image |
| Parametr`required` | Kontraktmodel, messages |
| Parametr`optional_controls` | Kontraktnull |
| Parametr`content_type` | Kontraktapplication/json |
| Parametr`text_file_material` | Kontraktskutečný obsah UTF-8 vložený jako text; ID/URLs souborů vyžadují samostatnou přesně vymezenou podporu |
Životní cyklus: `exact retained published method`
Struktury metod a ID jsou přesné; schopnosti dodavatele jsou oddělené od připuštění požadavku.
### Tarify
#### Sazby metod Ailoot
Vstup
0,0003 US$ */ 1K*
Výstup
0,0012 US$ */ 1K*
Čtení z mezipaměti
≈0,00006 US$ */ 1K*
Zápis do mezipaměti
0,0003 US$ */ 1K*
Zápis do mezipaměti, 5 min
0,0003 US$ */ 1K tokens*
#### Ceny podle délky požadavku · OpenAI Chat
| Velikost požadavku v tokenech | Vstup | Výstup | Čtení z mezipaměti | Zápis do mezipaměti | Mezipaměť 5 min | Mezipaměť 1 hodina |
| --- | --- | --- | --- | --- | --- | --- |
| Velikost požadavku v tokenech(0; 524 288\] | Vstup0,0003 US$ | Výstup0,0012 US$ | Čtení z mezipaměti≈0,00006 US$ | Zápis do mezipaměti0,0003 US$ | Mezipaměť 5 min0,0003 US$ | Mezipaměť 1 hodinaZákladní: — |
| Velikost požadavku v tokenech(524 288; 1 000 000\] | Vstup0,0006 US$ | Výstup0,0024 US$ | Čtení z mezipaměti≈0,00012 US$ | Zápis do mezipaměti0,0006 US$ | Mezipaměť 5 min0,0006 US$ | Mezipaměť 1 hodinaZákladní: — |
Sazby v USD za 1K tokenů. Není-li sazba nastavena, použije se zděděná základní sazba této metody; «—» znamená, že základní sazba není nastavena.
Ailoot před požadavkem rezervuje odhadovanou částku. Po výsledku vyúčtuje konečný poplatek podle naměřeného využití. Při streamování se účtování řídí konečným záznamem využití. [Jak funguje rezervace a vyúčtování →](https://ailoot.ai/docs/cs/billing/reserve/)
#### Podrobnosti referenčního tarifu
Referenční tabulky modelu nemění výběr metody, cenové nabídky ani poplatky. Skutečné poplatky používají sazby vybrané metody Ailoot.
Referenční tabulky modelu
#### Ceny podle konfigurace
Přiřaďte každý poplatek k uvedeným podmínkám. Pro každou sadu alternativních konfigurací použijte jednu sazbu.
| Konfigurace | Tabulka sazeb | Tokeny kontextu, více než | Tokeny kontextu, do uvedené hodnoty včetně | Poplatek |
| --- | --- | --- | --- | --- |
| KonfiguraceOpenAI Chat · Základní sazby za tokeny | Tabulka sazebZákladní sazba | Tokeny kontextu, více než— | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.0006** / 1K tokenů Výstup · Výstupní tokeny **$0.0024** / 1K tokenů Vstup · Čtení z mezipaměti **$0.00012** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguraceOpenAI Chat · Úroveň 1 podle délky požadavku | Tabulka sazeb— | Tokeny kontextu, více než0 | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.0006** / 1K tokenů Výstup · Výstupní tokeny **$0.0024** / 1K tokenů Vstup · Čtení z mezipaměti **$0.00012** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguraceAnthropic Messages · Základní sazby za tokeny | Tabulka sazebZákladní sazba | Tokeny kontextu, více než— | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.0006** / 1K tokenů Výstup · Výstupní tokeny **$0.0024** / 1K tokenů Vstup · Čtení z mezipaměti **$0.00012** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguraceAnthropic Messages · Úroveň 1 podle délky požadavku | Tabulka sazeb— | Tokeny kontextu, více než0 | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.0006** / 1K tokenů Výstup · Výstupní tokeny **$0.0024** / 1K tokenů Vstup · Čtení z mezipaměti **$0.00012** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
### Příklady požadavků
#### Ailoot · OpenAI Chat
Textový příkladVstup, obrázekPython SDKNode.js SDKStreamování v Pythonu
```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_TEXT_FILE:?Set your actual UTF-8 source-material file}"
export AILOOT_TEXT_FILE
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model": "minimax-text-latest", "messages": []}')
f=Path(os.environ["AILOOT_TEXT_FILE"])
if not f.is_file():raise SystemExit("Choose your actual UTF-8 source material")
text=f.read_text(encoding="utf-8")
if not text.strip():raise SystemExit("Source material must contain text")
p["messages"]=[{"role":"user","content":"Summarize this material and quote supporting source passages.\n\n"+text}]
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
print(json.dumps(json.loads(Path("result.json").read_text()),ensure_ascii=False,indent=2))
PY_RESULT
```
```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_IMAGE_FILE:?Set your actual PNG JPEG or WebP image}"
export AILOOT_IMAGE_FILE
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model": "minimax-text-latest", "messages": [{"role": "user", "content": [{"type": "text", "text": "Read labels and numbers in this image; flag unreadable text."}]}]}')
import base64
f=Path(os.environ["AILOOT_IMAGE_FILE"])
if not f.is_file():raise SystemExit("Choose an actual PNG JPEG or WebP image")
raw=f.read_bytes()
mime="image/png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "image/jpeg" if raw.startswith(b"\xff\xd8") else "image/webp" if raw[:4]==b"RIFF" and raw[8:12]==b"WEBP" else None
if not mime:raise SystemExit("Use PNG JPEG or WebP")
b64=base64.b64encode(raw).decode()
p["messages"][0]["content"].append({"type":"image_url","image_url":{"url":"data:"+mime+";base64,"+b64}})
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
print(json.dumps(json.loads(Path("result.json").read_text()),ensure_ascii=False,indent=2))
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)
resp = client.chat.completions.create(
model="minimax-text-latest",
messages=[{"role": "user", "content": "Explain the difference between an observation and a hypothesis 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(resp.to_dict(mode="json"))
```
```js
import OpenAI from "openai";
if (!process.env.AILOOT_API_KEY?.trim()) throw new Error("Set AILOOT_API_KEY before making a request");
const client = new OpenAI({ baseURL: "https://api.ailoot.ai/v1", apiKey: process.env.AILOOT_API_KEY, maxRetries: 0 });
const resp = await client.chat.completions.create({
model: "minimax-text-latest",
messages: [{ role: "user", content: "Explain the difference between an observation and a hypothesis in three sentences." }],
});
import { writeFileSync } from "node:fs";
function saveResult(data, stem = "result") {
writeFileSync(stem + ".json", JSON.stringify(data, null, 2));
console.log(JSON.stringify(data, null, 2));
const saveBlob = (encoded, suffix, label) => {
const raw = Buffer.from(encoded, "base64");
const ext = raw.subarray(0,8).equals(Buffer.from([137,80,78,71,13,10,26,10])) ? "png" : raw[0]===255 && raw[1]===216 ? "jpg" : raw.subarray(0,4).toString()==="RIFF" && raw.subarray(8,12).toString()==="WEBP" ? "webp" : suffix;
const file = `${stem}-${label}.${ext}`;
writeFileSync(file, raw); console.log("Saved", file);
};
for (const [i, block] of (data.content || []).entries()) console.log("Content", i, JSON.stringify(block));
for (const choice of data.choices || []) console.log("Choice", choice.index, JSON.stringify(choice.message || choice.delta || {}));
for (const [i, item] of (data.output || []).entries()) {
console.log("Output", i, JSON.stringify(item));
if (item.type === "image_generation_call" && item.result) saveBlob(item.result, item.output_format || "bin", `output-${i}`);
}
for (const [ci, candidate] of (data.candidates || []).entries()) {
for (const [pi, part] of (candidate.content?.parts || []).entries()) {
console.log("Candidate/part", ci, pi, JSON.stringify(part));
const blob = part.inlineData || part.inline_data;
if (blob?.data) {
const mime = blob.mimeType || blob.mime_type;
const suffix = ({"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"})[mime] || "bin";
saveBlob(blob.data, suffix, `candidate-${ci}-part-${pi}`);
}
}
}
}
saveResult(resp);
```
```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='minimax-text-latest',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")
```
### Přijímání a ukládání výsledků
#### Ailoot · OpenAI Chat
json nebo SSE
##### Uchovejte všechny dokončené výsledky
Uchovejte každou úplnou vrácenou odpověď, soubor i část obsahu.
Zachovejte každou volbu a její obsah/volání nástrojů/uvažování. V SSE sestavujte přírůstky podle indexu volby/nástroje a zachovejte konečný důvod ukončení i údaje o využití.
##### Pokud je nutné ověřit původní odpověď
Zachovejte ID požadavků/odpovědí a hlavičky. Není dodána obecná URL pro načtení textové úlohy.
Pole odpovědi
| Pole | Typ |
| --- | --- |
| Pole`choices[].index` | Typinteger |
| Pole`choices[].message.content` | Typstring\|null |
| Pole`choices[].message.tool_calls` | Typtool\_call\[\] |
| Pole`choices[].message.reasoning_content` | Typstring |
| Pole`choices[].message.reasoning_details` | Typobject\|array |
| Pole`choices[].finish_reason` | Typstring\|null |
| Pole`usage` | Typobject |
Chyby a další kroky
| Odpověď | Podmínka | Další krok |
| --- | --- | --- |
| Odpověď400 · `invalid_request_error` | PodmínkaNeplatná povinná pole, reprezentace podkladů nebo hodnota parametru | Další krokPřed novým požadavkem na vytvoření opravte uvedená pole. |
### Aliasy
#### Aliasy modelu
Ailoot [`MiniMax-M3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=MiniMax-M3&fmt=chat), [`minimax`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax&fmt=chat), [`minimax-latest`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-latest&fmt=chat), [`minimax-text`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-text&fmt=chat), [`minimax-text-latest`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-text-latest&fmt=chat), [`minimax/minimax-m3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax%2Fminimax-m3&fmt=chat)
**Ailoot Ultra** [`MiniMax-M3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Ultra&caller=MiniMax-M3&fmt=chat), [`minimax/minimax-m3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Ultra&caller=minimax%2Fminimax-m3&fmt=chat)
#### Aliasy cest metod
`/chat/completions`
#### Související ID modelů
[`minimax/minimax-m3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax%2Fminimax-m3&fmt=chat), [`minimax/minimax-m3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Ultra&caller=minimax%2Fminimax-m3&fmt=chat), [`minimax`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax&fmt=chat), [`minimax-latest`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-latest&fmt=chat), [`minimax-text`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-text&fmt=chat), [`minimax-text-latest`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-text-latest&fmt=chat), [`MiniMax-M3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=MiniMax-M3&fmt=chat), [`MiniMax-M3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Ultra&caller=MiniMax-M3&fmt=chat)
**Ailoot · Anthropic Messages** `POST /v1/messages` `minimax/minimax-m3`
[`minimax/minimax-m3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax%2Fminimax-m3&fmt=messages)
MiniMax /`minimax/minimax-m3`
ID modelu
- `MiniMax-M3`
- `minimax`
- `minimax-latest`
- `minimax-text`
- `minimax-text-latest`
- `minimax/minimax-m3`
### Úvod
MiniMax M3 je multimodální model pro dlouhodobou práci na kódu a agentní úlohy, který využívá MiniMax Sparse Attention a návrh pro dlouhý kontext. Uvedená chatová rozhraní Ultra přijímají text a vracejí textové odpovědi.
Přijímané vstupy
Text · Obrázky
Výsledky
Text
### Dostupné v Ailoot · vstupy a metody
**Ailoot · Anthropic Messages** `POST /v1/messages`
Vstup
`text`, `image`
Výstup
`text`
Kontext
1 000 000 tokens
Maximální výstup
524 288 tokens
Výstupní formát
json nebo SSE
| Pole | Typ | Požadavek | Hodnoty a limity | Výchozí |
| --- | --- | --- | --- | --- |
| Pole`model` | Typ`string` | PožadavekPovinné | Hodnoty a limity minimax/minimax-m3 | Výchozí— |
| Pole`messages` | Typ`message[]` | PožadavekPovinné | Hodnoty a limity Minimální počet položek: 1 | Výchozí— |
| Pole`messages[].role` | Typ`string` | PožadavekPovinné | Hodnoty a limity user, assistant | Výchozí— |
| Pole`messages[].content` | Typ`string\|content_block[]` | PožadavekPovinné | Hodnoty a limity | Výchozí— |
| Pole`system` | Typ`string\|content_block[]` | PožadavekVolitelné | Hodnoty a limity | Výchozí— |
| Pole`max_tokens` | Typ`integer` | PožadavekPovinné | Hodnoty a limity Minimum: 1 Limit platí pro: přesný limit vybraného modelu/karty | Výchozí— |
| Pole`stream` | Typ`boolean` | PožadavekVolitelné | Hodnoty a limity | Výchozífalse |
| Pole`temperature` | Typ`number` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`top_p` | Typ`number` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`stop_sequences` | Typ`string[]` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`tools` | Typ`tool[]` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`tools[].name` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Platí, když: nástroj je dodán | Výchozí— |
| Pole`tools[].description` | Typ`string` | PožadavekVolitelné | Hodnoty a limity | Výchozí— |
| Pole`tools[].input_schema` | Typ`JSON_schema` | PožadavekVolitelné | Hodnoty a limity | Výchozí— |
| Pole`tool_choice` | Typ`object` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`thinking.type` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`thinking.budget_tokens` | Typ`integer` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`output_config.effort` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`metadata` | Typ`object` | PožadavekVolitelné | Hodnoty a limity | Výchozí— |
| Pole`cache_control` | Typ`object` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
Kombinace vstupních materiálů
**Text** · text UTF8
`messages[].content nebo blok type=text`
**Text + obrázek**
`{type:image,source:{type:base64,media_type,data}} nebo zdroj type=url`
Parametry a životní cyklus metody
| Parametr | Kontrakt |
| --- | --- |
| Parametr`material_types` | Kontrakttext, image |
| Parametr`required` | Kontraktmodel, messages, max\_tokens |
| Parametr`optional_controls` | Kontraktnull |
| Parametr`content_type` | Kontraktapplication/json |
| Parametr`text_file_material` | Kontraktskutečný obsah UTF-8 vložený jako text; ID/URLs souborů vyžadují samostatnou přesně vymezenou podporu |
Životní cyklus: `exact retained published method`
Struktury metod a ID jsou přesné; schopnosti dodavatele jsou oddělené od připuštění požadavku.
### Tarify
#### Sazby metod Ailoot
Vstup
0,0003 US$ */ 1K*
Výstup
0,0012 US$ */ 1K*
Čtení z mezipaměti
≈0,00006 US$ */ 1K*
Zápis do mezipaměti
0,0003 US$ */ 1K*
Zápis do mezipaměti, 5 min
0,0003 US$ */ 1K tokens*
#### Ceny podle délky požadavku · Anthropic Messages
| Velikost požadavku v tokenech | Vstup | Výstup | Čtení z mezipaměti | Zápis do mezipaměti | Mezipaměť 5 min | Mezipaměť 1 hodina |
| --- | --- | --- | --- | --- | --- | --- |
| Velikost požadavku v tokenech(0; 524 288\] | Vstup0,0003 US$ | Výstup0,0012 US$ | Čtení z mezipaměti≈0,00006 US$ | Zápis do mezipaměti0,0003 US$ | Mezipaměť 5 min0,0003 US$ | Mezipaměť 1 hodinaZákladní: — |
| Velikost požadavku v tokenech(524 288; 1 000 000\] | Vstup0,0006 US$ | Výstup0,0024 US$ | Čtení z mezipaměti≈0,00012 US$ | Zápis do mezipaměti0,0006 US$ | Mezipaměť 5 min0,0006 US$ | Mezipaměť 1 hodinaZákladní: — |
Sazby v USD za 1K tokenů. Není-li sazba nastavena, použije se zděděná základní sazba této metody; «—» znamená, že základní sazba není nastavena.
Ailoot před požadavkem rezervuje odhadovanou částku. Po výsledku vyúčtuje konečný poplatek podle naměřeného využití. Při streamování se účtování řídí konečným záznamem využití. [Jak funguje rezervace a vyúčtování →](https://ailoot.ai/docs/cs/billing/reserve/)
#### Podrobnosti referenčního tarifu
Referenční tabulky modelu nemění výběr metody, cenové nabídky ani poplatky. Skutečné poplatky používají sazby vybrané metody Ailoot.
Referenční tabulky modelu
#### Ceny podle konfigurace
Přiřaďte každý poplatek k uvedeným podmínkám. Pro každou sadu alternativních konfigurací použijte jednu sazbu.
| Konfigurace | Tabulka sazeb | Tokeny kontextu, více než | Tokeny kontextu, do uvedené hodnoty včetně | Poplatek |
| --- | --- | --- | --- | --- |
| KonfiguraceOpenAI Chat · Základní sazby za tokeny | Tabulka sazebZákladní sazba | Tokeny kontextu, více než— | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.0006** / 1K tokenů Výstup · Výstupní tokeny **$0.0024** / 1K tokenů Vstup · Čtení z mezipaměti **$0.00012** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguraceOpenAI Chat · Úroveň 1 podle délky požadavku | Tabulka sazeb— | Tokeny kontextu, více než0 | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.0006** / 1K tokenů Výstup · Výstupní tokeny **$0.0024** / 1K tokenů Vstup · Čtení z mezipaměti **$0.00012** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguraceAnthropic Messages · Základní sazby za tokeny | Tabulka sazebZákladní sazba | Tokeny kontextu, více než— | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.0006** / 1K tokenů Výstup · Výstupní tokeny **$0.0024** / 1K tokenů Vstup · Čtení z mezipaměti **$0.00012** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguraceAnthropic Messages · Úroveň 1 podle délky požadavku | Tabulka sazeb— | Tokeny kontextu, více než0 | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.0006** / 1K tokenů Výstup · Výstupní tokeny **$0.0024** / 1K tokenů Vstup · Čtení z mezipaměti **$0.00012** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
### Příklady požadavků
#### Ailoot · Anthropic Messages
Textový příkladVstup, obrázekPython SDKNode.js SDKStreamování v Pythonu
```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_TEXT_FILE:?Set your actual UTF-8 source-material file}"
export AILOOT_TEXT_FILE
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model": "minimax/minimax-m3", "max_tokens": 1024, "messages": []}')
f=Path(os.environ["AILOOT_TEXT_FILE"])
if not f.is_file():raise SystemExit("Choose your actual UTF-8 source material")
text=f.read_text(encoding="utf-8")
if not text.strip():raise SystemExit("Source material must contain text")
p["messages"]=[{"role":"user","content":"Summarize this material and quote supporting source passages.\n\n"+text}]
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/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
print(json.dumps(json.loads(Path("result.json").read_text()),ensure_ascii=False,indent=2))
PY_RESULT
```
```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_IMAGE_FILE:?Set your actual PNG JPEG or WebP image}"
export AILOOT_IMAGE_FILE
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model": "minimax/minimax-m3", "max_tokens": 1024, "messages": [{"role": "user", "content": [{"type": "text", "text": "Read labels and numbers in this image; flag unreadable text."}]}]}')
import base64
f=Path(os.environ["AILOOT_IMAGE_FILE"])
if not f.is_file():raise SystemExit("Choose an actual PNG JPEG or WebP image")
raw=f.read_bytes()
mime="image/png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "image/jpeg" if raw.startswith(b"\xff\xd8") else "image/webp" if raw[:4]==b"RIFF" and raw[8:12]==b"WEBP" else None
if not mime:raise SystemExit("Use PNG JPEG or WebP")
b64=base64.b64encode(raw).decode()
p["messages"][0]["content"].append({"type":"image","source":{"type":"base64","media_type":mime,"data":b64}})
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/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
print(json.dumps(json.loads(Path("result.json").read_text()),ensure_ascii=False,indent=2))
PY_RESULT
```
```python
import anthropic
import os
if not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")
client = anthropic.Anthropic(base_url="https://api.ailoot.ai", api_key=os.environ["AILOOT_API_KEY"], max_retries=0)
msg = client.messages.create(
model="minimax/minimax-m3",
max_tokens=1024,
messages=[{"role": "user", "content": "Explain the difference between an observation and a hypothesis 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(msg.to_dict(mode="json"))
```
```js
import Anthropic from "@anthropic-ai/sdk";
if (!process.env.AILOOT_API_KEY?.trim()) throw new Error("Set AILOOT_API_KEY before making a request");
const client = new Anthropic({ baseURL: "https://api.ailoot.ai", apiKey: process.env.AILOOT_API_KEY, maxRetries: 0 });
const msg = await client.messages.create({
model: "minimax/minimax-m3",
max_tokens: 1024,
messages: [{ role: "user", content: "Explain the difference between an observation and a hypothesis in three sentences." }],
});
import { writeFileSync } from "node:fs";
function saveResult(data, stem = "result") {
writeFileSync(stem + ".json", JSON.stringify(data, null, 2));
console.log(JSON.stringify(data, null, 2));
const saveBlob = (encoded, suffix, label) => {
const raw = Buffer.from(encoded, "base64");
const ext = raw.subarray(0,8).equals(Buffer.from([137,80,78,71,13,10,26,10])) ? "png" : raw[0]===255 && raw[1]===216 ? "jpg" : raw.subarray(0,4).toString()==="RIFF" && raw.subarray(8,12).toString()==="WEBP" ? "webp" : suffix;
const file = `${stem}-${label}.${ext}`;
writeFileSync(file, raw); console.log("Saved", file);
};
for (const [i, block] of (data.content || []).entries()) console.log("Content", i, JSON.stringify(block));
for (const choice of data.choices || []) console.log("Choice", choice.index, JSON.stringify(choice.message || choice.delta || {}));
for (const [i, item] of (data.output || []).entries()) {
console.log("Output", i, JSON.stringify(item));
if (item.type === "image_generation_call" && item.result) saveBlob(item.result, item.output_format || "bin", `output-${i}`);
}
for (const [ci, candidate] of (data.candidates || []).entries()) {
for (const [pi, part] of (candidate.content?.parts || []).entries()) {
console.log("Candidate/part", ci, pi, JSON.stringify(part));
const blob = part.inlineData || part.inline_data;
if (blob?.data) {
const mime = blob.mimeType || blob.mime_type;
const suffix = ({"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"})[mime] || "bin";
saveBlob(blob.data, suffix, `candidate-${ci}-part-${pi}`);
}
}
}
}
saveResult(msg);
```
```python
import anthropic,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=anthropic.Anthropic(base_url="https://api.ailoot.ai",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.messages.stream(model='minimax/minimax-m3',max_tokens=1024,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_message()
save_result(final.to_dict(mode="json"),"stream-result")
```
### Přijímání a ukládání výsledků
#### Ailoot · Anthropic Messages
json nebo SSE
##### Uchovejte všechny dokončené výsledky
Uchovejte každou úplnou vrácenou odpověď, soubor i část obsahu.
Zachovejte všechny bloky obsahu, podpisy uvažování a skutečná ID použití nástrojů. Sestavte všechny přírůstky bloků SSE; první textový blok není úplný výstup.
##### Pokud je nutné ověřit původní odpověď
Zachovejte ID požadavků/odpovědí a hlavičky. Není dodána obecná URL pro načtení textové úlohy.
Pole odpovědi
| Pole | Typ |
| --- | --- |
| Pole`id` | Typstring |
| Pole`model` | Typstring |
| Pole`content[]` | Typtext\|thinking\|tool\_use\|other content block |
| Pole`stop_reason` | Typstring\|null |
| Pole`usage` | Typobject |
Chyby a další kroky
| Odpověď | Podmínka | Další krok |
| --- | --- | --- |
| Odpověď400 · `invalid_request_error` | PodmínkaNeplatná povinná pole, reprezentace podkladů nebo hodnota parametru | Další krokPřed novým požadavkem na vytvoření opravte uvedená pole. |
### Aliasy
#### Aliasy modelu
Ailoot [`MiniMax-M3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=MiniMax-M3&fmt=messages), [`minimax`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax&fmt=messages), [`minimax-latest`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-latest&fmt=messages), [`minimax-text`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-text&fmt=messages), [`minimax-text-latest`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-text-latest&fmt=messages), [`minimax/minimax-m3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax%2Fminimax-m3&fmt=messages)
**Ailoot Ultra** [`MiniMax-M3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Ultra&caller=MiniMax-M3&fmt=messages), [`minimax/minimax-m3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Ultra&caller=minimax%2Fminimax-m3&fmt=messages)
#### Aliasy cest metod
`/chat/completions`
#### Související ID modelů
[`minimax/minimax-m3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax%2Fminimax-m3&fmt=messages), [`minimax/minimax-m3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Ultra&caller=minimax%2Fminimax-m3&fmt=messages), [`minimax`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax&fmt=messages), [`minimax-latest`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-latest&fmt=messages), [`minimax-text`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-text&fmt=messages), [`minimax-text-latest`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-text-latest&fmt=messages), [`MiniMax-M3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=MiniMax-M3&fmt=messages), [`MiniMax-M3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Ultra&caller=MiniMax-M3&fmt=messages)
**Ailoot · OpenAI Responses** `POST /v1/responses` `minimax/minimax-m3`
[`minimax/minimax-m3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax%2Fminimax-m3&fmt=responses)
MiniMax /`minimax/minimax-m3`
ID modelu
- `MiniMax-M3`
- `minimax`
- `minimax-latest`
- `minimax-text`
- `minimax-text-latest`
- `minimax/minimax-m3`
### Úvod
MiniMax M3 je multimodální model pro dlouhodobou práci na kódu a agentní úlohy, který využívá MiniMax Sparse Attention a návrh pro dlouhý kontext. Uvedená chatová rozhraní Ultra přijímají text a vracejí textové odpovědi.
Přijímané vstupy
Text · Obrázky
Výsledky
Text
### Dostupné v Ailoot · vstupy a metody
**Ailoot · OpenAI Responses** `POST /v1/responses`
Vstup
`text`, `image`
Výstup
`text`
Kontext
1 000 000 tokens
Maximální výstup
1 000 000 tokens
Výstupní formát
json nebo SSE
| Pole | Typ | Požadavek | Hodnoty a limity | Výchozí |
| --- | --- | --- | --- | --- |
| Pole`model` | Typ`string` | PožadavekPovinné | Hodnoty a limity minimax/minimax-m3 | Výchozí— |
| Pole`input` | Typ`string\|input_item[]` | PožadavekPovinné | Hodnoty a limity | Výchozí— |
| Pole`instructions` | Typ`string` | PožadavekVolitelné | Hodnoty a limity | Výchozí— |
| Pole`input[].type` | Typ`string` | PožadavekVolitelné | Hodnoty a limity message, reasoning, function\_call, function\_call\_output | Výchozí— |
| Pole`input[].content` | Typ`string\|content_part[]` | PožadavekVolitelné | Hodnoty a limity | Výchozí— |
| Pole`input[].call_id` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Platí, když: function\_call\_output; zachovejte skutečně vrácené call\_id | Výchozí— |
| Pole`input[].output` | Typ`string\|content_part[]` | PožadavekVolitelné | Hodnoty a limity Platí, když: function\_call\_output | Výchozí— |
| Pole`max_output_tokens` | Typ`integer` | PožadavekVolitelné | Hodnoty a limity Minimum: 1 Závisí na modelu | Výchozí— |
| Pole`stream` | Typ`boolean` | PožadavekVolitelné | Hodnoty a limity | Výchozífalse |
| Pole`temperature` | Typ`number` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`top_p` | Typ`number` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`tools` | Typ`tool[]` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`tool_choice` | Typ`string\|object` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`parallel_tool_calls` | Typ`boolean` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`reasoning.effort` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`reasoning.summary` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`text.format` | Typ`object` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`text.verbosity` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`include` | Typ`string[]` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`store` | Typ`boolean` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`previous_response_id` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Požadavek na ID: Pouze skutečné ID odpovědi z podporovaného pokračování Závisí na modelu | Výchozí— |
| Pole`service_tier` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`prompt_cache_key` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`prompt_cache_options` | Typ`object` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
Kombinace vstupních materiálů
**Text** · text UTF8
`vstupní text nebo část input_text`
**Text + obrázek**
`{type:input_image,image_url}`
Parametry a životní cyklus metody
| Parametr | Kontrakt |
| --- | --- |
| Parametr`material_types` | Kontrakttext, image |
| Parametr`required` | Kontraktmodel, input |
| Parametr`optional_controls` | Kontraktnull |
| Parametr`content_type` | Kontraktapplication/json |
| Parametr`text_file_material` | Kontraktskutečný obsah UTF-8 vložený jako text; ID/URLs souborů vyžadují samostatnou přesně vymezenou podporu |
Životní cyklus: `exact retained published method`
Struktury metod a ID jsou přesné; schopnosti dodavatele jsou oddělené od připuštění požadavku.
### Tarify
#### Sazby metod Ailoot
Vstup
0,0003 US$ */ 1K*
Výstup
0,0012 US$ */ 1K*
Čtení z mezipaměti
≈0,00006 US$ */ 1K*
Zápis do mezipaměti
0,0003 US$ */ 1K*
Zápis do mezipaměti, 5 min
0,0003 US$ */ 1K tokens*
#### Ceny podle délky požadavku · OpenAI Responses
| Velikost požadavku v tokenech | Vstup | Výstup | Čtení z mezipaměti | Zápis do mezipaměti | Mezipaměť 5 min | Mezipaměť 1 hodina |
| --- | --- | --- | --- | --- | --- | --- |
| Velikost požadavku v tokenech(0; 524 288\] | Vstup0,0003 US$ | Výstup0,0012 US$ | Čtení z mezipaměti≈0,00006 US$ | Zápis do mezipaměti0,0003 US$ | Mezipaměť 5 min0,0003 US$ | Mezipaměť 1 hodinaZákladní: — |
| Velikost požadavku v tokenech(524 288; 1 000 000\] | Vstup0,0006 US$ | Výstup0,0024 US$ | Čtení z mezipaměti≈0,00012 US$ | Zápis do mezipaměti0,0006 US$ | Mezipaměť 5 min0,0006 US$ | Mezipaměť 1 hodinaZákladní: — |
Sazby v USD za 1K tokenů. Není-li sazba nastavena, použije se zděděná základní sazba této metody; «—» znamená, že základní sazba není nastavena.
Ailoot před požadavkem rezervuje odhadovanou částku. Po výsledku vyúčtuje konečný poplatek podle naměřeného využití. Při streamování se účtování řídí konečným záznamem využití. [Jak funguje rezervace a vyúčtování →](https://ailoot.ai/docs/cs/billing/reserve/)
#### Podrobnosti referenčního tarifu
Referenční tabulky modelu nemění výběr metody, cenové nabídky ani poplatky. Skutečné poplatky používají sazby vybrané metody Ailoot.
Referenční tabulky modelu
#### Ceny podle konfigurace
Přiřaďte každý poplatek k uvedeným podmínkám. Pro každou sadu alternativních konfigurací použijte jednu sazbu.
| Konfigurace | Tabulka sazeb | Tokeny kontextu, více než | Tokeny kontextu, do uvedené hodnoty včetně | Poplatek |
| --- | --- | --- | --- | --- |
| KonfiguraceOpenAI Chat · Základní sazby za tokeny | Tabulka sazebZákladní sazba | Tokeny kontextu, více než— | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.0006** / 1K tokenů Výstup · Výstupní tokeny **$0.0024** / 1K tokenů Vstup · Čtení z mezipaměti **$0.00012** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguraceOpenAI Chat · Úroveň 1 podle délky požadavku | Tabulka sazeb— | Tokeny kontextu, více než0 | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.0006** / 1K tokenů Výstup · Výstupní tokeny **$0.0024** / 1K tokenů Vstup · Čtení z mezipaměti **$0.00012** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguraceAnthropic Messages · Základní sazby za tokeny | Tabulka sazebZákladní sazba | Tokeny kontextu, více než— | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.0006** / 1K tokenů Výstup · Výstupní tokeny **$0.0024** / 1K tokenů Vstup · Čtení z mezipaměti **$0.00012** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguraceAnthropic Messages · Úroveň 1 podle délky požadavku | Tabulka sazeb— | Tokeny kontextu, více než0 | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.0006** / 1K tokenů Výstup · Výstupní tokeny **$0.0024** / 1K tokenů Vstup · Čtení z mezipaměti **$0.00012** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
### Příklady požadavků
#### Ailoot · OpenAI Responses
Textový příkladVstup, obrázekPython SDKNode.js SDKStreamování v Pythonu
```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_TEXT_FILE:?Set your actual UTF-8 source-material file}"
export AILOOT_TEXT_FILE
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model": "minimax/minimax-m3", "input": ""}')
f=Path(os.environ["AILOOT_TEXT_FILE"])
if not f.is_file():raise SystemExit("Choose your actual UTF-8 source material")
text=f.read_text(encoding="utf-8")
if not text.strip():raise SystemExit("Source material must contain text")
p["input"]="Summarize this material and quote supporting source passages.\n\n"+text
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/responses \
-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 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(json.loads(Path("result.json").read_text(encoding="utf-8")))
PY_RESULT
```
```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_IMAGE_FILE:?Set your actual PNG JPEG or WebP image}"
export AILOOT_IMAGE_FILE
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model": "minimax/minimax-m3", "input": [{"role": "user", "content": [{"type": "input_text", "text": "Read labels and numbers in this image; flag unreadable text."}]}]}')
import base64
f=Path(os.environ["AILOOT_IMAGE_FILE"])
if not f.is_file():raise SystemExit("Choose an actual PNG JPEG or WebP image")
raw=f.read_bytes()
mime="image/png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "image/jpeg" if raw.startswith(b"\xff\xd8") else "image/webp" if raw[:4]==b"RIFF" and raw[8:12]==b"WEBP" else None
if not mime:raise SystemExit("Use PNG JPEG or WebP")
b64=base64.b64encode(raw).decode()
p["input"][0]["content"].append({"type":"input_image","image_url":"data:"+mime+";base64,"+b64})
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/responses \
-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 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(json.loads(Path("result.json").read_text(encoding="utf-8")))
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)
resp = client.responses.create(model="minimax/minimax-m3", input="Explain the difference between an observation and a hypothesis 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(resp.to_dict(mode="json"))
```
```js
import OpenAI from "openai";
if (!process.env.AILOOT_API_KEY?.trim()) throw new Error("Set AILOOT_API_KEY before making a request");
const client = new OpenAI({ baseURL: "https://api.ailoot.ai/v1", apiKey: process.env.AILOOT_API_KEY, maxRetries: 0 });
const resp = await client.responses.create({ model: "minimax/minimax-m3", input: "Explain the difference between an observation and a hypothesis in three sentences." });
import { writeFileSync } from "node:fs";
function saveResult(data, stem = "result") {
writeFileSync(stem + ".json", JSON.stringify(data, null, 2));
console.log(JSON.stringify(data, null, 2));
const saveBlob = (encoded, suffix, label) => {
const raw = Buffer.from(encoded, "base64");
const ext = raw.subarray(0,8).equals(Buffer.from([137,80,78,71,13,10,26,10])) ? "png" : raw[0]===255 && raw[1]===216 ? "jpg" : raw.subarray(0,4).toString()==="RIFF" && raw.subarray(8,12).toString()==="WEBP" ? "webp" : suffix;
const file = `${stem}-${label}.${ext}`;
writeFileSync(file, raw); console.log("Saved", file);
};
for (const [i, block] of (data.content || []).entries()) console.log("Content", i, JSON.stringify(block));
for (const choice of data.choices || []) console.log("Choice", choice.index, JSON.stringify(choice.message || choice.delta || {}));
for (const [i, item] of (data.output || []).entries()) {
console.log("Output", i, JSON.stringify(item));
if (item.type === "image_generation_call" && item.result) saveBlob(item.result, item.output_format || "bin", `output-${i}`);
}
for (const [ci, candidate] of (data.candidates || []).entries()) {
for (const [pi, part] of (candidate.content?.parts || []).entries()) {
console.log("Candidate/part", ci, pi, JSON.stringify(part));
const blob = part.inlineData || part.inline_data;
if (blob?.data) {
const mime = blob.mimeType || blob.mime_type;
const suffix = ({"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"})[mime] || "bin";
saveBlob(blob.data, suffix, `candidate-${ci}-part-${pi}`);
}
}
}
}
saveResult(resp);
```
```python
from openai import OpenAI
import os
from pathlib import Path
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))
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)
with client.responses.stream(model="minimax/minimax-m3", input="Explain the difference between an observation and a hypothesis 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_response()
save_result(final.to_dict(mode="json"),"stream-result")
```
### Přijímání a ukládání výsledků
#### Ailoot · OpenAI Responses
json nebo SSE
##### Uchovejte všechny dokončené výsledky
Uchovejte každou úplnou vrácenou odpověď, soubor i část obsahu.
Zachovejte každou výstupní položku a část obsahu, skutečné call\_id funkce, šifrované uvažování a údaje o využití. Při streamování uchovejte úplnou identitu události/položky.
##### Pokud je nutné ověřit původní odpověď
Zachovejte ID požadavků/odpovědí a hlavičky. Není dodána obecná URL pro načtení textové úlohy.
Pole odpovědi
| Pole | Typ |
| --- | --- |
| Pole`id` | Typstring |
| Pole`status` | Typstring |
| Pole`output[]` | Typmessage\|reasoning\|function\_call\|other item |
| Pole`output[].content[]` | Typcontent part |
| Pole`usage` | Typobject |
Chyby a další kroky
| Odpověď | Podmínka | Další krok |
| --- | --- | --- |
| Odpověď400 · `invalid_request_error` | PodmínkaNeplatná povinná pole, reprezentace podkladů nebo hodnota parametru | Další krokPřed novým požadavkem na vytvoření opravte uvedená pole. |
### Aliasy
#### Aliasy modelu
Ailoot [`MiniMax-M3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=MiniMax-M3&fmt=responses), [`minimax`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax&fmt=responses), [`minimax-latest`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-latest&fmt=responses), [`minimax-text`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-text&fmt=responses), [`minimax-text-latest`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-text-latest&fmt=responses), [`minimax/minimax-m3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax%2Fminimax-m3&fmt=responses)
**Ailoot Ultra** [`MiniMax-M3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Ultra&caller=MiniMax-M3), [`minimax/minimax-m3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Ultra&caller=minimax%2Fminimax-m3)
#### Aliasy cest metod
`/chat/completions`
#### Související ID modelů
[`minimax/minimax-m3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax%2Fminimax-m3&fmt=responses), [`minimax/minimax-m3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Ultra&caller=minimax%2Fminimax-m3), [`minimax`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax&fmt=responses), [`minimax-latest`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-latest&fmt=responses), [`minimax-text`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-text&fmt=responses), [`minimax-text-latest`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-text-latest&fmt=responses), [`MiniMax-M3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=MiniMax-M3&fmt=responses), [`MiniMax-M3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Ultra&caller=MiniMax-M3)
**Ailoot · OpenAI Chat** `POST /v1/chat/completions` `minimax/minimax-m3`
[`minimax/minimax-m3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax%2Fminimax-m3&fmt=chat)
MiniMax /`minimax/minimax-m3`
ID modelu
- `MiniMax-M3`
- `minimax`
- `minimax-latest`
- `minimax-text`
- `minimax-text-latest`
- `minimax/minimax-m3`
### Úvod
MiniMax M3 je multimodální model pro dlouhodobou práci na kódu a agentní úlohy, který využívá MiniMax Sparse Attention a návrh pro dlouhý kontext. Uvedená chatová rozhraní Ultra přijímají text a vracejí textové odpovědi.
Přijímané vstupy
Text · Obrázky
Výsledky
Text
### Dostupné v Ailoot · vstupy a metody
**Ailoot · OpenAI Chat** `POST /v1/chat/completions`
Vstup
`text`, `image`
Výstup
`text`
Kontext
1 000 000 tokens
Maximální výstup
524 288 tokens
Výstupní formát
json nebo SSE
| Pole | Typ | Požadavek | Hodnoty a limity | Výchozí |
| --- | --- | --- | --- | --- |
| Pole`model` | Typ`string` | PožadavekPovinné | Hodnoty a limity minimax/minimax-m3 | Výchozí— |
| Pole`messages` | Typ`message[]` | PožadavekPovinné | Hodnoty a limity Minimální počet položek: 1 | Výchozí— |
| Pole`messages[].role` | Typ`string` | PožadavekPovinné | Hodnoty a limity Příklady: system, user, assistant, tool, function Podmínky: Tyto role jsou výslovně zastoupeny typy kompatibility zdrojového kódu; přesná sada rolí zůstává specifická pro daný model. Závisí na modelu | Výchozí— |
| Pole`messages[].content` | Typ`string\|content_part[]\|null` | PožadavekVolitelné | Hodnoty a limity | Výchozí— |
| Pole`messages[].tool_calls` | Typ`tool_call[]` | PožadavekVolitelné | Hodnoty a limity | Výchozí— |
| Pole`messages[].tool_call_id` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Platí, když: role=tool; použijte skutečně vrácené ID | Výchozí— |
| Pole`messages[].name` | Typ`string` | PožadavekVolitelné | Hodnoty a limity | Výchozí— |
| Pole`messages[].reasoning_content` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Platí, když: Předávejte zpět skutečně vrácené uvažování tam, kde je tento model používá | Výchozí— |
| Pole`messages[].reasoning_details` | Typ`object\|array` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`max_tokens` | Typ`integer` | PožadavekVolitelné | Hodnoty a limity Minimum: 1 Závisí na modelu | Výchozí— |
| Pole`max_completion_tokens` | Typ`integer` | PožadavekVolitelné | Hodnoty a limity Minimum: 1 Závisí na modelu | Výchozí— |
| Pole`stream` | Typ`boolean` | PožadavekVolitelné | Hodnoty a limity | Výchozífalse |
| Pole`stream_options.include_usage` | Typ`boolean` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`temperature` | Typ`number` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`top_p` | Typ`number` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`stop` | Typ`string\|string[]` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`tools` | Typ`function_tool[]` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`tools[].type` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`tools[].function.name` | Typ`string` | PožadavekPovinné | Hodnoty a limity Platí, když: nástroj typu funkce je dodán | Výchozí— |
| Pole`tools[].function.description` | Typ`string` | PožadavekVolitelné | Hodnoty a limity | Výchozí— |
| Pole`tools[].function.parameters` | Typ`JSON_schema` | PožadavekVolitelné | Hodnoty a limity | Výchozí— |
| Pole`tool_choice` | Typ`string\|object` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`parallel_tool_calls` | Typ`boolean` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`response_format` | Typ`object` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`reasoning_effort` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`reasoning` | Typ`object` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`service_tier` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`instructions` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Pole kompatibility | Výchozí— |
| Pole`functions` | Typ`function[]` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`function_call` | Typ`string\|object` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`prompt_cache_options` | Typ`object` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
Kombinace vstupních materiálů
**Text** · text UTF8
`messages[].content`
**Text + obrázek**
`{type:image_url,image_url:{url,detail}}`
Parametry a životní cyklus metody
| Parametr | Kontrakt |
| --- | --- |
| Parametr`material_types` | Kontrakttext, image |
| Parametr`required` | Kontraktmodel, messages |
| Parametr`optional_controls` | Kontraktnull |
| Parametr`content_type` | Kontraktapplication/json |
| Parametr`text_file_material` | Kontraktskutečný obsah UTF-8 vložený jako text; ID/URLs souborů vyžadují samostatnou přesně vymezenou podporu |
Životní cyklus: `exact retained published method`
Struktury metod a ID jsou přesné; schopnosti dodavatele jsou oddělené od připuštění požadavku.
### Tarify
#### Sazby metod Ailoot
Vstup
0,0003 US$ */ 1K*
Výstup
0,0012 US$ */ 1K*
Čtení z mezipaměti
≈0,00006 US$ */ 1K*
Zápis do mezipaměti
0,0003 US$ */ 1K*
Zápis do mezipaměti, 5 min
0,0003 US$ */ 1K tokens*
#### Ceny podle délky požadavku · OpenAI Chat
| Velikost požadavku v tokenech | Vstup | Výstup | Čtení z mezipaměti | Zápis do mezipaměti | Mezipaměť 5 min | Mezipaměť 1 hodina |
| --- | --- | --- | --- | --- | --- | --- |
| Velikost požadavku v tokenech(0; 524 288\] | Vstup0,0003 US$ | Výstup0,0012 US$ | Čtení z mezipaměti≈0,00006 US$ | Zápis do mezipaměti0,0003 US$ | Mezipaměť 5 min0,0003 US$ | Mezipaměť 1 hodinaZákladní: — |
| Velikost požadavku v tokenech(524 288; 1 000 000\] | Vstup0,0006 US$ | Výstup0,0024 US$ | Čtení z mezipaměti≈0,00012 US$ | Zápis do mezipaměti0,0006 US$ | Mezipaměť 5 min0,0006 US$ | Mezipaměť 1 hodinaZákladní: — |
Sazby v USD za 1K tokenů. Není-li sazba nastavena, použije se zděděná základní sazba této metody; «—» znamená, že základní sazba není nastavena.
Ailoot před požadavkem rezervuje odhadovanou částku. Po výsledku vyúčtuje konečný poplatek podle naměřeného využití. Při streamování se účtování řídí konečným záznamem využití. [Jak funguje rezervace a vyúčtování →](https://ailoot.ai/docs/cs/billing/reserve/)
#### Podrobnosti referenčního tarifu
Referenční tabulky modelu nemění výběr metody, cenové nabídky ani poplatky. Skutečné poplatky používají sazby vybrané metody Ailoot.
Referenční tabulky modelu
#### Ceny podle konfigurace
Přiřaďte každý poplatek k uvedeným podmínkám. Pro každou sadu alternativních konfigurací použijte jednu sazbu.
| Konfigurace | Tabulka sazeb | Tokeny kontextu, více než | Tokeny kontextu, do uvedené hodnoty včetně | Poplatek |
| --- | --- | --- | --- | --- |
| KonfiguraceOpenAI Chat · Základní sazby za tokeny | Tabulka sazebZákladní sazba | Tokeny kontextu, více než— | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.0006** / 1K tokenů Výstup · Výstupní tokeny **$0.0024** / 1K tokenů Vstup · Čtení z mezipaměti **$0.00012** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguraceOpenAI Chat · Úroveň 1 podle délky požadavku | Tabulka sazeb— | Tokeny kontextu, více než0 | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.0006** / 1K tokenů Výstup · Výstupní tokeny **$0.0024** / 1K tokenů Vstup · Čtení z mezipaměti **$0.00012** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguraceAnthropic Messages · Základní sazby za tokeny | Tabulka sazebZákladní sazba | Tokeny kontextu, více než— | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.0006** / 1K tokenů Výstup · Výstupní tokeny **$0.0024** / 1K tokenů Vstup · Čtení z mezipaměti **$0.00012** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguraceAnthropic Messages · Úroveň 1 podle délky požadavku | Tabulka sazeb— | Tokeny kontextu, více než0 | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.0006** / 1K tokenů Výstup · Výstupní tokeny **$0.0024** / 1K tokenů Vstup · Čtení z mezipaměti **$0.00012** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
### Příklady požadavků
#### Ailoot · OpenAI Chat
Textový příkladVstup, obrázekPython SDKNode.js SDKStreamování v Pythonu
```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_TEXT_FILE:?Set your actual UTF-8 source-material file}"
export AILOOT_TEXT_FILE
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model": "minimax/minimax-m3", "messages": []}')
f=Path(os.environ["AILOOT_TEXT_FILE"])
if not f.is_file():raise SystemExit("Choose your actual UTF-8 source material")
text=f.read_text(encoding="utf-8")
if not text.strip():raise SystemExit("Source material must contain text")
p["messages"]=[{"role":"user","content":"Summarize this material and quote supporting source passages.\n\n"+text}]
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
print(json.dumps(json.loads(Path("result.json").read_text()),ensure_ascii=False,indent=2))
PY_RESULT
```
```bash
set -eu
: "${AILOOT_API_KEY:?Set your Ailoot API key}"
: "${AILOOT_IMAGE_FILE:?Set your actual PNG JPEG or WebP image}"
export AILOOT_IMAGE_FILE
python3 - <<'PY_REQUEST'
import json,os
from pathlib import Path
p=json.loads('{"model": "minimax/minimax-m3", "messages": [{"role": "user", "content": [{"type": "text", "text": "Read labels and numbers in this image; flag unreadable text."}]}]}')
import base64
f=Path(os.environ["AILOOT_IMAGE_FILE"])
if not f.is_file():raise SystemExit("Choose an actual PNG JPEG or WebP image")
raw=f.read_bytes()
mime="image/png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "image/jpeg" if raw.startswith(b"\xff\xd8") else "image/webp" if raw[:4]==b"RIFF" and raw[8:12]==b"WEBP" else None
if not mime:raise SystemExit("Use PNG JPEG or WebP")
b64=base64.b64encode(raw).decode()
p["messages"][0]["content"].append({"type":"image_url","image_url":{"url":"data:"+mime+";base64,"+b64}})
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
print(json.dumps(json.loads(Path("result.json").read_text()),ensure_ascii=False,indent=2))
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)
resp = client.chat.completions.create(
model="minimax/minimax-m3",
messages=[{"role": "user", "content": "Explain the difference between an observation and a hypothesis 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(resp.to_dict(mode="json"))
```
```js
import OpenAI from "openai";
if (!process.env.AILOOT_API_KEY?.trim()) throw new Error("Set AILOOT_API_KEY before making a request");
const client = new OpenAI({ baseURL: "https://api.ailoot.ai/v1", apiKey: process.env.AILOOT_API_KEY, maxRetries: 0 });
const resp = await client.chat.completions.create({
model: "minimax/minimax-m3",
messages: [{ role: "user", content: "Explain the difference between an observation and a hypothesis in three sentences." }],
});
import { writeFileSync } from "node:fs";
function saveResult(data, stem = "result") {
writeFileSync(stem + ".json", JSON.stringify(data, null, 2));
console.log(JSON.stringify(data, null, 2));
const saveBlob = (encoded, suffix, label) => {
const raw = Buffer.from(encoded, "base64");
const ext = raw.subarray(0,8).equals(Buffer.from([137,80,78,71,13,10,26,10])) ? "png" : raw[0]===255 && raw[1]===216 ? "jpg" : raw.subarray(0,4).toString()==="RIFF" && raw.subarray(8,12).toString()==="WEBP" ? "webp" : suffix;
const file = `${stem}-${label}.${ext}`;
writeFileSync(file, raw); console.log("Saved", file);
};
for (const [i, block] of (data.content || []).entries()) console.log("Content", i, JSON.stringify(block));
for (const choice of data.choices || []) console.log("Choice", choice.index, JSON.stringify(choice.message || choice.delta || {}));
for (const [i, item] of (data.output || []).entries()) {
console.log("Output", i, JSON.stringify(item));
if (item.type === "image_generation_call" && item.result) saveBlob(item.result, item.output_format || "bin", `output-${i}`);
}
for (const [ci, candidate] of (data.candidates || []).entries()) {
for (const [pi, part] of (candidate.content?.parts || []).entries()) {
console.log("Candidate/part", ci, pi, JSON.stringify(part));
const blob = part.inlineData || part.inline_data;
if (blob?.data) {
const mime = blob.mimeType || blob.mime_type;
const suffix = ({"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"})[mime] || "bin";
saveBlob(blob.data, suffix, `candidate-${ci}-part-${pi}`);
}
}
}
}
saveResult(resp);
```
```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='minimax/minimax-m3',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")
```
### Přijímání a ukládání výsledků
#### Ailoot · OpenAI Chat
json nebo SSE
##### Uchovejte všechny dokončené výsledky
Uchovejte každou úplnou vrácenou odpověď, soubor i část obsahu.
Zachovejte každou volbu a její obsah/volání nástrojů/uvažování. V SSE sestavujte přírůstky podle indexu volby/nástroje a zachovejte konečný důvod ukončení i údaje o využití.
##### Pokud je nutné ověřit původní odpověď
Zachovejte ID požadavků/odpovědí a hlavičky. Není dodána obecná URL pro načtení textové úlohy.
Pole odpovědi
| Pole | Typ |
| --- | --- |
| Pole`choices[].index` | Typinteger |
| Pole`choices[].message.content` | Typstring\|null |
| Pole`choices[].message.tool_calls` | Typtool\_call\[\] |
| Pole`choices[].message.reasoning_content` | Typstring |
| Pole`choices[].message.reasoning_details` | Typobject\|array |
| Pole`choices[].finish_reason` | Typstring\|null |
| Pole`usage` | Typobject |
Chyby a další kroky
| Odpověď | Podmínka | Další krok |
| --- | --- | --- |
| Odpověď400 · `invalid_request_error` | PodmínkaNeplatná povinná pole, reprezentace podkladů nebo hodnota parametru | Další krokPřed novým požadavkem na vytvoření opravte uvedená pole. |
### Aliasy
#### Aliasy modelu
Ailoot [`MiniMax-M3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=MiniMax-M3&fmt=chat), [`minimax`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax&fmt=chat), [`minimax-latest`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-latest&fmt=chat), [`minimax-text`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-text&fmt=chat), [`minimax-text-latest`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-text-latest&fmt=chat), [`minimax/minimax-m3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax%2Fminimax-m3&fmt=chat)
**Ailoot Ultra** [`MiniMax-M3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Ultra&caller=MiniMax-M3&fmt=chat), [`minimax/minimax-m3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Ultra&caller=minimax%2Fminimax-m3&fmt=chat)
#### Aliasy cest metod
`/chat/completions`
#### Související ID modelů
[`minimax/minimax-m3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax%2Fminimax-m3&fmt=chat), [`minimax/minimax-m3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Ultra&caller=minimax%2Fminimax-m3&fmt=chat), [`minimax`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax&fmt=chat), [`minimax-latest`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-latest&fmt=chat), [`minimax-text`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-text&fmt=chat), [`minimax-text-latest`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-text-latest&fmt=chat), [`MiniMax-M3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=MiniMax-M3&fmt=chat), [`MiniMax-M3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Ultra&caller=MiniMax-M3&fmt=chat)
**Ailoot Ultra · OpenAI Chat** `POST /v1/chat/completions` `minimax/minimax-m3`
[`minimax/minimax-m3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Ultra&caller=minimax%2Fminimax-m3&fmt=chat)
MiniMax /`minimax/minimax-m3`
ID modelu
- `MiniMax-M3`
- `minimax/minimax-m3`
### Úvod
MiniMax M3 je multimodální model pro dlouhodobou práci na kódu a agentní úlohy, který využívá MiniMax Sparse Attention a návrh pro dlouhý kontext. Uvedená chatová rozhraní Ultra přijímají text a vracejí textové odpovědi.
Přijímané vstupy
Text
Výsledky
Text
### Dostupné v Ailoot · vstupy a metody
**Ailoot Ultra · OpenAI Chat** `POST /v1/chat/completions`
Vstup
`text`
Výstup
`text`
Výstupní formát
json nebo SSE
| Pole | Typ | Požadavek | Hodnoty a limity | Výchozí |
| --- | --- | --- | --- | --- |
| Pole`model` | Typ`string` | PožadavekPovinné | Hodnoty a limity minimax/minimax-m3 | Výchozí— |
| Pole`messages` | Typ`message[]` | PožadavekPovinné | Hodnoty a limity Minimální počet položek: 1 | Výchozí— |
| Pole`messages[].role` | Typ`string` | PožadavekPovinné | Hodnoty a limity Příklady: system, user, assistant, tool, function Podmínky: Tyto role jsou výslovně zastoupeny typy kompatibility zdrojového kódu; přesná sada rolí zůstává specifická pro daný model. Závisí na modelu | Výchozí— |
| Pole`messages[].content` | Typ`string\|content_part[]\|null` | PožadavekVolitelné | Hodnoty a limity | Výchozí— |
| Pole`messages[].tool_calls` | Typ`tool_call[]` | PožadavekVolitelné | Hodnoty a limity | Výchozí— |
| Pole`messages[].tool_call_id` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Platí, když: role=tool; použijte skutečně vrácené ID | Výchozí— |
| Pole`messages[].name` | Typ`string` | PožadavekVolitelné | Hodnoty a limity | Výchozí— |
| Pole`messages[].reasoning_content` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Platí, když: Předávejte zpět skutečně vrácené uvažování tam, kde je tento model používá | Výchozí— |
| Pole`messages[].reasoning_details` | Typ`object\|array` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`max_tokens` | Typ`integer` | PožadavekVolitelné | Hodnoty a limity Minimum: 1 Závisí na modelu | Výchozí— |
| Pole`max_completion_tokens` | Typ`integer` | PožadavekVolitelné | Hodnoty a limity Minimum: 1 Závisí na modelu | Výchozí— |
| Pole`stream` | Typ`boolean` | PožadavekVolitelné | Hodnoty a limity | Výchozífalse |
| Pole`stream_options.include_usage` | Typ`boolean` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`temperature` | Typ`number` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`top_p` | Typ`number` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`stop` | Typ`string\|string[]` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`tools` | Typ`function_tool[]` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`tools[].type` | Typ`string` | PožadavekVolitelné | Hodnoty a limity function Závisí na modelu | Výchozí— |
| Pole`tools[].function.name` | Typ`string` | PožadavekPovinné | Hodnoty a limity Platí, když: nástroj typu funkce je dodán | Výchozí— |
| Pole`tools[].function.description` | Typ`string` | PožadavekVolitelné | Hodnoty a limity | Výchozí— |
| Pole`tools[].function.parameters` | Typ`JSON_schema` | PožadavekVolitelné | Hodnoty a limity | Výchozí— |
| Pole`tool_choice` | Typ`string\|object` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`parallel_tool_calls` | Typ`boolean` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`response_format` | Typ`object` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`reasoning_effort` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`reasoning` | Typ`object` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`service_tier` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`instructions` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Pole kompatibility | Výchozí— |
| Pole`functions` | Typ`function[]` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`function_call` | Typ`string\|object` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`prompt_cache_options` | Typ`object` | PožadavekVolitelné | Hodnoty a limity Závisí na modelu | Výchozí— |
| Pole`modalities` | Typ`string[]` | PožadavekVolitelné | Hodnoty a limity text | Výchozí— |
| Pole`provider` | Typ`object` | PožadavekVolitelné | Hodnoty a limity Podmínky: provider.options je na této textové trase Ultra odmítáno | Výchozí— |
| Pole`cache_control.ttl` | Typ`string` | PožadavekVolitelné | Hodnoty a limity Podmínky: Hodnota 1h je ve skutečných umístěních mezipaměti promptů odmítána | Výchozí— |
Kombinace vstupních materiálů
**Text** · text UTF8
`messages[].content`
Parametry a životní cyklus metody
| Parametr | Kontrakt |
| --- | --- |
| Parametr`content_type` | Kontraktapplication/json |
| Parametr`required` | Kontraktmodel, messages |
| Parametr`material_types` | Kontrakttext |
| Parametr`messages` | Kontraktpole zpráv se strukturou role/content |
| Parametr`file_material` | Kontraktskutečný dokument UTF-8 vložený jako doslovný text; ID souboru se neodvozuje |
| Parametr`optional_controls` | Kontraktstream, temperature, top\_p, stop, max\_tokens, max\_completion\_tokens, reasoning, response\_format, tools, tool\_choice |
| Parametr`control_scope` | Kontraktspecifické pro model; nástroje uživatelských funkcí se liší od hostovaných nástrojů |
| Parametr`output_modalities` | Kontrakttext |
| Parametr`hosted_operations` | Kontraktfalse |
| Parametr`multimodal_input_binding` | Kontraktnull |
Životní cyklus: `synchronous_or_streamed`
Odešlete přesné ID modelu spolu s messages.
Délka kontextu není limitem výstupu.
Textový soubor může dodat doslovný text; obrazové/zvukové vstupy a vstupy v podobě souborových objektů vyžadují přesnou vazbu.
### Tarify
Údaje o tarifech nepřidávají možnosti požadavku. Podporované parametry jsou uvedeny u vybrané metody.
Rychlý režim
Standardní sazba Při výběru rychlého režimu
Režim flex
Standardní sazba Při výběru režimu flex
Maximální intenzita uvažování
Standardní sazba Když se při maximální intenzitě uvažování použije výchozí úprava (default)
#### Sazby Ailoot
#### Ceny podle konfigurace
Přiřaďte každý poplatek k uvedeným podmínkám. Pro každou sadu alternativních konfigurací použijte jednu sazbu.
| Konfigurace | Tabulka sazeb | Tokeny kontextu, více než | Tokeny kontextu, do uvedené hodnoty včetně | Poplatek |
| --- | --- | --- | --- | --- |
| KonfiguraceZákladní sazby za tokeny | Tabulka sazebZákladní sazba | Tokeny kontextu, více než— | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.0006** / 1K tokenů Výstup · Výstupní tokeny **$0.0024** / 1K tokenů Vstup · Čtení z mezipaměti **$0.00012** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguracePásmo délky požadavku 1 | Tabulka sazeb— | Tokeny kontextu, více než0 | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.0006** / 1K tokenů Výstup · Výstupní tokeny **$0.0024** / 1K tokenů Vstup · Čtení z mezipaměti **$0.00012** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
Ailoot před požadavkem rezervuje odhadovanou částku. Po výsledku vyúčtuje konečný poplatek podle naměřeného využití. Při streamování se účtování řídí konečným záznamem využití. [Jak funguje rezervace a vyúčtování →](https://ailoot.ai/docs/cs/billing/reserve/)
### Příklady požadavků
#### Ailoot Ultra · OpenAI Chat
curlPython SDKStreamování v Pythonu
```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": "minimax/minimax-m3", "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='minimax/minimax-m3',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='minimax/minimax-m3',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")
```
### Přijímání a ukládání výsledků
#### Ailoot Ultra · OpenAI Chat
json nebo SSE
##### Uchovejte všechny dokončené výsledky
Uchovejte každou úplnou vrácenou odpověď, soubor i část obsahu.
Zachovejte každou volbu a její obsah/volání nástrojů/uvažování. V SSE sestavujte přírůstky podle indexu volby/nástroje a zachovejte konečný důvod ukončení i údaje o využití.
##### Pokud je nutné ověřit původní odpověď
Zachovejte ID požadavků/odpovědí a hlavičky. Není dodána obecná URL pro načtení textové úlohy.
Pole odpovědi
| Pole | Typ |
| --- | --- |
| Pole`choices[].index` | Typinteger |
| Pole`choices[].message.content` | Typstring\|null |
| Pole`choices[].message.tool_calls` | Typtool\_call\[\] |
| Pole`choices[].message.reasoning_content` | Typstring |
| Pole`choices[].message.reasoning_details` | Typobject\|array |
| Pole`choices[].finish_reason` | Typstring\|null |
| Pole`usage` | Typobject |
Chyby a další kroky
| Odpověď | Podmínka | Další krok |
| --- | --- | --- |
| Odpověď400 · `invalid_request_error` | PodmínkaNeplatná povinná pole, reprezentace podkladů nebo hodnota parametru | Další krokPřed novým požadavkem na vytvoření opravte uvedená pole. |
### Aliasy
#### Aliasy modelu
Ailoot [`MiniMax-M3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=MiniMax-M3&fmt=chat), [`minimax`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax&fmt=chat), [`minimax-latest`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-latest&fmt=chat), [`minimax-text`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-text&fmt=chat), [`minimax-text-latest`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-text-latest&fmt=chat), [`minimax/minimax-m3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax%2Fminimax-m3&fmt=chat)
**Ailoot Ultra** [`MiniMax-M3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Ultra&caller=MiniMax-M3&fmt=chat), [`minimax/minimax-m3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Ultra&caller=minimax%2Fminimax-m3&fmt=chat)
#### Aliasy cest metod
`/chat/completions`
#### Související ID modelů
[`minimax/minimax-m3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax%2Fminimax-m3&fmt=chat), [`minimax/minimax-m3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Ultra&caller=minimax%2Fminimax-m3&fmt=chat), [`minimax`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax&fmt=chat), [`minimax-latest`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-latest&fmt=chat), [`minimax-text`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-text&fmt=chat), [`minimax-text-latest`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-text-latest&fmt=chat), [`MiniMax-M3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=MiniMax-M3&fmt=chat), [`MiniMax-M3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Ultra&caller=MiniMax-M3&fmt=chat)
**Ailoot Ultra · Anthropic Messages** `POST /v1/messages` `minimax/minimax-m3`
[`minimax/minimax-m3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Ultra&caller=minimax%2Fminimax-m3&fmt=messages)
MiniMax /`minimax/minimax-m3`
ID modelu
- `MiniMax-M3`
- `minimax/minimax-m3`
### Úvod
MiniMax M3 je multimodální model pro dlouhodobou práci na kódu a agentní úlohy, který využívá MiniMax Sparse Attention a návrh pro dlouhý kontext. Uvedená chatová rozhraní Ultra přijímají text a vracejí textové odpovědi.
Přijímané vstupy
Text
Výsledky
json · sse
### Dostupné v Ailoot · vstupy a metody
**Ailoot Ultra · Anthropic Messages** `POST /v1/messages`
Vstup
`text`
Výstup
`json`, `sse`
Výstupní formát
JSON nebo SSE
| Pole | Typ | Požadavek | Hodnoty a limity | Výchozí |
| --- | --- | --- | --- | --- |
| Pole`model` | Typ`string` | PožadavekPovinné | Hodnoty a limity minimax/minimax-m3 | Výchozí— |
| Pole`messages` | Typ`message[]` | PožadavekPovinné | Hodnoty a limity | Výchozí— |
| Pole`messages[].role` | Typ`string` | PožadavekPovinné | Hodnoty a limity user, assistant | Výchozí— |
| Pole`messages[].content` | Typ`string` | PožadavekPovinné | Hodnoty a limity | Výchozí— |
| Pole`max_tokens` | Typ`integer` | PožadavekPovinné | Hodnoty a limity | Výchozí— |
| Pole`stream` | Typ`boolean` | PožadavekVolitelné | Hodnoty a limity | Výchozífalse |
Kombinace vstupních materiálů
**Text** · text UTF-8
`řetězec messages[].content`
Parametry a životní cyklus metody
| Parametr | Kontrakt |
| --- | --- |
| Parametr`content_type` | Kontraktapplication/json |
| Parametr`required` | Kontraktmodel, messages, max\_tokens |
| Parametr`optional_controls` | Kontraktstream |
| Parametr`material_types` | Kontrakttext |
| Parametr`text_file_material` | KontraktPřečtěte skutečný dokument UTF-8 a vložte jeho text do uvedeného pole input nebo do řetězce obsahu zprávy. |
Životní cyklus: `synchronous_or_streamed`
### Tarify
Údaje o tarifech nepřidávají možnosti požadavku. Podporované parametry jsou uvedeny u vybrané metody.
Rychlý režim
Standardní sazba Při výběru rychlého režimu
Režim flex
Standardní sazba Při výběru režimu flex
Maximální intenzita uvažování
Standardní sazba Když se při maximální intenzitě uvažování použije výchozí úprava (default)
#### Sazby Ailoot
#### Ceny podle konfigurace
Přiřaďte každý poplatek k uvedeným podmínkám. Pro každou sadu alternativních konfigurací použijte jednu sazbu.
| Konfigurace | Tabulka sazeb | Tokeny kontextu, více než | Tokeny kontextu, do uvedené hodnoty včetně | Poplatek |
| --- | --- | --- | --- | --- |
| KonfiguraceZákladní sazby za tokeny | Tabulka sazebZákladní sazba | Tokeny kontextu, více než— | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.0006** / 1K tokenů Výstup · Výstupní tokeny **$0.0024** / 1K tokenů Vstup · Čtení z mezipaměti **$0.00012** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguracePásmo délky požadavku 1 | Tabulka sazeb— | Tokeny kontextu, více než0 | Tokeny kontextu, do uvedené hodnoty včetněBez horní meze | Poplatek Vstup · Vstupní tokeny **$0.0006** / 1K tokenů Výstup · Výstupní tokeny **$0.0024** / 1K tokenů Vstup · Čtení z mezipaměti **$0.00012** / 1K tokenů Vstup · Zápis do mezipaměti **—** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
Ailoot před požadavkem rezervuje odhadovanou částku. Po výsledku vyúčtuje konečný poplatek podle naměřeného využití. Při streamování se účtování řídí konečným záznamem využití. [Jak funguje rezervace a vyúčtování →](https://ailoot.ai/docs/cs/billing/reserve/)
### Příklady požadavků
#### Ailoot Ultra · Anthropic Messages
Úplné minimální tělo požadavku JSONcurl · použijte svůj dokument UTF-8Python · uložte úplný výsledek
```json
{
"model": "minimax/minimax-m3",
"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': 'minimax/minimax-m3', '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': 'minimax/minimax-m3', '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))
```
### Přijímání a ukládání výsledků
#### Ailoot Ultra · Anthropic Messages
JSON nebo SSE
##### Uchovejte všechny dokončené výsledky
Uchovejte každou úplnou vrácenou odpověď, soubor i část obsahu.
Zachovejte všechny bloky obsahu, podpisy uvažování a skutečná ID použití nástrojů. Sestavte všechny přírůstky bloků SSE; první textový blok není úplný výstup.
##### Pokud je nutné ověřit původní odpověď
Zachovejte ID požadavků/odpovědí a hlavičky. Není dodána obecná URL pro načtení textové úlohy.
Pole odpovědi
| Pole | Typ |
| --- | --- |
| Pole`id` | Typstring |
| Pole`model` | Typstring |
| Pole`content[]` | Typtext\|thinking\|tool\_use\|other content block |
| Pole`stop_reason` | Typstring\|null |
| Pole`usage` | Typobject |
Chyby a další kroky
| Odpověď | Podmínka | Další krok |
| --- | --- | --- |
| Odpověď400 · `invalid_request_error` | PodmínkaNeplatná povinná pole, reprezentace podkladů nebo hodnota parametru | Další krokPřed novým požadavkem na vytvoření opravte uvedená pole. |
### Aliasy
#### Aliasy modelu
Ailoot [`MiniMax-M3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=MiniMax-M3&fmt=messages), [`minimax`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax&fmt=messages), [`minimax-latest`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-latest&fmt=messages), [`minimax-text`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-text&fmt=messages), [`minimax-text-latest`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-text-latest&fmt=messages), [`minimax/minimax-m3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax%2Fminimax-m3&fmt=messages)
**Ailoot Ultra** [`MiniMax-M3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Ultra&caller=MiniMax-M3&fmt=messages), [`minimax/minimax-m3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Ultra&caller=minimax%2Fminimax-m3&fmt=messages)
#### Aliasy cest metod
`/chat/completions`
#### Související ID modelů
[`minimax/minimax-m3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax%2Fminimax-m3&fmt=messages), [`minimax/minimax-m3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Ultra&caller=minimax%2Fminimax-m3&fmt=messages), [`minimax`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax&fmt=messages), [`minimax-latest`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-latest&fmt=messages), [`minimax-text`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-text&fmt=messages), [`minimax-text-latest`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=minimax-text-latest&fmt=messages), [`MiniMax-M3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Core&caller=MiniMax-M3&fmt=messages), [`MiniMax-M3`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m3&route=Ultra&caller=MiniMax-M3&fmt=messages)
FAQ · MiniMax: MiniMax M3
Jaké vstupy a výsledky jsou dostupné?
`POST /v1/messages` · `MiniMax-M3`: `text`, `image` → `text` `POST /v1/responses` · `MiniMax-M3`: `text`, `image` → `text` `POST /v1/chat/completions` · `MiniMax-M3`: `text`, `image` → `text` `POST /v1/chat/completions` · `MiniMax-M3`: `text` → `text` `POST /v1/messages` · `MiniMax-M3`: `text` → `json`, `sse` `POST /v1/messages` · `minimax`: `text`, `image` → `text` `POST /v1/responses` · `minimax`: `text`, `image` → `text` `POST /v1/chat/completions` · `minimax`: `text`, `image` → `text` `POST /v1/messages` · `minimax-latest`: `text`, `image` → `text` `POST /v1/responses` · `minimax-latest`: `text`, `image` → `text` `POST /v1/chat/completions` · `minimax-latest`: `text`, `image` → `text` `POST /v1/messages` · `minimax-text`: `text`, `image` → `text` `POST /v1/responses` · `minimax-text`: `text`, `image` → `text` `POST /v1/chat/completions` · `minimax-text`: `text`, `image` → `text` `POST /v1/messages` · `minimax-text-latest`: `text`, `image` → `text` `POST /v1/responses` · `minimax-text-latest`: `text`, `image` → `text` `POST /v1/chat/completions` · `minimax-text-latest`: `text`, `image` → `text` `POST /v1/messages` · `minimax/minimax-m3`: `text`, `image` → `text` `POST /v1/responses` · `minimax/minimax-m3`: `text`, `image` → `text` `POST /v1/chat/completions` · `minimax/minimax-m3`: `text`, `image` → `text` `POST /v1/chat/completions` · `minimax/minimax-m3`: `text` → `text` `POST /v1/messages` · `minimax/minimax-m3`: `text` → `json`, `sse`
Jaká pole požadavek používá?
`POST /v1/messages` · `MiniMax-M3`: `model`, `messages`, `system`, `max_tokens`, `stream`, `metadata` `POST /v1/responses` · `MiniMax-M3`: `model`, `input`, `instructions`, `stream` `POST /v1/chat/completions` · `MiniMax-M3`: `model`, `messages`, `stream` `POST /v1/chat/completions` · `MiniMax-M3`: `model`, `messages`, `stream` `POST /v1/messages` · `MiniMax-M3`: `model`, `messages`, `max_tokens`, `stream` `POST /v1/messages` · `minimax`: `model`, `messages`, `system`, `max_tokens`, `stream`, `metadata` `POST /v1/responses` · `minimax`: `model`, `input`, `instructions`, `stream` `POST /v1/chat/completions` · `minimax`: `model`, `messages`, `stream` `POST /v1/messages` · `minimax-latest`: `model`, `messages`, `system`, `max_tokens`, `stream`, `metadata` `POST /v1/responses` · `minimax-latest`: `model`, `input`, `instructions`, `stream` `POST /v1/chat/completions` · `minimax-latest`: `model`, `messages`, `stream` `POST /v1/messages` · `minimax-text`: `model`, `messages`, `system`, `max_tokens`, `stream`, `metadata` `POST /v1/responses` · `minimax-text`: `model`, `input`, `instructions`, `stream` `POST /v1/chat/completions` · `minimax-text`: `model`, `messages`, `stream` `POST /v1/messages` · `minimax-text-latest`: `model`, `messages`, `system`, `max_tokens`, `stream`, `metadata` `POST /v1/responses` · `minimax-text-latest`: `model`, `input`, `instructions`, `stream` `POST /v1/chat/completions` · `minimax-text-latest`: `model`, `messages`, `stream` `POST /v1/messages` · `minimax/minimax-m3`: `model`, `messages`, `system`, `max_tokens`, `stream`, `metadata` `POST /v1/responses` · `minimax/minimax-m3`: `model`, `input`, `instructions`, `stream` `POST /v1/chat/completions` · `minimax/minimax-m3`: `model`, `messages`, `stream` `POST /v1/chat/completions` · `minimax/minimax-m3`: `model`, `messages`, `stream`, `modalities`, `provider` `POST /v1/messages` · `minimax/minimax-m3`: `model`, `messages`, `max_tokens`, `stream`
Jaké limity platí?
`POST /v1/messages` · `MiniMax-M3`: `ctx`: `1000000`; `max_out`: `524288`; `messages.min_items`: `1`; `max_tokens.minimum`: `1` `POST /v1/responses` · `MiniMax-M3`: `ctx`: `1000000`; `max_out`: `1000000` `POST /v1/chat/completions` · `MiniMax-M3`: `ctx`: `1000000`; `max_out`: `524288`; `messages.min_items`: `1` `POST /v1/chat/completions` · `MiniMax-M3`: `messages.min_items`: `1` `POST /v1/messages` · `minimax`: `ctx`: `1000000`; `max_out`: `524288`; `messages.min_items`: `1`; `max_tokens.minimum`: `1` `POST /v1/responses` · `minimax`: `ctx`: `1000000`; `max_out`: `1000000` `POST /v1/chat/completions` · `minimax`: `ctx`: `1000000`; `max_out`: `524288`; `messages.min_items`: `1` `POST /v1/messages` · `minimax-latest`: `ctx`: `1000000`; `max_out`: `524288`; `messages.min_items`: `1`; `max_tokens.minimum`: `1` `POST /v1/responses` · `minimax-latest`: `ctx`: `1000000`; `max_out`: `1000000` `POST /v1/chat/completions` · `minimax-latest`: `ctx`: `1000000`; `max_out`: `524288`; `messages.min_items`: `1` `POST /v1/messages` · `minimax-text`: `ctx`: `1000000`; `max_out`: `524288`; `messages.min_items`: `1`; `max_tokens.minimum`: `1` `POST /v1/responses` · `minimax-text`: `ctx`: `1000000`; `max_out`: `1000000` `POST /v1/chat/completions` · `minimax-text`: `ctx`: `1000000`; `max_out`: `524288`; `messages.min_items`: `1` `POST /v1/messages` · `minimax-text-latest`: `ctx`: `1000000`; `max_out`: `524288`; `messages.min_items`: `1`; `max_tokens.minimum`: `1` `POST /v1/responses` · `minimax-text-latest`: `ctx`: `1000000`; `max_out`: `1000000` `POST /v1/chat/completions` · `minimax-text-latest`: `ctx`: `1000000`; `max_out`: `524288`; `messages.min_items`: `1` `POST /v1/messages` · `minimax/minimax-m3`: `ctx`: `1000000`; `max_out`: `524288`; `messages.min_items`: `1`; `max_tokens.minimum`: `1` `POST /v1/responses` · `minimax/minimax-m3`: `ctx`: `1000000`; `max_out`: `1000000` `POST /v1/chat/completions` · `minimax/minimax-m3`: `ctx`: `1000000`; `max_out`: `524288`; `messages.min_items`: `1` `POST /v1/chat/completions` · `minimax/minimax-m3`: `messages.min_items`: `1`
Připojte Ailoot k Claude Code, OpenCode, Hermes nebo vlastní aplikaci.
## Společnost a její portfolio projektů
Společnost a její portfolio projektů: miliony zákazníků; měsíční tržby v miliardách.
## Nakupujte tokeny se slevou.
Sleva předplatného pro pravidelnou práci. Promo kódy až 50% na nákup tokenů.
Předplatné
Pro pravidelné požadavky vyberte tarif se slevou.
Promo kód až 50%
Při nákupu zadejte kód. Cena se přepočítá podle probíhající akce.
Výdaje v historii
U každého požadavku se uloží model, tokeny a částka.
[Vybrat předplatné](https://ailoot.ai/docs/cs/billing/subscriptions/) · [Zobrazit ceny modelů](https://ailoot.ai/models/cs/)
## Připojte API k produktu, který prodáváte.
SaaS, aplikace a boti podle nabídky a licenční smlouvy Ailoot. Pro přeprodej požádejte o licenci přeprodejce.
Komerční aplikace
Začleňte generování textu, obrázků, videa a zvuku do placených funkcí své služby.
Licence pro přeprodejce
Pošlete popis projektu a způsob poskytování přístupu. Vyžádejte písemné podmínky použití a přeprodeje.
Dokumenty na webu
Nabídka, licenční smlouva a zásady zpracování dat jsou dostupné před připojením.
[Požádat o licenci přeprodejce](mailto:support@ailoot.ai) · [Nabídka a licenční smlouva](https://ailoot.ai/legal/offer?lang=cs)
## Ailoot · Společnost a její portfolio projektů
Ailoot staví na dlouhodobých provozních zkušenostech, široké klientské základně, stabilních službách a průběžném sledování KPI.
Společnost a její portfolio projektů: miliony zákazníků; měsíční tržby v miliardách.
Ailoot využívá tyto provozní zkušenosti k poskytování přístupu přes API k funkcím AI v produktech zákazníků, agentech, aplikacích a automatizacích.