Source: https://ailoot.ai/models/de/mistralai-mistral-small-3-1-24b-instruct/
Canonical: https://ailoot.ai/models/de/mistralai-mistral-small-3-1-24b-instruct/
Language: de

# Mistral: Mistral Small 3.1 24B

[Markdown](https://ailoot.ai/models/de/mistralai-mistral-small-3-1-24b-instruct/index.md) · [JSON](https://ailoot.ai/models/de/mistralai-mistral-small-3-1-24b-instruct/facts.json)

## [Mistral: Mistral Small 3.1 24B](https://ailoot.ai/models/de/mistralai-mistral-small-3-1-24b-instruct/)

Mistral Small 3.1 24B Instruct 2503 ergänzt die Small-3-Linie um Bildverständnis und einen vom Hersteller angegebenen Kontext von 128k. Es verbindet mehrsprachigen Text, Programmierung und mathematisches Schlussfolgern mit Systemanweisungen, JSON und nativen Funktionsaufrufen in einer eigenständigen, auf Anweisungen abgestimmten Veröffentlichung.

- [**Ailoot Ultra · OpenAI Chat** `POST /v1/chat/completions` `mistralai/mistral-small-3.1-24b-instruct`](https://ailoot.ai/models/de/mistralai-mistral-small-3-1-24b-instruct/#method-0)
- [**Ailoot Ultra · Anthropic Messages** `POST /v1/messages` `mistralai/mistral-small-3.1-24b-instruct`](https://ailoot.ai/models/de/mistralai-mistral-small-3-1-24b-instruct/#method-1)

Über das Modell

Diese Beschreibung erläutert die Fähigkeiten des Modells. Die über Ailoot verfügbaren Eingaben, Ausgaben und Optionen sind unten für die ausgewählte Methode aufgeführt.

Mistral Small 3.1 24B Instruct 2503 baut auf Small 3 2501 auf, ergänzt visuelles Verständnis und erweitert die Unterstützung langer Kontexte auf 128k Tokens. Es hat 24 Milliarden Parameter und wurde aus der separat benannten Veröffentlichung Small 3.1 Base auf Anweisungen abgestimmt. Das Modell verarbeitet Text und Bilder und erzeugt Text, darunter eine Erklärung, Code oder einen strukturierten Datensatz.

Zentrale Fähigkeiten

Visuelle Fähigkeiten ermöglichen dem Modell, sichtbares Material gemeinsam mit der Nutzerfrage zu analysieren. Ein Dokumentbild kann das zu prüfende Feld oder die Aussage liefern, ein Diagramm die zu erklärende Beziehung und eine Grafik die Daten hinter einem Vergleich. Halte Beschriftungen, Einheiten und relevante umgebende Inhalte lesbar, damit sich die Frage auf Belege bezieht, die tatsächlich im Bild vorhanden sind.

Der Hersteller nennt mehrsprachige Unterstützung für Dutzende Sprachen, darunter Russisch, Englisch, Französisch, Deutsch, Griechisch, Hindi, Indonesisch, Italienisch, Japanisch, Koreanisch, Malaiisch, Nepali, Polnisch, Portugiesisch, Rumänisch, Serbisch, Spanisch, Schwedisch, Türkisch, Ukrainisch, Vietnamesisch, Arabisch, Bengalisch, Chinesisch und Farsi. Definiere für eine mehrsprachige Antwort Zielsprache, Leser und Terminologie. Namen, zitierte Bezeichnungen, Variablenkennungen und Einheiten können unverändert bleiben, während die umgebende Prosa angepasst wird.

Die Modellkarte beschreibt außerdem Dialog- und Reasoning-Fähigkeiten, native Funktionsaufrufe, JSON-Ausgabe und die Befolgung von Systemprompts. Der Tokenizer ist Tekken mit einem als 131k bezeichneten Vokabular. Dies sind Funktionen der benannten, auf Anweisungen abgestimmten Veröffentlichung; ihre Base-Ausgabe hat eine andere Rolle, und spätere Veröffentlichungen Small 3.2 und Small 4 behalten ihre eigenen Änderungen und Modi.

Vorbereitung von Dokument-, Programmier- und Mathematikaufgaben

Benenne bei einer Aufgabe zu langen Dokumenten die Dokumente und stelle eine definierte Frage. Ein Vergleich kann eine Anforderungsmatrix mit Aussage, Quellabschnitt und möglichen Widersprüchen zwischen Dokumenten verlangen. Eine Zusammenfassung kann ausschließlich das für eine benannte Änderung relevante Material anfordern. Der lange Kontext hält diese Quellen zusammen, während die endgültige Antwort knapp bleiben kann.

Stelle für eine Codeerklärung die Funktion und die Eingabe bereit, deren Verhalten nachvollzogen werden soll. Füge relevante Hilfsfunktionen oder Deklarationen hinzu und frage, wie sich der Zustand vor der Wertrückgabe verändert. Nenne für eine vorgeschlagene Änderung die Anforderung, die zu bewahrende öffentliche Schnittstelle und die erwartete Ausgabe. Fordere den überarbeiteten Code getrennt von Erklärung und Beispielen an.

Definiere bei einer mathematischen Aufgabe die Symbole und Bereichsannahmen, bevor du eine Herleitung anforderst. Lege fest, ob das Endergebnis exakt, gerundet oder ein Beweis einer Behauptung sein soll. Wenn die Bedingung in einem Bild steht, halte Formel und zugehörige Beschriftungen klar und bitte das Modell, diese Notation in seiner Antwort zu bewahren. Diese Vorbereitungen setzen den dokumentierten Schwerpunkt des Modells auf Programmierung und mathematisches Schlussfolgern in ein prüfbares Artefakt um.

Anweisungsformat und empfohlene Verwendung

Der Hersteller veröffentlicht eine V7-Tekken-Dialogvorlage, die System-, Nutzer- und Assistentenrollen unterscheidet, und empfiehlt die passende Tokenizer-Implementierung als maßgebliche Referenz. Eine Systemanweisung sollte Rolle und Antwortregeln des Assistenten definieren, während die Nutzernachricht die eigentliche Aufgabe und das Quellenmaterial enthält. Korrekte Dialogformatierung unterscheidet sich davon, rollenähnliche Bezeichnungen in ein zitiertes Dokument einzufügen.

Die Modellkarte empfiehlt eine relativ niedrige Temperatur wie 0,15 und einen auf den Anwendungsfall zugeschnittenen Systemprompt. Definiere Ausgabefelder oder Abschnitte sowie die Bedingungen, die bei einer Überarbeitung erhalten bleiben müssen. Fordere für wiederholte Extraktionen JSON mit festgelegten Namen und Typen sowie einer Darstellung von Werten an, die in der Quelle fehlen. Ein erklärender Absatz kann separat zurückgegeben werden, wenn eine Person die Interpretation prüfen muss.

Ablauf für Funktionsaufrufe

Das Modell kann eine Funktion aus den von der Anwendung beschriebenen Werkzeugen auswählen und ihre Argumente erzeugen. Die Anwendung führt die Funktion aus, gibt das Ergebnis mit dem zugehörigen Werkzeugaufruf zurück, und das Modell verwendet dieses Ergebnis in einer späteren Antwort. Das Herstellerbeispiel zeigt diesen Dialogzyklus einschließlich früheren Werkzeugeinsatzes und einer neuen Nutzerfrage. Eine vorgeschlagene Abfrage ist daher von den Daten getrennt, die die Abfrage tatsächlich zurückgibt.

Ein praktischer Assistent kann zunächst eine Frage aus einem Dokument extrahieren und dann eine bereitgestellte Referenzfunktion nutzen, um eine fehlende Bedingung zu erhalten. Beschreibe die Funktion klar, füge ihre Pflichtargumente hinzu und bewahre das zurückgegebene Ergebnis zusammen mit der ursprünglichen Operation. JSON ordnet ein Textergebnis; ein Funktionsaufruf fordert eine verbundene Operation an, statt unbemerkt Code auszuführen oder eine Datenbank zu lesen.

Inhaltliche Grenzen

Die dokumentierte visuelle Fähigkeit liest Bilder; sie erzeugt sie nicht. Die veröffentlichten Assistentenhinweise unterscheiden dieses Modell außerdem von Audio- und Videotranskription, sodass bei einer gesprochenen oder videobasierten Frage der relevante Inhalt durch einen geeigneten separaten Vorbereitungsschritt bereitgestellt werden muss. Webzugriff und externe Handlungen stammen ebenfalls aus verbundenen Werkzeugen und nicht allein aus dem Text- und Bildmodell.

Der Kontext von 128k betrifft die Eingabe der Aufgabe und den erzeugten Dialog, während das Generierungsbeispiel mit 512 Tokens in der Modellkarte nur eine Beispieleinstellung ist. In den gelesenen Quellen ist keine separate harte Antwortlängenkapazität angegeben. Bewahre die genaue Ausgabe Instruct 2503, ihr Dialogformat und die gewünschte Erklärung, den Datensatz oder das Codeartefakt.

Praktische Aufgabe

### Praktische Aufgabe

Technisches Beispiel auf Englisch

```
Trace an accumulator function

Trace this Python function on [3, -1, 4]: 'def running_sum(xs):
    total = 0
    out = []
    for x in xs:
        total += x
        out.append(total)
    return out'. Give a row for each iteration showing x, total and out, then the return value. Explain in one sentence why out differs from doubling each element.
```

#### Erwartetes Ergebnis

```
A three-row state trace, the final list and one sentence distinguishing cumulative addition from elementwise multiplication.
```

#### Ergebnis prüfen

```
Each row uses the prior total, including the negative input, rather than restarting the accumulator.
```

**Ailoot Ultra · OpenAI Chat** `POST /v1/chat/completions` `mistralai/mistral-small-3.1-24b-instruct`

[`mistralai/mistral-small-3.1-24b-instruct`](https://ailoot.ai/models/de/#m=mistralai%2Fmistral-small-3.1-24b-instruct&route=Ultra&caller=mistralai%2Fmistral-small-3.1-24b-instruct&fmt=chat)

Mistral /`mistralai/mistral-small-3.1-24b-instruct`

### Start

Mistral Small 3.1 24B Instruct 2503 ergänzt die Small-3-Linie um Bildverständnis und einen vom Hersteller angegebenen Kontext von 128k. Es verbindet mehrsprachigen Text, Programmierung und mathematisches Schlussfolgern mit Systemanweisungen, JSON und nativen Funktionsaufrufen in einer eigenständigen, auf Anweisungen abgestimmten Veröffentlichung.

Zulässige Eingaben

Text

Ergebnisse

Text

### In Ailoot verfügbar · Eingaben und Methoden

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

Eingabetypen

`text`

Ausgabetypen

`text`

Ausgabeformat

json oder SSE

| Feld | Typ | Anforderung | Werte und Limits | Standard |
| --- | --- | --- | --- | --- |
| Feld`model` | Typ`string` | AnforderungErforderlich | Werte und Limits mistralai/mistral-small-3.1-24b-instruct | Standard— |
| Feld`messages` | Typ`message[]` | AnforderungErforderlich | Werte und Limits Mindestanzahl Elemente: 1 | Standard— |
| Feld`messages[].role` | Typ`string` | AnforderungErforderlich | Werte und Limits Beispiele: system, user, assistant, tool, function Bedingungen: Diese Rollen sind in den Kompatibilitätstypen des Quellcodes ausdrücklich dargestellt; der genaue Rollenumfang bleibt modellspezifisch. Modellabhängig | Standard— |
| Feld`messages[].content` | Typ`string\|content_part[]\|null` | AnforderungOptional | Werte und Limits | Standard— |
| Feld`messages[].tool_calls` | Typ`tool_call[]` | AnforderungOptional | Werte und Limits | Standard— |
| Feld`messages[].tool_call_id` | Typ`string` | AnforderungOptional | Werte und Limits Gilt, wenn: role=tool; die tatsächlich zurückgegebene ID verwenden | Standard— |
| Feld`messages[].name` | Typ`string` | AnforderungOptional | Werte und Limits | Standard— |
| Feld`messages[].reasoning_content` | Typ`string` | AnforderungOptional | Werte und Limits Gilt, wenn: Tatsächlich zurückgegebene Reasoning-Daten erneut übermitteln, sofern dieses Modell sie verwendet | Standard— |
| Feld`messages[].reasoning_details` | Typ`object\|array` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`max_tokens` | Typ`integer` | AnforderungOptional | Werte und Limits Minimum: 1 Modellabhängig | Standard— |
| Feld`max_completion_tokens` | Typ`integer` | AnforderungOptional | Werte und Limits Minimum: 1 Modellabhängig | Standard— |
| Feld`stream` | Typ`boolean` | AnforderungOptional | Werte und Limits | Standardfalse |
| Feld`stream_options.include_usage` | Typ`boolean` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`temperature` | Typ`number` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`top_p` | Typ`number` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`stop` | Typ`string\|string[]` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`tools` | Typ`function_tool[]` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`tools[].type` | Typ`string` | AnforderungOptional | Werte und Limits function Modellabhängig | Standard— |
| Feld`tools[].function.name` | Typ`string` | AnforderungErforderlich | Werte und Limits Gilt, wenn: Funktionswerkzeug bereitgestellt | Standard— |
| Feld`tools[].function.description` | Typ`string` | AnforderungOptional | Werte und Limits | Standard— |
| Feld`tools[].function.parameters` | Typ`JSON_schema` | AnforderungOptional | Werte und Limits | Standard— |
| Feld`tool_choice` | Typ`string\|object` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`parallel_tool_calls` | Typ`boolean` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`response_format` | Typ`object` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`reasoning_effort` | Typ`string` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`reasoning` | Typ`object` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`service_tier` | Typ`string` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`instructions` | Typ`string` | AnforderungOptional | Werte und Limits Kompatibilitätsfeld | Standard— |
| Feld`functions` | Typ`function[]` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`function_call` | Typ`string\|object` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`prompt_cache_options` | Typ`object` | AnforderungOptional | Werte und Limits Modellabhängig | Standard— |
| Feld`modalities` | Typ`string[]` | AnforderungOptional | Werte und Limits text | Standard— |
| Feld`provider` | Typ`object` | AnforderungOptional | Werte und Limits Bedingungen: provider.options wird auf dieser Ultra-Textroute abgelehnt | Standard— |
| Feld`cache_control.ttl` | Typ`string` | AnforderungOptional | Werte und Limits Bedingungen: 1h wird in den tatsächlichen Prompt-Cache-Feldern abgelehnt | Standard— |

Kombinationen von Eingabematerialien

**Text** · UTF8-Text

`messages[].content`

Methodenparameter und Lebenszyklus

| Parameter | Vertrag |
| --- | --- |
| Parameter`content_type` | Vertragapplication/json |
| Parameter`required` | Vertragmodel, messages |
| Parameter`material_types` | Vertragtext |
| Parameter`messages` | VertragNachrichtenarray mit role/content-Struktur |
| Parameter`file_material` | VertragTatsächliches UTF-8-Dokument als wörtlicher Text eingefügt; keine Datei-ID abgeleitet |
| Parameter`optional_controls` | Vertragstream, temperature, top\_p, stop, max\_tokens, max\_completion\_tokens, reasoning, response\_format, tools, tool\_choice |
| Parameter`control_scope` | VertragModellspezifisch; benutzerseitige Funktionswerkzeuge unterscheiden sich von gehosteten Werkzeugen |
| Parameter`output_modalities` | Vertragtext |
| Parameter`hosted_operations` | Vertragfalse |
| Parameter`multimodal_input_binding` | Vertragnull |

Lebenszyklus: `synchronous_or_streamed`

Die genaue Modell-ID zusammen mit messages senden.

Die Kontextlänge ist keine Ausgabeobergrenze.

Eine Textdatei kann wörtlichen Text liefern; Bild-, Audio- und Dateiobjekteingaben benötigen eine exakte Zuordnung.

### Tarife

Tarifangaben erweitern die Anfrageoptionen nicht. Unterstützte Parameter stehen bei der ausgewählten Methode.

Schnellmodus

Standardtarif Wenn der Schnellmodus ausgewählt ist

Flex-Modus

Standardtarif Wenn der Modus flex ausgewählt ist

Maximaler Denkaufwand

Standardtarif Wenn beim maximalen Denkaufwand die Standardanpassung (default) verwendet wird

#### Ailoot-Tarife

#### Preise nach Konfiguration

Ordnen Sie jede Gebühr den angezeigten Bedingungen zu. Verwenden Sie für jede Gruppe alternativer Konfigurationen einen Tarif.

| Konfiguration | Tarifstaffel | Kontexttoken, mehr als | Kontexttoken, bis einschließlich | Gebühr |
| --- | --- | --- | --- | --- |
| KonfigurationBasistarife für Token | TarifstaffelGrundtarif | Kontexttoken, mehr als— | Kontexttoken, bis einschließlichKeine Obergrenze | Gebühr Eingabe · Eingabetoken **$0.0011** / 1K Token Ausgabe · Ausgabetoken **$0.00111** / 1K Token Eingabe · Cache-Lesen **$0** / 1K Token Eingabe · Cache-Schreiben **$0** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token |
| KonfigurationAnfragelängenstufe 1 | Tarifstaffel— | Kontexttoken, mehr als0 | Kontexttoken, bis einschließlichKeine Obergrenze | Gebühr Eingabe · Eingabetoken **$0.0011** / 1K Token Ausgabe · Ausgabetoken **$0.00111** / 1K Token Eingabe · Cache-Lesen **$0** / 1K Token Eingabe · Cache-Schreiben **$0** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token |

Ailoot reserviert vor einer Anfrage einen geschätzten Betrag. Nach dem Ergebnis rechnet Ailoot die endgültige Gebühr anhand des gemessenen Verbrauchs ab. Bei Streaming erfolgt die Abrechnung anhand des abschließenden Verbrauchsdatensatzes. [So funktionieren Reservierung und Abrechnung →](https://ailoot.ai/docs/de/billing/reserve/)

### Beispielanfragen

#### Ailoot Ultra · OpenAI Chat

curlPython SDKPython-Stream

```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": "mistralai/mistral-small-3.1-24b-instruct", "messages": [{"role": "user", "content": "Explain the difference between an observation and a hypothesis in three sentences."}]}')

Path("request.json").write_text(json.dumps(p,ensure_ascii=False))
PY_REQUEST
curl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/chat/completions \
  -H "Authorization: Bearer $AILOOT_API_KEY" -H 'Content-Type: application/json' \
  --data-binary @request.json -D response-headers.txt -o result.json
python3 - <<'PY_RESULT'
import json
from pathlib import Path
r=json.loads(Path("result.json").read_text())
for x in r.get("choices",[]):
    if x.get("message",{}).get("content"): print(x["message"]["content"])
PY_RESULT
```

```python
from openai import OpenAI
import os

if not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")
client=OpenAI(base_url="https://api.ailoot.ai/v1",api_key=os.environ["AILOOT_API_KEY"],max_retries=0)
result=client.chat.completions.create(model='mistralai/mistral-small-3.1-24b-instruct',messages=[{"role":"user","content":"Explain observations and hypotheses in three sentences."}])
import base64, json
from pathlib import Path

def save_result(data, stem="result"):
    # Keep every field, including usage, IDs, reasoning and tool requests.
    Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
    print(json.dumps(data, ensure_ascii=False, indent=2))
    def save_blob(encoded, suffix, label):
        raw = base64.b64decode(encoded, altchars=b"-_", validate=True)
        ext = "png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "jpg" if raw.startswith(b"\xff\xd8") else "webp" if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" else suffix
        file = Path(stem + "-" + label + "." + ext)
        file.write_bytes(raw)
        print("Saved", file)
    for index, block in enumerate(data.get("content") or []):
        print("Content", index, json.dumps(block, ensure_ascii=False))
    for choice in data.get("choices") or []:
        print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))
    for index, item in enumerate(data.get("output") or []):
        print("Output", index, json.dumps(item, ensure_ascii=False))
        if item.get("type") == "image_generation_call" and item.get("result"):
            save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))
    for ci, candidate in enumerate(data.get("candidates") or []):
        for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):
            print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))
            blob = part.get("inlineData") or part.get("inline_data")
            if blob and blob.get("data"):
                mime = blob.get("mimeType") or blob.get("mime_type")
                suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")
                save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))

save_result(result.to_dict(mode="json"))
```

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

if not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")
client=OpenAI(base_url="https://api.ailoot.ai/v1",api_key=os.environ["AILOOT_API_KEY"],max_retries=0)
import base64, json
from pathlib import Path

def save_result(data, stem="result"):
    # Keep every field, including usage, IDs, reasoning and tool requests.
    Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")
    print(json.dumps(data, ensure_ascii=False, indent=2))
    def save_blob(encoded, suffix, label):
        raw = base64.b64decode(encoded, altchars=b"-_", validate=True)
        ext = "png" if raw.startswith(b"\x89PNG\r\n\x1a\n") else "jpg" if raw.startswith(b"\xff\xd8") else "webp" if raw[:4] == b"RIFF" and raw[8:12] == b"WEBP" else suffix
        file = Path(stem + "-" + label + "." + ext)
        file.write_bytes(raw)
        print("Saved", file)
    for index, block in enumerate(data.get("content") or []):
        print("Content", index, json.dumps(block, ensure_ascii=False))
    for choice in data.get("choices") or []:
        print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))
    for index, item in enumerate(data.get("output") or []):
        print("Output", index, json.dumps(item, ensure_ascii=False))
        if item.get("type") == "image_generation_call" and item.get("result"):
            save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))
    for ci, candidate in enumerate(data.get("candidates") or []):
        for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):
            print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))
            blob = part.get("inlineData") or part.get("inline_data")
            if blob and blob.get("data"):
                mime = blob.get("mimeType") or blob.get("mime_type")
                suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")
                save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))

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

### Ergebnisse abrufen und speichern

#### Ailoot Ultra · OpenAI Chat

json oder SSE

##### Alle fertiggestellten Ergebnisse aufbewahren

Bewahren Sie jede vollständig zurückgegebene Antwort, Datei und jeden Inhaltsteil auf.

Alle Antwortvarianten mit ihren Inhalten, Werkzeugaufrufen und Reasoning-Daten beibehalten. In SSE die Deltas nach Varianten- und Werkzeugindex zusammensetzen; endgültigen Beendigungsgrund und Verbrauchsdaten beibehalten.

##### Wenn die ursprüngliche Antwort geprüft werden muss

Anfrage- und Antwort-IDs sowie Header beibehalten. Eine allgemeine URL zum Abrufen von Textaufträgen wird nicht angegeben.

Antwortfelder

| Feld | Typ |
| --- | --- |
| Feld`choices[].index` | Typinteger |
| Feld`choices[].message.content` | Typstring\|null |
| Feld`choices[].message.tool_calls` | Typtool\_call\[\] |
| Feld`choices[].message.reasoning_content` | Typstring |
| Feld`choices[].message.reasoning_details` | Typobject\|array |
| Feld`choices[].finish_reason` | Typstring\|null |
| Feld`usage` | Typobject |

Fehler und nächste Schritte

| Antwort | Bedingung | Nächster Schritt |
| --- | --- | --- |
| Antwort400 · `invalid_request_error` | BedingungPflichtfelder, Darstellung des Eingabematerials oder Parameterwert ungültig | Nächster SchrittDie angegebenen Felder vor einer neuen Erstellungsanfrage korrigieren. |

### Aliasnamen

#### Modellaliasnamen

**Ailoot Ultra** [`mistralai/mistral-small-3.1-24b-instruct`](https://ailoot.ai/models/de/#m=mistralai%2Fmistral-small-3.1-24b-instruct&route=Ultra&caller=mistralai%2Fmistral-small-3.1-24b-instruct&fmt=chat)

#### Aliasnamen für Methodenpfade

Verwenden Sie die oben angezeigten Methodenpfade.

#### Zugehörige Aufrufer-IDs

[`mistralai/mistral-small-3.1-24b-instruct`](https://ailoot.ai/models/de/#m=mistralai%2Fmistral-small-3.1-24b-instruct&route=Ultra&caller=mistralai%2Fmistral-small-3.1-24b-instruct&fmt=chat)

**Ailoot Ultra · Anthropic Messages** `POST /v1/messages` `mistralai/mistral-small-3.1-24b-instruct`

[`mistralai/mistral-small-3.1-24b-instruct`](https://ailoot.ai/models/de/#m=mistralai%2Fmistral-small-3.1-24b-instruct&route=Ultra&caller=mistralai%2Fmistral-small-3.1-24b-instruct&fmt=messages)

Mistral /`mistralai/mistral-small-3.1-24b-instruct`

### Start

Mistral Small 3.1 24B Instruct 2503 ergänzt die Small-3-Linie um Bildverständnis und einen vom Hersteller angegebenen Kontext von 128k. Es verbindet mehrsprachigen Text, Programmierung und mathematisches Schlussfolgern mit Systemanweisungen, JSON und nativen Funktionsaufrufen in einer eigenständigen, auf Anweisungen abgestimmten Veröffentlichung.

Zulässige Eingaben

Text

Ergebnisse

json · sse

### In Ailoot verfügbar · Eingaben und Methoden

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

Eingabetypen

`text`

Ausgabetypen

`json`, `sse`

Ausgabeformat

JSON oder SSE

| Feld | Typ | Anforderung | Werte und Limits | Standard |
| --- | --- | --- | --- | --- |
| Feld`model` | Typ`string` | AnforderungErforderlich | Werte und Limits mistralai/mistral-small-3.1-24b-instruct | Standard— |
| Feld`messages` | Typ`message[]` | AnforderungErforderlich | Werte und Limits | Standard— |
| Feld`messages[].role` | Typ`string` | AnforderungErforderlich | Werte und Limits user, assistant | Standard— |
| Feld`messages[].content` | Typ`string` | AnforderungErforderlich | Werte und Limits | Standard— |
| Feld`max_tokens` | Typ`integer` | AnforderungErforderlich | Werte und Limits | Standard— |
| Feld`stream` | Typ`boolean` | AnforderungOptional | Werte und Limits | Standardfalse |

Kombinationen von Eingabematerialien

**Text** · UTF-8-Text

`Zeichenfolge messages[].content`

Methodenparameter und Lebenszyklus

| Parameter | Vertrag |
| --- | --- |
| Parameter`content_type` | Vertragapplication/json |
| Parameter`required` | Vertragmodel, messages, max\_tokens |
| Parameter`optional_controls` | Vertragstream |
| Parameter`material_types` | Vertragtext |
| Parameter`text_file_material` | VertragDas tatsächliche UTF-8-Dokument lesen und seinen Text in die angegebene Zeichenfolge für Eingabe oder Nachrichteninhalt einfügen. |

Lebenszyklus: `synchronous_or_streamed`

### Tarife

Tarifangaben erweitern die Anfrageoptionen nicht. Unterstützte Parameter stehen bei der ausgewählten Methode.

Schnellmodus

Standardtarif Wenn der Schnellmodus ausgewählt ist

Flex-Modus

Standardtarif Wenn der Modus flex ausgewählt ist

Maximaler Denkaufwand

Standardtarif Wenn beim maximalen Denkaufwand die Standardanpassung (default) verwendet wird

#### Ailoot-Tarife

#### Preise nach Konfiguration

Ordnen Sie jede Gebühr den angezeigten Bedingungen zu. Verwenden Sie für jede Gruppe alternativer Konfigurationen einen Tarif.

| Konfiguration | Tarifstaffel | Kontexttoken, mehr als | Kontexttoken, bis einschließlich | Gebühr |
| --- | --- | --- | --- | --- |
| KonfigurationBasistarife für Token | TarifstaffelGrundtarif | Kontexttoken, mehr als— | Kontexttoken, bis einschließlichKeine Obergrenze | Gebühr Eingabe · Eingabetoken **$0.0011** / 1K Token Ausgabe · Ausgabetoken **$0.00111** / 1K Token Eingabe · Cache-Lesen **$0** / 1K Token Eingabe · Cache-Schreiben **$0** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token |
| KonfigurationAnfragelängenstufe 1 | Tarifstaffel— | Kontexttoken, mehr als0 | Kontexttoken, bis einschließlichKeine Obergrenze | Gebühr Eingabe · Eingabetoken **$0.0011** / 1K Token Ausgabe · Ausgabetoken **$0.00111** / 1K Token Eingabe · Cache-Lesen **$0** / 1K Token Eingabe · Cache-Schreiben **$0** / 1K Token Eingabe · Cache-Schreiben, 1 Stunde **—** / 1K Token |

Ailoot reserviert vor einer Anfrage einen geschätzten Betrag. Nach dem Ergebnis rechnet Ailoot die endgültige Gebühr anhand des gemessenen Verbrauchs ab. Bei Streaming erfolgt die Abrechnung anhand des abschließenden Verbrauchsdatensatzes. [So funktionieren Reservierung und Abrechnung →](https://ailoot.ai/docs/de/billing/reserve/)

### Beispielanfragen

#### Ailoot Ultra · Anthropic Messages

Vollständiger minimaler JSON-Bodycurl · eigenes UTF-8-Dokument verwendenPython · das vollständige Ergebnis speichern

```json
{
  "model": "mistralai/mistral-small-3.1-24b-instruct",
  "max_tokens": 128,
  "messages": [
    {
      "role": "user",
      "content": "Summarize the incident report."
    }
  ],
  "stream": false
}
```

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

source_file = Path(os.environ['AILOOT_TEXT_FILE'])
if not source_file.is_file():
    raise SystemExit('Set AILOOT_TEXT_FILE to your actual UTF-8 document')
text = source_file.read_text(encoding='utf-8')
if not text.strip():
    raise SystemExit('Choose a document containing text')
payload = {'model': 'mistralai/mistral-small-3.1-24b-instruct', 'max_tokens': 128, 'messages': [{'role': 'user', 'content': 'Summarize the incident report.'}]}
payload['messages'][0]['content'] = 'Summarize this material and quote supporting source passages.\n\n' + text
Path('request.json').write_text(json.dumps(payload, ensure_ascii=False), encoding='utf-8')
PY_REQUEST
curl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/messages \
  -H "x-api-key: $AILOOT_API_KEY" -H 'anthropic-version: 2023-06-01' -H 'Content-Type: application/json' \
  --data-binary @request.json -D response-headers.txt -o result.json
python3 - <<'PY_RESULT'
import json
from pathlib import Path

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

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

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

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

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

### Ergebnisse abrufen und speichern

#### Ailoot Ultra · Anthropic Messages

JSON oder SSE

##### Alle fertiggestellten Ergebnisse aufbewahren

Bewahren Sie jede vollständig zurückgegebene Antwort, Datei und jeden Inhaltsteil auf.

Alle Inhaltsblöcke, Thinking-Signaturen und tatsächlichen Werkzeugaufruf-IDs beibehalten. Alle SSE-Blockdeltas zusammensetzen; der erste Textblock ist nicht die vollständige Ausgabe.

##### Wenn die ursprüngliche Antwort geprüft werden muss

Anfrage- und Antwort-IDs sowie Header beibehalten. Eine allgemeine URL zum Abrufen von Textaufträgen wird nicht angegeben.

Antwortfelder

| Feld | Typ |
| --- | --- |
| Feld`id` | Typstring |
| Feld`model` | Typstring |
| Feld`content[]` | Typtext\|thinking\|tool\_use\|other content block |
| Feld`stop_reason` | Typstring\|null |
| Feld`usage` | Typobject |

Fehler und nächste Schritte

| Antwort | Bedingung | Nächster Schritt |
| --- | --- | --- |
| Antwort400 · `invalid_request_error` | BedingungPflichtfelder, Darstellung des Eingabematerials oder Parameterwert ungültig | Nächster SchrittDie angegebenen Felder vor einer neuen Erstellungsanfrage korrigieren. |

### Aliasnamen

#### Modellaliasnamen

**Ailoot Ultra** [`mistralai/mistral-small-3.1-24b-instruct`](https://ailoot.ai/models/de/#m=mistralai%2Fmistral-small-3.1-24b-instruct&route=Ultra&caller=mistralai%2Fmistral-small-3.1-24b-instruct&fmt=messages)

#### Aliasnamen für Methodenpfade

Verwenden Sie die oben angezeigten Methodenpfade.

#### Zugehörige Aufrufer-IDs

[`mistralai/mistral-small-3.1-24b-instruct`](https://ailoot.ai/models/de/#m=mistralai%2Fmistral-small-3.1-24b-instruct&route=Ultra&caller=mistralai%2Fmistral-small-3.1-24b-instruct&fmt=messages)

FAQ · Mistral: Mistral Small 3.1 24B

Welche Eingaben und Ergebnisse sind verfügbar?

`POST /v1/chat/completions` · `mistralai/mistral-small-3.1-24b-instruct`: `text` → `text` `POST /v1/messages` · `mistralai/mistral-small-3.1-24b-instruct`: `text` → `json`, `sse`

Welche Felder verwendet die Anfrage?

`POST /v1/chat/completions` · `mistralai/mistral-small-3.1-24b-instruct`: `model`, `messages`, `stream`, `modalities`, `provider` `POST /v1/messages` · `mistralai/mistral-small-3.1-24b-instruct`: `model`, `messages`, `max_tokens`, `stream`

Welche Grenzen gelten?

`POST /v1/chat/completions` · `mistralai/mistral-small-3.1-24b-instruct`: `messages.min_items`: `1`

Verbinden Sie Ailoot mit Claude Code, OpenCode, Hermes oder Ihrer eigenen Anwendung.

## Das Unternehmen und sein Projektportfolio

Das Unternehmen und sein Projektportfolio: Millionen von Kunden; monatliche Umsätze in Milliardenhöhe.

## Tokens mit Rabatt kaufen.

Aborabatt für regelmäßige Arbeit. Aktionscodes bieten bis 50% beim Tokenkauf.

Abo

Wählen Sie einen Tarif mit Rabatt für Ihre regelmäßigen Anfragen.

Aktionscode bis 50%

Geben Sie den Code beim Kauf ein. Der Preis wird nach den gültigen Aktionsbedingungen berechnet.

Ausgaben in der Historie

Modell, Tokens und Betrag werden für jede Anfrage gespeichert.

[Abo wählen](https://ailoot.ai/docs/de/billing/subscriptions/) · [Modellpreise ansehen](https://ailoot.ai/models/de/)

## Verbinden Sie die API mit dem Produkt, das Sie verkaufen.

SaaS, Anwendungen und Bots nach dem offiziellen Angebot und Lizenzvertrag von Ailoot. Fordern Sie für den Weiterverkauf eine Reseller-Lizenz an.

Kommerzielle Anwendung

Integrieren Sie Text-, Bild-, Video- und Audioerzeugung in kostenpflichtige Funktionen Ihres Dienstes.

Reseller-Lizenz

Senden Sie Projektbeschreibung und Zugangsmodell. Fordern Sie schriftliche Nutzungs- und Weiterverkaufsbedingungen an.

Dokumente auf der Website

Offizielles Angebot, Lizenzvertrag und Datenschutzerklärung sind vor der Verbindung zugänglich.

[Reseller-Lizenz anfordern](mailto:support@ailoot.ai) · [Offizielles Angebot und Lizenzvertrag](https://ailoot.ai/legal/offer?lang=de)

## Ailoot · Das Unternehmen und sein Projektportfolio





Ailoot baut auf bewährte Betriebserfahrung, einen großen Kundenstamm, stabilen Service und kontinuierliche KPI-Kontrolle.





Das Unternehmen und sein Projektportfolio: Millionen von Kunden; monatliche Umsätze in Milliardenhöhe.





Ailoot nutzt diese Betriebserfahrung für den API-Zugang zu KI-Funktionen in Kundenprodukten, Agenten, Anwendungen und Automatisierungen.
