Source: https://ailoot.ai/models/cs/minimax-m2/
Canonical: https://ailoot.ai/models/cs/minimax-m2/
Language: cs

# MiniMax: MiniMax M2

[Markdown](https://ailoot.ai/models/cs/minimax-m2/index.md) · [JSON](https://ailoot.ai/models/cs/minimax-m2/facts.json)

## [MiniMax: MiniMax M2](https://ailoot.ai/models/cs/minimax-m2/)

MiniMax M2 je textový model společnosti MiniMax pro programování od začátku do konce a agentní postupy, s 10 miliardami aktivních parametrů z celkových 230 miliard. Jeho zveřejněný profil zahrnuje uvažování, nástroje pro volání funkcí, strukturované výstupy a katalogový kontext 204 800 tokenů.

- [**Ailoot · Anthropic Messages** `POST /v1/messages` `MiniMax-M2`](https://ailoot.ai/models/cs/minimax-m2/#method-0)
- [**Ailoot · OpenAI Responses** `POST /v1/responses` `MiniMax-M2`](https://ailoot.ai/models/cs/minimax-m2/#method-1)
- [**Ailoot · OpenAI Chat** `POST /v1/chat/completions` `MiniMax-M2`](https://ailoot.ai/models/cs/minimax-m2/#method-2)
- [**Ailoot Ultra · OpenAI Chat** `POST /v1/chat/completions` `MiniMax-M2`](https://ailoot.ai/models/cs/minimax-m2/#method-3)
- [**Ailoot Ultra · Anthropic Messages** `POST /v1/messages` `MiniMax-M2`](https://ailoot.ai/models/cs/minimax-m2/#method-4)
- [**Ailoot · Anthropic Messages** `POST /v1/messages` `minimax/minimax-m2`](https://ailoot.ai/models/cs/minimax-m2/#method-5)
- [**Ailoot · OpenAI Responses** `POST /v1/responses` `minimax/minimax-m2`](https://ailoot.ai/models/cs/minimax-m2/#method-6)
- [**Ailoot · OpenAI Chat** `POST /v1/chat/completions` `minimax/minimax-m2`](https://ailoot.ai/models/cs/minimax-m2/#method-7)
- [**Ailoot Ultra · OpenAI Chat** `POST /v1/chat/completions` `minimax/minimax-m2`](https://ailoot.ai/models/cs/minimax-m2/#method-8)
- [**Ailoot Ultra · Anthropic Messages** `POST /v1/messages` `minimax/minimax-m2`](https://ailoot.ai/models/cs/minimax-m2/#method-9)

O modelu

Tento popis zahrnuje schopnosti modelu. Vstupy, výstupy a možnosti dostupné v Ailoot jsou uvedeny níže pro vybranou metodu.

MiniMax M2 je jazykový model společnosti MiniMax pro programování od začátku do konce a pracovní postupy agentů. Má celkem 230 miliard parametrů, z nichž je aktivních deset miliard. Textový vstup vede k textovému výstupu. Zveřejněná metadata modelu uvádějí uvažování, nástroje pro volání funkcí a strukturované výstupy; kontextové okno v katalogu činí 204 800 tokenů.

#### Programátorská úloha s jasným výsledkem

Poskytněte příslušnou implementaci, pozorované chování a výsledek potřebný po změně. Pokud diagnózu určuje selhávající vstup a skutečný chybový výstup, zachovejte je. Zadání nové funkce může určit dotčená rozhraní a chování, které musí při provádění změny zůstat správné.

Požadujte konkrétní artefakt: cílenou opravu, diagnózu založenou na zdrojích nebo další kontrolu, která vyřeší otevřenou otázku. Umístění souborů a související kontrakty uchovávejte s výsledkem, aby navržená práce mohla být zkontrolována v zamýšlené části aplikace.

#### Uvažování a pozorování nástrojů

Určete operace dostupné okolní aplikaci. Pokud vybrané rozhraní zpřístupňuje nástroje pro volání funkcí, model může navrhnout volání nástroje a vrácené pozorování použít jako důkaz pro další krok. Uchovávejte skutečné výsledky příkazů, vyhledání nebo práce se soubory a nepovažujte navrženou operaci za dokončenou práci.

Pro strukturovaný výsledek určete pole, typy a zacházení s chybějícími informacemi. Ověřte vrácenou podobu i její věcné hodnoty. Plánovací záznam nebo extrahovaný fakt by měl zůstat spojený se zdrojovými důkazy, které mu dávají význam.

#### Pokračujte z doloženého stavu

Při plánování vycházejte ze skutečné kapacity kontextu a limitu výstupu daného rozhraní a rezervujte prostor pro odpověď. V delší úloze udržujte viditelná dokončená rozhodnutí, aktuální pozorování a zbývající otázky. Užitečný artefakt M2 spojuje výsledek s chováním, které řeší, a s ověřením potřebným před dalším krokem vývoje nebo použití aplikace.

Praktická úloha

### Praktická úloha

Technický příklad v angličtině

```
Preserve omitted fields in an update

A profile update handler uses name = body.get('name') and email = body.get('email'), then writes both fields. A request containing only name erases the stored email. Propose a minimal Python update-building function that changes only supplied fields and preserves explicit null values. Include tests distinguishing an omitted email from an email set to null.
```

#### Očekávaný výsledek

```
A focused partial-update function and two tests showing omission and explicit-null behavior.
```

#### Ověření výsledku

```
The tests demonstrate that absent and present-with-null fields produce different update records.
```

**Ailoot · Anthropic Messages** `POST /v1/messages` `MiniMax-M2`

[`MiniMax-M2`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m2&route=Core&caller=MiniMax-M2&fmt=messages)

MiniMax /`MiniMax-M2`

ID modelu

- `MiniMax-M2`
- `minimax/minimax-m2`

### Úvod

MiniMax M2 je textový model společnosti MiniMax pro programování od začátku do konce a agentní postupy, s 10 miliardami aktivních parametrů z celkových 230 miliard. Jeho zveřejněný profil zahrnuje uvažování, nástroje pro volání funkcí, strukturované výstupy a katalogový kontext 204 800 tokenů.

Přijímané vstupy

Text

Výsledky

Text

### Dostupné v Ailoot · vstupy a metody

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

Vstup

`text`

Výstup

`text`

Kontext

204 800 tokens

Maximální výstup

204 800 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-M2 | 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`

Parametry a životní cyklus metody

| Parametr | Kontrakt |
| --- | --- |
| Parametr`material_types` | Kontrakttext |
| 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,00003 US$ */ 1K*

Zápis do mezipaměti

0,000375 US$ */ 1K*

Zápis do mezipaměti, 5 min

0,000375 US$ */ 1K tokens*

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 | Poplatek |
| --- | --- | --- |
| KonfiguraceOpenAI Chat · Základní sazby za tokeny | Tabulka sazebZákladní sazba | Poplatek Vstup · Vstupní tokeny **$0.0006** / 1K tokenů Výstup · Výstupní tokeny **$0.0024** / 1K tokenů Vstup · Čtení z mezipaměti **$0.00006** / 1K tokenů Vstup · Zápis do mezipaměti **$0.00075** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguraceAnthropic Messages · Základní sazby za tokeny | Tabulka sazebZákladní sazba | Poplatek Vstup · Vstupní tokeny **$0.0006** / 1K tokenů Výstup · Výstupní tokeny **$0.0024** / 1K tokenů Vstup · Čtení z mezipaměti **$0.00006** / 1K tokenů Vstup · Zápis do mezipaměti **$0.00075** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |

### Příklady požadavků

#### Ailoot · Anthropic Messages

Textový příkladPython 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-M2", "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
```

```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-M2",
    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-M2",
  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-M2',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

<strong>Ailoot</strong> [`MiniMax-M2`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m2&route=Core&caller=MiniMax-M2&fmt=messages), [`minimax/minimax-m2`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m2&route=Core&caller=minimax%2Fminimax-m2&fmt=messages)
**Ailoot Ultra** [`MiniMax-M2`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m2&route=Ultra&caller=MiniMax-M2&fmt=messages), [`minimax/minimax-m2`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m2&route=Ultra&caller=minimax%2Fminimax-m2&fmt=messages)

#### Aliasy cest metod

`/chat/completions`

#### Související ID modelů

[`minimax/minimax-m2`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m2&route=Core&caller=minimax%2Fminimax-m2&fmt=messages), [`minimax/minimax-m2`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m2&route=Ultra&caller=minimax%2Fminimax-m2&fmt=messages), [`MiniMax-M2`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m2&route=Core&caller=MiniMax-M2&fmt=messages), [`MiniMax-M2`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m2&route=Ultra&caller=MiniMax-M2&fmt=messages)

**Ailoot · OpenAI Responses** `POST /v1/responses` `MiniMax-M2`

[`MiniMax-M2`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m2&route=Core&caller=MiniMax-M2&fmt=responses)

MiniMax /`MiniMax-M2`

ID modelu

- `MiniMax-M2`
- `minimax/minimax-m2`

### Úvod

MiniMax M2 je textový model společnosti MiniMax pro programování od začátku do konce a agentní postupy, s 10 miliardami aktivních parametrů z celkových 230 miliard. Jeho zveřejněný profil zahrnuje uvažování, nástroje pro volání funkcí, strukturované výstupy a katalogový kontext 204 800 tokenů.

Přijímané vstupy

Text

Výsledky

Text

### Dostupné v Ailoot · vstupy a metody

**Ailoot · OpenAI Responses** `POST /v1/responses`

Vstup

`text`

Výstup

`text`

Kontext

204 800 tokens

Maximální výstup

204 800 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-M2 | 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`

Parametry a životní cyklus metody

| Parametr | Kontrakt |
| --- | --- |
| Parametr`material_types` | Kontrakttext |
| 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,00003 US$ */ 1K*

Zápis do mezipaměti

0,000375 US$ */ 1K*

Zápis do mezipaměti, 5 min

0,000375 US$ */ 1K tokens*

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 | Poplatek |
| --- | --- | --- |
| KonfiguraceOpenAI Chat · Základní sazby za tokeny | Tabulka sazebZákladní sazba | Poplatek Vstup · Vstupní tokeny **$0.0006** / 1K tokenů Výstup · Výstupní tokeny **$0.0024** / 1K tokenů Vstup · Čtení z mezipaměti **$0.00006** / 1K tokenů Vstup · Zápis do mezipaměti **$0.00075** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguraceAnthropic Messages · Základní sazby za tokeny | Tabulka sazebZákladní sazba | Poplatek Vstup · Vstupní tokeny **$0.0006** / 1K tokenů Výstup · Výstupní tokeny **$0.0024** / 1K tokenů Vstup · Čtení z mezipaměti **$0.00006** / 1K tokenů Vstup · Zápis do mezipaměti **$0.00075** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |

### Příklady požadavků

#### Ailoot · OpenAI Responses

Textový příkladPython 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-M2", "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
```

```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-M2", 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-M2", 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-M2", 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

<strong>Ailoot</strong> [`MiniMax-M2`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m2&route=Core&caller=MiniMax-M2&fmt=responses), [`minimax/minimax-m2`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m2&route=Core&caller=minimax%2Fminimax-m2&fmt=responses)
**Ailoot Ultra** [`MiniMax-M2`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m2&route=Ultra&caller=MiniMax-M2), [`minimax/minimax-m2`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m2&route=Ultra&caller=minimax%2Fminimax-m2)

#### Aliasy cest metod

`/chat/completions`

#### Související ID modelů

[`minimax/minimax-m2`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m2&route=Core&caller=minimax%2Fminimax-m2&fmt=responses), [`minimax/minimax-m2`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m2&route=Ultra&caller=minimax%2Fminimax-m2), [`MiniMax-M2`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m2&route=Core&caller=MiniMax-M2&fmt=responses), [`MiniMax-M2`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m2&route=Ultra&caller=MiniMax-M2)

**Ailoot · OpenAI Chat** `POST /v1/chat/completions` `MiniMax-M2`

[`MiniMax-M2`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m2&route=Core&caller=MiniMax-M2&fmt=chat)

MiniMax /`MiniMax-M2`

ID modelu

- `MiniMax-M2`
- `minimax/minimax-m2`

### Úvod

MiniMax M2 je textový model společnosti MiniMax pro programování od začátku do konce a agentní postupy, s 10 miliardami aktivních parametrů z celkových 230 miliard. Jeho zveřejněný profil zahrnuje uvažování, nástroje pro volání funkcí, strukturované výstupy a katalogový kontext 204 800 tokenů.

Přijímané vstupy

Text

Výsledky

Text

### Dostupné v Ailoot · vstupy a metody

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

Vstup

`text`

Výstup

`text`

Kontext

204 800 tokens

Maximální výstup

204 800 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-M2 | 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`

Parametry a životní cyklus metody

| Parametr | Kontrakt |
| --- | --- |
| Parametr`material_types` | Kontrakttext |
| 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,00003 US$ */ 1K*

Zápis do mezipaměti

0,000375 US$ */ 1K*

Zápis do mezipaměti, 5 min

0,000375 US$ */ 1K tokens*

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 | Poplatek |
| --- | --- | --- |
| KonfiguraceOpenAI Chat · Základní sazby za tokeny | Tabulka sazebZákladní sazba | Poplatek Vstup · Vstupní tokeny **$0.0006** / 1K tokenů Výstup · Výstupní tokeny **$0.0024** / 1K tokenů Vstup · Čtení z mezipaměti **$0.00006** / 1K tokenů Vstup · Zápis do mezipaměti **$0.00075** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguraceAnthropic Messages · Základní sazby za tokeny | Tabulka sazebZákladní sazba | Poplatek Vstup · Vstupní tokeny **$0.0006** / 1K tokenů Výstup · Výstupní tokeny **$0.0024** / 1K tokenů Vstup · Čtení z mezipaměti **$0.00006** / 1K tokenů Vstup · Zápis do mezipaměti **$0.00075** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |

### Příklady požadavků

#### Ailoot · OpenAI Chat

Textový příkladPython 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-M2", "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
```

```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-M2",
    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-M2",
  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-M2',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

<strong>Ailoot</strong> [`MiniMax-M2`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m2&route=Core&caller=MiniMax-M2&fmt=chat), [`minimax/minimax-m2`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m2&route=Core&caller=minimax%2Fminimax-m2&fmt=chat)
**Ailoot Ultra** [`MiniMax-M2`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m2&route=Ultra&caller=MiniMax-M2&fmt=chat), [`minimax/minimax-m2`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m2&route=Ultra&caller=minimax%2Fminimax-m2&fmt=chat)

#### Aliasy cest metod

`/chat/completions`

#### Související ID modelů

[`minimax/minimax-m2`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m2&route=Core&caller=minimax%2Fminimax-m2&fmt=chat), [`minimax/minimax-m2`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m2&route=Ultra&caller=minimax%2Fminimax-m2&fmt=chat), [`MiniMax-M2`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m2&route=Core&caller=MiniMax-M2&fmt=chat), [`MiniMax-M2`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m2&route=Ultra&caller=MiniMax-M2&fmt=chat)

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

[`MiniMax-M2`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m2&route=Ultra&caller=MiniMax-M2&fmt=chat)

MiniMax /`MiniMax-M2`

ID modelu

- `MiniMax-M2`
- `minimax/minimax-m2`

### Úvod

MiniMax M2 je textový model společnosti MiniMax pro programování od začátku do konce a agentní postupy, s 10 miliardami aktivních parametrů z celkových 230 miliard. Jeho zveřejněný profil zahrnuje uvažování, nástroje pro volání funkcí, strukturované výstupy a katalogový kontext 204 800 tokenů.

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

Neuvedeno Při výběru rychlého režimu

Režim flex

Neuvedeno Při výběru režimu flex

Maximální intenzita uvažování

Neuvedeno Když se při maximální intenzitě uvažování použije výchozí úprava (default)

#### Sazby Ailoot

#### Ceny podle konfigurace

| Konfigurace | Tabulka sazeb | Poplatek |
| --- | --- | --- |
| KonfiguraceZákladní sazby za tokeny | Tabulka sazebZákladní sazba | Poplatek Vstup · Vstupní tokeny **$0.0006** / 1K tokenů Výstup · Výstupní tokeny **$0.0024** / 1K tokenů Vstup · Čtení z mezipaměti **$0.00006** / 1K tokenů Vstup · Zápis do mezipaměti **$0.00075** / 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-M2","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-M2", 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

<strong>Ailoot</strong> [`MiniMax-M2`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m2&route=Core&caller=MiniMax-M2&fmt=chat), [`minimax/minimax-m2`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m2&route=Core&caller=minimax%2Fminimax-m2&fmt=chat)
**Ailoot Ultra** [`MiniMax-M2`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m2&route=Ultra&caller=MiniMax-M2&fmt=chat), [`minimax/minimax-m2`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m2&route=Ultra&caller=minimax%2Fminimax-m2&fmt=chat)

#### Aliasy cest metod

`/chat/completions`

#### Související ID modelů

[`minimax/minimax-m2`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m2&route=Core&caller=minimax%2Fminimax-m2&fmt=chat), [`minimax/minimax-m2`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m2&route=Ultra&caller=minimax%2Fminimax-m2&fmt=chat), [`MiniMax-M2`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m2&route=Core&caller=MiniMax-M2&fmt=chat), [`MiniMax-M2`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m2&route=Ultra&caller=MiniMax-M2&fmt=chat)

**Ailoot Ultra · Anthropic Messages** `POST /v1/messages` `MiniMax-M2`

[`MiniMax-M2`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m2&route=Ultra&caller=MiniMax-M2&fmt=messages)

MiniMax /`MiniMax-M2`

ID modelu

- `MiniMax-M2`
- `minimax/minimax-m2`

### Úvod

MiniMax M2 je textový model společnosti MiniMax pro programování od začátku do konce a agentní postupy, s 10 miliardami aktivních parametrů z celkových 230 miliard. Jeho zveřejněný profil zahrnuje uvažování, nástroje pro volání funkcí, strukturované výstupy a katalogový kontext 204 800 tokenů.

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

Neuvedeno Při výběru rychlého režimu

Režim flex

Neuvedeno Při výběru režimu flex

Maximální intenzita uvažování

Neuvedeno Když se při maximální intenzitě uvažování použije výchozí úprava (default)

#### Sazby Ailoot

#### Ceny podle konfigurace

| Konfigurace | Tabulka sazeb | Poplatek |
| --- | --- | --- |
| KonfiguraceZákladní sazby za tokeny | Tabulka sazebZákladní sazba | Poplatek Vstup · Vstupní tokeny **$0.0006** / 1K tokenů Výstup · Výstupní tokeny **$0.0024** / 1K tokenů Vstup · Čtení z mezipaměti **$0.00006** / 1K tokenů Vstup · Zápis do mezipaměti **$0.00075** / 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-M2",
  "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-M2', '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-M2', '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

<strong>Ailoot</strong> [`MiniMax-M2`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m2&route=Core&caller=MiniMax-M2&fmt=messages), [`minimax/minimax-m2`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m2&route=Core&caller=minimax%2Fminimax-m2&fmt=messages)
**Ailoot Ultra** [`MiniMax-M2`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m2&route=Ultra&caller=MiniMax-M2&fmt=messages), [`minimax/minimax-m2`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m2&route=Ultra&caller=minimax%2Fminimax-m2&fmt=messages)

#### Aliasy cest metod

`/chat/completions`

#### Související ID modelů

[`minimax/minimax-m2`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m2&route=Core&caller=minimax%2Fminimax-m2&fmt=messages), [`minimax/minimax-m2`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m2&route=Ultra&caller=minimax%2Fminimax-m2&fmt=messages), [`MiniMax-M2`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m2&route=Core&caller=MiniMax-M2&fmt=messages), [`MiniMax-M2`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m2&route=Ultra&caller=MiniMax-M2&fmt=messages)

**Ailoot · Anthropic Messages** `POST /v1/messages` `minimax/minimax-m2`

[`minimax/minimax-m2`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m2&route=Core&caller=minimax%2Fminimax-m2&fmt=messages)

MiniMax /`minimax/minimax-m2`

ID modelu

- `MiniMax-M2`
- `minimax/minimax-m2`

### Úvod

MiniMax M2 je textový model společnosti MiniMax pro programování od začátku do konce a agentní postupy, s 10 miliardami aktivních parametrů z celkových 230 miliard. Jeho zveřejněný profil zahrnuje uvažování, nástroje pro volání funkcí, strukturované výstupy a katalogový kontext 204 800 tokenů.

Přijímané vstupy

Text

Výsledky

Text

### Dostupné v Ailoot · vstupy a metody

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

Vstup

`text`

Výstup

`text`

Kontext

204 800 tokens

Maximální výstup

204 800 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-m2 | 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`

Parametry a životní cyklus metody

| Parametr | Kontrakt |
| --- | --- |
| Parametr`material_types` | Kontrakttext |
| 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,00003 US$ */ 1K*

Zápis do mezipaměti

0,000375 US$ */ 1K*

Zápis do mezipaměti, 5 min

0,000375 US$ */ 1K tokens*

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 | Poplatek |
| --- | --- | --- |
| KonfiguraceOpenAI Chat · Základní sazby za tokeny | Tabulka sazebZákladní sazba | Poplatek Vstup · Vstupní tokeny **$0.0006** / 1K tokenů Výstup · Výstupní tokeny **$0.0024** / 1K tokenů Vstup · Čtení z mezipaměti **$0.00006** / 1K tokenů Vstup · Zápis do mezipaměti **$0.00075** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguraceAnthropic Messages · Základní sazby za tokeny | Tabulka sazebZákladní sazba | Poplatek Vstup · Vstupní tokeny **$0.0006** / 1K tokenů Výstup · Výstupní tokeny **$0.0024** / 1K tokenů Vstup · Čtení z mezipaměti **$0.00006** / 1K tokenů Vstup · Zápis do mezipaměti **$0.00075** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |

### Příklady požadavků

#### Ailoot · Anthropic Messages

Textový příkladPython 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-m2", "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
```

```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-m2",
    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-m2",
  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-m2',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

<strong>Ailoot</strong> [`MiniMax-M2`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m2&route=Core&caller=MiniMax-M2&fmt=messages), [`minimax/minimax-m2`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m2&route=Core&caller=minimax%2Fminimax-m2&fmt=messages)
**Ailoot Ultra** [`MiniMax-M2`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m2&route=Ultra&caller=MiniMax-M2&fmt=messages), [`minimax/minimax-m2`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m2&route=Ultra&caller=minimax%2Fminimax-m2&fmt=messages)

#### Aliasy cest metod

`/chat/completions`

#### Související ID modelů

[`minimax/minimax-m2`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m2&route=Core&caller=minimax%2Fminimax-m2&fmt=messages), [`minimax/minimax-m2`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m2&route=Ultra&caller=minimax%2Fminimax-m2&fmt=messages), [`MiniMax-M2`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m2&route=Core&caller=MiniMax-M2&fmt=messages), [`MiniMax-M2`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m2&route=Ultra&caller=MiniMax-M2&fmt=messages)

**Ailoot · OpenAI Responses** `POST /v1/responses` `minimax/minimax-m2`

[`minimax/minimax-m2`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m2&route=Core&caller=minimax%2Fminimax-m2&fmt=responses)

MiniMax /`minimax/minimax-m2`

ID modelu

- `MiniMax-M2`
- `minimax/minimax-m2`

### Úvod

MiniMax M2 je textový model společnosti MiniMax pro programování od začátku do konce a agentní postupy, s 10 miliardami aktivních parametrů z celkových 230 miliard. Jeho zveřejněný profil zahrnuje uvažování, nástroje pro volání funkcí, strukturované výstupy a katalogový kontext 204 800 tokenů.

Přijímané vstupy

Text

Výsledky

Text

### Dostupné v Ailoot · vstupy a metody

**Ailoot · OpenAI Responses** `POST /v1/responses`

Vstup

`text`

Výstup

`text`

Kontext

204 800 tokens

Maximální výstup

204 800 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-m2 | 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`

Parametry a životní cyklus metody

| Parametr | Kontrakt |
| --- | --- |
| Parametr`material_types` | Kontrakttext |
| 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,00003 US$ */ 1K*

Zápis do mezipaměti

0,000375 US$ */ 1K*

Zápis do mezipaměti, 5 min

0,000375 US$ */ 1K tokens*

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 | Poplatek |
| --- | --- | --- |
| KonfiguraceOpenAI Chat · Základní sazby za tokeny | Tabulka sazebZákladní sazba | Poplatek Vstup · Vstupní tokeny **$0.0006** / 1K tokenů Výstup · Výstupní tokeny **$0.0024** / 1K tokenů Vstup · Čtení z mezipaměti **$0.00006** / 1K tokenů Vstup · Zápis do mezipaměti **$0.00075** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguraceAnthropic Messages · Základní sazby za tokeny | Tabulka sazebZákladní sazba | Poplatek Vstup · Vstupní tokeny **$0.0006** / 1K tokenů Výstup · Výstupní tokeny **$0.0024** / 1K tokenů Vstup · Čtení z mezipaměti **$0.00006** / 1K tokenů Vstup · Zápis do mezipaměti **$0.00075** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |

### Příklady požadavků

#### Ailoot · OpenAI Responses

Textový příkladPython 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-m2", "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
```

```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-m2", 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-m2", 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-m2", 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

<strong>Ailoot</strong> [`MiniMax-M2`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m2&route=Core&caller=MiniMax-M2&fmt=responses), [`minimax/minimax-m2`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m2&route=Core&caller=minimax%2Fminimax-m2&fmt=responses)
**Ailoot Ultra** [`MiniMax-M2`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m2&route=Ultra&caller=MiniMax-M2), [`minimax/minimax-m2`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m2&route=Ultra&caller=minimax%2Fminimax-m2)

#### Aliasy cest metod

`/chat/completions`

#### Související ID modelů

[`minimax/minimax-m2`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m2&route=Core&caller=minimax%2Fminimax-m2&fmt=responses), [`minimax/minimax-m2`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m2&route=Ultra&caller=minimax%2Fminimax-m2), [`MiniMax-M2`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m2&route=Core&caller=MiniMax-M2&fmt=responses), [`MiniMax-M2`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m2&route=Ultra&caller=MiniMax-M2)

**Ailoot · OpenAI Chat** `POST /v1/chat/completions` `minimax/minimax-m2`

[`minimax/minimax-m2`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m2&route=Core&caller=minimax%2Fminimax-m2&fmt=chat)

MiniMax /`minimax/minimax-m2`

ID modelu

- `MiniMax-M2`
- `minimax/minimax-m2`

### Úvod

MiniMax M2 je textový model společnosti MiniMax pro programování od začátku do konce a agentní postupy, s 10 miliardami aktivních parametrů z celkových 230 miliard. Jeho zveřejněný profil zahrnuje uvažování, nástroje pro volání funkcí, strukturované výstupy a katalogový kontext 204 800 tokenů.

Přijímané vstupy

Text

Výsledky

Text

### Dostupné v Ailoot · vstupy a metody

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

Vstup

`text`

Výstup

`text`

Kontext

204 800 tokens

Maximální výstup

204 800 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-m2 | 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`

Parametry a životní cyklus metody

| Parametr | Kontrakt |
| --- | --- |
| Parametr`material_types` | Kontrakttext |
| 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,00003 US$ */ 1K*

Zápis do mezipaměti

0,000375 US$ */ 1K*

Zápis do mezipaměti, 5 min

0,000375 US$ */ 1K tokens*

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 | Poplatek |
| --- | --- | --- |
| KonfiguraceOpenAI Chat · Základní sazby za tokeny | Tabulka sazebZákladní sazba | Poplatek Vstup · Vstupní tokeny **$0.0006** / 1K tokenů Výstup · Výstupní tokeny **$0.0024** / 1K tokenů Vstup · Čtení z mezipaměti **$0.00006** / 1K tokenů Vstup · Zápis do mezipaměti **$0.00075** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |
| KonfiguraceAnthropic Messages · Základní sazby za tokeny | Tabulka sazebZákladní sazba | Poplatek Vstup · Vstupní tokeny **$0.0006** / 1K tokenů Výstup · Výstupní tokeny **$0.0024** / 1K tokenů Vstup · Čtení z mezipaměti **$0.00006** / 1K tokenů Vstup · Zápis do mezipaměti **$0.00075** / 1K tokenů Vstup · Zápis do mezipaměti, 1 hodina **—** / 1K tokenů |

### Příklady požadavků

#### Ailoot · OpenAI Chat

Textový příkladPython 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-m2", "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
```

```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-m2",
    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-m2",
  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-m2',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

<strong>Ailoot</strong> [`MiniMax-M2`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m2&route=Core&caller=MiniMax-M2&fmt=chat), [`minimax/minimax-m2`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m2&route=Core&caller=minimax%2Fminimax-m2&fmt=chat)
**Ailoot Ultra** [`MiniMax-M2`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m2&route=Ultra&caller=MiniMax-M2&fmt=chat), [`minimax/minimax-m2`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m2&route=Ultra&caller=minimax%2Fminimax-m2&fmt=chat)

#### Aliasy cest metod

`/chat/completions`

#### Související ID modelů

[`minimax/minimax-m2`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m2&route=Core&caller=minimax%2Fminimax-m2&fmt=chat), [`minimax/minimax-m2`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m2&route=Ultra&caller=minimax%2Fminimax-m2&fmt=chat), [`MiniMax-M2`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m2&route=Core&caller=MiniMax-M2&fmt=chat), [`MiniMax-M2`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m2&route=Ultra&caller=MiniMax-M2&fmt=chat)

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

[`minimax/minimax-m2`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m2&route=Ultra&caller=minimax%2Fminimax-m2&fmt=chat)

MiniMax /`minimax/minimax-m2`

ID modelu

- `MiniMax-M2`
- `minimax/minimax-m2`

### Úvod

MiniMax M2 je textový model společnosti MiniMax pro programování od začátku do konce a agentní postupy, s 10 miliardami aktivních parametrů z celkových 230 miliard. Jeho zveřejněný profil zahrnuje uvažování, nástroje pro volání funkcí, strukturované výstupy a katalogový kontext 204 800 tokenů.

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

Neuvedeno Při výběru rychlého režimu

Režim flex

Neuvedeno Při výběru režimu flex

Maximální intenzita uvažování

Neuvedeno Když se při maximální intenzitě uvažování použije výchozí úprava (default)

#### Sazby Ailoot

#### Ceny podle konfigurace

| Konfigurace | Tabulka sazeb | Poplatek |
| --- | --- | --- |
| KonfiguraceZákladní sazby za tokeny | Tabulka sazebZákladní sazba | Poplatek Vstup · Vstupní tokeny **$0.0006** / 1K tokenů Výstup · Výstupní tokeny **$0.0024** / 1K tokenů Vstup · Čtení z mezipaměti **$0.00006** / 1K tokenů Vstup · Zápis do mezipaměti **$0.00075** / 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-m2", "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-m2',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-m2',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

<strong>Ailoot</strong> [`MiniMax-M2`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m2&route=Core&caller=MiniMax-M2&fmt=chat), [`minimax/minimax-m2`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m2&route=Core&caller=minimax%2Fminimax-m2&fmt=chat)
**Ailoot Ultra** [`MiniMax-M2`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m2&route=Ultra&caller=MiniMax-M2&fmt=chat), [`minimax/minimax-m2`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m2&route=Ultra&caller=minimax%2Fminimax-m2&fmt=chat)

#### Aliasy cest metod

`/chat/completions`

#### Související ID modelů

[`minimax/minimax-m2`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m2&route=Core&caller=minimax%2Fminimax-m2&fmt=chat), [`minimax/minimax-m2`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m2&route=Ultra&caller=minimax%2Fminimax-m2&fmt=chat), [`MiniMax-M2`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m2&route=Core&caller=MiniMax-M2&fmt=chat), [`MiniMax-M2`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m2&route=Ultra&caller=MiniMax-M2&fmt=chat)

**Ailoot Ultra · Anthropic Messages** `POST /v1/messages` `minimax/minimax-m2`

[`minimax/minimax-m2`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m2&route=Ultra&caller=minimax%2Fminimax-m2&fmt=messages)

MiniMax /`minimax/minimax-m2`

ID modelu

- `MiniMax-M2`
- `minimax/minimax-m2`

### Úvod

MiniMax M2 je textový model společnosti MiniMax pro programování od začátku do konce a agentní postupy, s 10 miliardami aktivních parametrů z celkových 230 miliard. Jeho zveřejněný profil zahrnuje uvažování, nástroje pro volání funkcí, strukturované výstupy a katalogový kontext 204 800 tokenů.

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

Neuvedeno Při výběru rychlého režimu

Režim flex

Neuvedeno Při výběru režimu flex

Maximální intenzita uvažování

Neuvedeno Když se při maximální intenzitě uvažování použije výchozí úprava (default)

#### Sazby Ailoot

#### Ceny podle konfigurace

| Konfigurace | Tabulka sazeb | Poplatek |
| --- | --- | --- |
| KonfiguraceZákladní sazby za tokeny | Tabulka sazebZákladní sazba | Poplatek Vstup · Vstupní tokeny **$0.0006** / 1K tokenů Výstup · Výstupní tokeny **$0.0024** / 1K tokenů Vstup · Čtení z mezipaměti **$0.00006** / 1K tokenů Vstup · Zápis do mezipaměti **$0.00075** / 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-m2",
  "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-m2', '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-m2', '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

<strong>Ailoot</strong> [`MiniMax-M2`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m2&route=Core&caller=MiniMax-M2&fmt=messages), [`minimax/minimax-m2`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m2&route=Core&caller=minimax%2Fminimax-m2&fmt=messages)
**Ailoot Ultra** [`MiniMax-M2`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m2&route=Ultra&caller=MiniMax-M2&fmt=messages), [`minimax/minimax-m2`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m2&route=Ultra&caller=minimax%2Fminimax-m2&fmt=messages)

#### Aliasy cest metod

`/chat/completions`

#### Související ID modelů

[`minimax/minimax-m2`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m2&route=Core&caller=minimax%2Fminimax-m2&fmt=messages), [`minimax/minimax-m2`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m2&route=Ultra&caller=minimax%2Fminimax-m2&fmt=messages), [`MiniMax-M2`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m2&route=Core&caller=MiniMax-M2&fmt=messages), [`MiniMax-M2`](https://ailoot.ai/models/cs/#m=minimax%2Fminimax-m2&route=Ultra&caller=MiniMax-M2&fmt=messages)

FAQ · MiniMax: MiniMax M2

Jaké vstupy a výsledky jsou dostupné?

`POST /v1/messages` · `MiniMax-M2`: `text` → `text` `POST /v1/responses` · `MiniMax-M2`: `text` → `text` `POST /v1/chat/completions` · `MiniMax-M2`: `text` → `text` `POST /v1/chat/completions` · `MiniMax-M2`: `text` → `text` `POST /v1/messages` · `MiniMax-M2`: `text` → `json`, `sse` `POST /v1/messages` · `minimax/minimax-m2`: `text` → `text` `POST /v1/responses` · `minimax/minimax-m2`: `text` → `text` `POST /v1/chat/completions` · `minimax/minimax-m2`: `text` → `text` `POST /v1/chat/completions` · `minimax/minimax-m2`: `text` → `text` `POST /v1/messages` · `minimax/minimax-m2`: `text` → `json`, `sse`

Jaká pole požadavek používá?

`POST /v1/messages` · `MiniMax-M2`: `model`, `messages`, `system`, `max_tokens`, `stream`, `metadata` `POST /v1/responses` · `MiniMax-M2`: `model`, `input`, `instructions`, `stream` `POST /v1/chat/completions` · `MiniMax-M2`: `model`, `messages`, `stream` `POST /v1/chat/completions` · `MiniMax-M2`: `model`, `messages`, `stream` `POST /v1/messages` · `MiniMax-M2`: `model`, `messages`, `max_tokens`, `stream` `POST /v1/messages` · `minimax/minimax-m2`: `model`, `messages`, `system`, `max_tokens`, `stream`, `metadata` `POST /v1/responses` · `minimax/minimax-m2`: `model`, `input`, `instructions`, `stream` `POST /v1/chat/completions` · `minimax/minimax-m2`: `model`, `messages`, `stream` `POST /v1/chat/completions` · `minimax/minimax-m2`: `model`, `messages`, `stream`, `modalities`, `provider` `POST /v1/messages` · `minimax/minimax-m2`: `model`, `messages`, `max_tokens`, `stream`

Jaké limity platí?

`POST /v1/messages` · `MiniMax-M2`: `ctx`: `204800`; `max_out`: `204800`; `messages.min_items`: `1`; `max_tokens.minimum`: `1` `POST /v1/responses` · `MiniMax-M2`: `ctx`: `204800`; `max_out`: `204800` `POST /v1/chat/completions` · `MiniMax-M2`: `ctx`: `204800`; `max_out`: `204800`; `messages.min_items`: `1` `POST /v1/chat/completions` · `MiniMax-M2`: `messages.min_items`: `1` `POST /v1/messages` · `minimax/minimax-m2`: `ctx`: `204800`; `max_out`: `204800`; `messages.min_items`: `1`; `max_tokens.minimum`: `1` `POST /v1/responses` · `minimax/minimax-m2`: `ctx`: `204800`; `max_out`: `204800` `POST /v1/chat/completions` · `minimax/minimax-m2`: `ctx`: `204800`; `max_out`: `204800`; `messages.min_items`: `1` `POST /v1/chat/completions` · `minimax/minimax-m2`: `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.