Source: https://ailoot.ai/models/fr/inclusionai-ling-3-1-flash/
Canonical: https://ailoot.ai/models/fr/inclusionai-ling-3-1-flash/
Language: fr

# inclusionAI: Ling 3.1 Flash

[Markdown](https://ailoot.ai/models/fr/inclusionai-ling-3-1-flash/index.md) · [JSON](https://ailoot.ai/models/fr/inclusionai-ling-3-1-flash/facts.json)

## [inclusionAI: Ling 3.1 Flash](https://ailoot.ai/models/fr/inclusionai-ling-3-1-flash/)

Ling 3.1 Flash est le modèle de raisonnement hybride d’inclusionAI pour le travail bureautique, le développement logiciel prolongé et les agents complexes. Son architecture parcimonieuse à 560 milliards de paramètres en active environ 25 milliards par token, pour la planification en plusieurs étapes, l’interaction avec les outils et les révisions à partir de résultats intermédiaires.

- [**Ailoot Ultra · Chat OpenAI** `POST /v1/chat/completions` `inclusionai/ling-3.1-flash`](https://ailoot.ai/models/fr/inclusionai-ling-3-1-flash/#method-0)
- [**Ailoot Ultra · Messages Anthropic** `POST /v1/messages` `inclusionai/ling-3.1-flash`](https://ailoot.ai/models/fr/inclusionai-ling-3-1-flash/#method-1)

À propos du modèle

Cette description présente les capacités du modèle. Les entrées, sorties et options disponibles dans Ailoot pour la méthode sélectionnée figurent ci-dessous.

Ling 3.1 Flash est le modèle de langage à raisonnement hybride d’inclusionAI pour les tâches comportant plusieurs étapes plutôt qu’une seule réponse courte. Le fabricant le destine au travail bureautique quotidien, à l’ingénierie logicielle prolongée et aux flux d’agents complexes. Il utilise une architecture à mélange d’experts avec environ 560 milliards de paramètres au total et quelque 25 milliards actifs pour chaque token, équilibrant une grande capacité de modèle avec une quantité plus faible de calcul actif.

Son objectif de conception central est de maintenir l’état de la tâche et de rectifier le déroulement des travaux longs. Dans un flux relié à des outils, le modèle peut planifier plusieurs étapes, interpréter les résultats intermédiaires et réviser l’étape suivante lorsque les éléments probants changent. Donnez-lui un objectif précis, les documents disponibles et une définition de l’achèvement. Par exemple : « Examinez ces notes d’incident, identifiez les causes non résolues et produisez un plan d’investigation par ordre de priorité. Pour chaque action, nommez les éléments nécessaires pour déterminer si elle a fonctionné. » Cela transforme une demande vague en un résultat qui peut être examiné et servir de base à la suite du travail.

Pour le travail bureautique, les entrées utiles comprennent des notes sources, du texte extrait de documents, des tableaux avec des définitions de colonnes claires et le public visé par un rapport. Précisez la période, les unités et la comparaison à utiliser. Demandez un livrable écrit, comme une note de direction, un plan de rapport ou une explication des changements importants. Exemple : « En utilisant uniquement ces tableaux trimestriels, expliquez les changements les plus importants, distinguez les valeurs observées des hypothèses et rédigez une note avec les questions sans réponse à la fin. » Gardez les libellés des sources avec l’entrée pour relier les affirmations obtenues aux bons documents.

Pour le développement logiciel, le fabricant met en avant la refactorisation entre langages, l’optimisation des performances et l’analyse des parties fréquemment utilisées d’une base de code. Fournissez les fichiers pertinents sous forme de texte, le comportement à préserver, les versions des dépendances et toute sortie défaillante ou mesure. Une demande utile sollicite une modification proposée et les vérifications nécessaires pour l’évaluer : « Refactorisez cet analyseur en préservant le format de sortie documenté. Expliquez le comportement affecté, montrez le code révisé et identifiez les cas qui révéleraient une régression. » Pour les performances, fournissez des profils ou des durées réels et demandez de relier chaque recommandation à un goulet d’étranglement mesuré.

Pour l’analyse professionnelle, rassemblez les règles, les définitions et les éléments pertinents avant de demander une recommandation. Ling 3.1 Flash est destiné à synthétiser des informations dispersées, à interpréter des indicateurs et à développer des suggestions d’action. Demandez une comparaison nommant les hypothèses et les informations encore nécessaires, plutôt qu’un verdict sans appui. Par exemple, fournissez plusieurs propositions de projets et demandez une note de décision utilisant les mêmes critères pour chacune, avec des observations étayées par les sources séparées des conséquences déduites. Lorsque les éléments se contredisent, demandez les passages contradictoires et la question qui permettrait de les départager.

Le fabricant distingue un plafond de contexte du modèle de 1M de tokens du contexte de 256K actuellement ouvert par son service officiel. Ces chiffres décrivent des limites différentes. Organisez les documents de travail selon la fenêtre applicable et réservez de la place pour la réponse ; un plafond au niveau du modèle ne signifie pas que chaque interface accepte autant d’entrée. Pour une tâche importante, gardez ensemble l’objectif, les décisions prises, les questions non résolues et les références sources. Délimitez explicitement les documents et le code pour éviter de confondre les contenus à analyser avec les instructions à suivre.

Préparez les tâches reliées à des outils avec des descriptions d’outils claires, les arguments attendus et des comptes rendus de résultats utiles. Réinjectez les résultats réels dans la conversation pour que la proposition suivante repose sur des observations. Demandez au modèle d’expliquer ce que change un résultat renvoyé et quels éléments manquent encore. La conception du modèle orientée agents permet ce schéma de planification et de retour d’information ; l’application exécute les étapes avec outils et préserve leurs résultats. Une commande, une modification de code ou un rapport proposés sont surtout utiles lorsque leur état est clair : suggérés, exécutés avec un résultat enregistré ou encore en attente de vérification.

Ling 3.1 Flash appartient à la lignée des modèles de langage ; l’édition distincte Ling 3.0 Flash VL est le modèle visuel du fabricant. Pour cette tâche textuelle, préparez des contenus sources textuels et conservez leur structure, leurs libellés et leur provenance. Précisez la langue et la forme de sortie : note concise, tableau de constats, explication de correctif ou plan numéroté. Demandez au modèle de signaler les informations manquantes et vérifiez le livrable demandé à partir des contraintes d’origine. Les flux longs exigent toujours l’examen des résultats intermédiaires : une hypothèse initiale erronée pourrait sinon être reprise dans les raisonnements ultérieurs et transformée en un rapport final convaincant.

**Ailoot Ultra · Chat OpenAI** `POST /v1/chat/completions` `inclusionai/ling-3.1-flash`

[`inclusionai/ling-3.1-flash`](https://ailoot.ai/models/fr/#m=inclusionai%2Fling-3.1-flash&route=Ultra&caller=inclusionai%2Fling-3.1-flash&fmt=chat)

inclusionAI /`inclusionai/ling-3.1-flash`

### Premiers pas

Ling 3.1 Flash est le modèle de raisonnement hybride d’inclusionAI pour le travail bureautique, le développement logiciel prolongé et les agents complexes. Son architecture parcimonieuse à 560 milliards de paramètres en active environ 25 milliards par token, pour la planification en plusieurs étapes, l’interaction avec les outils et les révisions à partir de résultats intermédiaires.

Entrées acceptées

Texte

Résultats

Texte

### Disponible dans Ailoot · entrées et méthodes

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

Types d’entrée

`text`

Types de sortie

`text`

Format de sortie

json ou SSE

| Champ | Type | Exigence | Valeurs et limites | Par défaut |
| --- | --- | --- | --- | --- |
| Champ`model` | Type`string` | ExigenceObligatoire | Valeurs et limites inclusionai/ling-3.1-flash | Par défaut— |
| Champ`messages` | Type`message[]` | ExigenceObligatoire | Valeurs et limites Nombre minimal d’éléments: 1 | Par défaut— |
| Champ`messages[].role` | Type`string` | ExigenceObligatoire | Valeurs et limites Selon le modèle | Par défaut— |
| Champ`messages[].content` | Type`string` | ExigenceFacultatif | Valeurs et limites S’applique lorsque: Conversation textuelle | Par défaut— |
| Champ`stream` | Type`boolean` | ExigenceFacultatif | Valeurs et limites | Par défautfalse |

Combinaisons d’éléments d’entrée

**Texte** · Texte UTF8

`messages[].content`

Paramètres et cycle de vie de la méthode

| Paramètre | Contrat |
| --- | --- |
| Paramètre`content_type` | Contratapplication/json |
| Paramètre`required` | Contratmodel, messages |
| Paramètre`material_types` | Contrattext |
| Paramètre`messages` | Contrattableau de messages avec une structure role/content |
| Paramètre`file_material` | Contratdocument UTF-8 réel inséré sous forme de texte littéral ; aucun identifiant de fichier déduit |
| Paramètre`optional_controls` | Contratstream |
| Paramètre`control_scope` | ContratConversation textuelle ; stream est un booléen dont la valeur par défaut est false. |
| Paramètre`output_modalities` | Contrattext |
| Paramètre`hosted_operations` | Contratfalse |
| Paramètre`multimodal_input_binding` | Contratnull |

Alias de méthode : `/chat/completions`

Cycle de vie : `synchronous_or_streamed`

Envoyez l’identifiant exact du modèle avec messages.

La longueur du contexte n’est pas un plafond de sortie.

Un fichier texte peut fournir du texte littéral ; les entrées image/audio/objets fichier nécessitent une liaison exacte.

### Tarifs

Les tarifs n’ajoutent pas d’options de requête. Les paramètres pris en charge figurent dans la méthode sélectionnée.

Mode rapide

Non précisé Lorsque le mode rapide est sélectionné

Mode Flex

Non précisé Lorsque le mode flex est sélectionné

Effort de raisonnement maximal

Non précisé Lorsque l’effort de raisonnement maximal utilise l’ajustement par défaut (default)

#### Tarifs Ailoot

#### Prix par configuration

Associez chaque coût aux conditions indiquées. Utilisez un seul tarif pour chaque ensemble de configurations alternatives.

| Configuration | Barème tarifaire | Tokens de contexte, plus de | Tokens de contexte, jusqu’à la limite incluse | Coût |
| --- | --- | --- | --- | --- |
| ConfigurationTarifs de base des tokens | Barème tarifaireTarif de base | Tokens de contexte, plus de— | Tokens de contexte, jusqu’à la limite incluseSans borne supérieure | Coût Entrée · Tokens en entrée **$0.0006** / 1K tokens Sortie · Tokens en sortie **$0.0018** / 1K tokens Entrée · Lecture du cache **$0.00012** / 1K tokens Entrée · Écriture dans le cache **—** / 1K tokens Entrée · Écriture dans le cache, 1 h **—** / 1K tokens |
| ConfigurationPalier 1 de longueur de requête | Barème tarifaire— | Tokens de contexte, plus de0 | Tokens de contexte, jusqu’à la limite incluseSans borne supérieure | Coût Entrée · Tokens en entrée **$0.0006** / 1K tokens Sortie · Tokens en sortie **$0.0018** / 1K tokens Entrée · Lecture du cache **$0.00012** / 1K tokens Entrée · Écriture dans le cache **—** / 1K tokens Entrée · Écriture dans le cache, 1 h **—** / 1K tokens |

Ailoot réserve un montant estimé avant une requête. Après le résultat, le montant final est débité selon l’utilisation mesurée. Pour le streaming, le montant final à débiter est calculé à partir du relevé final d’utilisation. [Fonctionnement de la réservation et du débit →](https://ailoot.ai/docs/fr/billing/reserve/)

### Exemples de requêtes

#### Ailoot Ultra · Chat OpenAI

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":"inclusionai/ling-3.1-flash","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="inclusionai/ling-3.1-flash", 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"))
```

### Recevoir et enregistrer les résultats

#### Ailoot Ultra · Chat OpenAI

json ou SSE

##### Conserver tous les résultats terminés

Conservez chaque réponse, fichier et partie de contenu renvoyés dans leur intégralité.

Conservez chaque choix avec son contenu, ses appels d’outils et son raisonnement. En SSE, assemblez les deltas par index de choix et d’outil, puis conservez le motif final de terminaison et les données d’utilisation.

##### Si la réponse d’origine doit être vérifiée

Conservez les identifiants de requête et de réponse ainsi que les en-têtes. Aucune URL générique de récupération des tâches textuelles n’est fournie.

Champs de la réponse

| Champ | Type |
| --- | --- |
| Champ`choices[].index` | Typeinteger |
| Champ`choices[].message.content` | Typestring\|null |
| Champ`choices[].message.tool_calls` | Typetool\_call\[\] |
| Champ`choices[].message.reasoning_content` | Typestring |
| Champ`choices[].message.reasoning_details` | Typeobject\|array |
| Champ`choices[].finish_reason` | Typestring\|null |
| Champ`usage` | Typeobject |

Erreurs et étapes suivantes

| Réponse | Condition | Étape suivante |
| --- | --- | --- |
| Réponse400 · `invalid_request_error` | ConditionChamps obligatoires, représentation des contenus ou valeur de paramètre non valides | Étape suivanteCorrigez les champs indiqués avant une nouvelle requête de création. |

### Alias

#### Alias du modèle

**Ailoot Ultra** [`inclusionai/ling-3.1-flash`](https://ailoot.ai/models/fr/#m=inclusionai%2Fling-3.1-flash&route=Ultra&caller=inclusionai%2Fling-3.1-flash&fmt=chat)

#### Alias des chemins de méthode

`/chat/completions`

#### ID d’appel associés

[`inclusionai/ling-3.1-flash`](https://ailoot.ai/models/fr/#m=inclusionai%2Fling-3.1-flash&route=Ultra&caller=inclusionai%2Fling-3.1-flash&fmt=chat)

**Ailoot Ultra · Messages Anthropic** `POST /v1/messages` `inclusionai/ling-3.1-flash`

[`inclusionai/ling-3.1-flash`](https://ailoot.ai/models/fr/#m=inclusionai%2Fling-3.1-flash&route=Ultra&caller=inclusionai%2Fling-3.1-flash&fmt=messages)

inclusionAI /`inclusionai/ling-3.1-flash`

### Premiers pas

Ling 3.1 Flash est le modèle de raisonnement hybride d’inclusionAI pour le travail bureautique, le développement logiciel prolongé et les agents complexes. Son architecture parcimonieuse à 560 milliards de paramètres en active environ 25 milliards par token, pour la planification en plusieurs étapes, l’interaction avec les outils et les révisions à partir de résultats intermédiaires.

Entrées acceptées

Texte

Résultats

json · sse

### Disponible dans Ailoot · entrées et méthodes

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

Types d’entrée

`text`

Types de sortie

`json`, `sse`

Format de sortie

JSON ou SSE

| Champ | Type | Exigence | Valeurs et limites | Par défaut |
| --- | --- | --- | --- | --- |
| Champ`model` | Type`string` | ExigenceObligatoire | Valeurs et limites inclusionai/ling-3.1-flash | Par défaut— |
| Champ`messages` | Type`message[]` | ExigenceObligatoire | Valeurs et limites | Par défaut— |
| Champ`messages[].role` | Type`string` | ExigenceObligatoire | Valeurs et limites user, assistant | Par défaut— |
| Champ`messages[].content` | Type`string` | ExigenceObligatoire | Valeurs et limites | Par défaut— |
| Champ`max_tokens` | Type`integer` | ExigenceObligatoire | Valeurs et limites | Par défaut— |
| Champ`stream` | Type`boolean` | ExigenceFacultatif | Valeurs et limites | Par défautfalse |

Combinaisons d’éléments d’entrée

**Texte** · Texte UTF-8

`chaîne messages[].content`

Paramètres et cycle de vie de la méthode

| Paramètre | Contrat |
| --- | --- |
| Paramètre`content_type` | Contratapplication/json |
| Paramètre`required` | Contratmodel, messages, max\_tokens |
| Paramètre`optional_controls` | Contratstream |
| Paramètre`material_types` | Contrattext |
| Paramètre`text_file_material` | ContratLisez le document UTF-8 réel et placez son texte dans l’entrée indiquée ou dans la chaîne de contenu du message. |

Cycle de vie : `synchronous_or_streamed`

### Tarifs

Les tarifs n’ajoutent pas d’options de requête. Les paramètres pris en charge figurent dans la méthode sélectionnée.

Mode rapide

Non précisé Lorsque le mode rapide est sélectionné

Mode Flex

Non précisé Lorsque le mode flex est sélectionné

Effort de raisonnement maximal

Non précisé Lorsque l’effort de raisonnement maximal utilise l’ajustement par défaut (default)

#### Tarifs Ailoot

#### Prix par configuration

Associez chaque coût aux conditions indiquées. Utilisez un seul tarif pour chaque ensemble de configurations alternatives.

| Configuration | Barème tarifaire | Tokens de contexte, plus de | Tokens de contexte, jusqu’à la limite incluse | Coût |
| --- | --- | --- | --- | --- |
| ConfigurationTarifs de base des tokens | Barème tarifaireTarif de base | Tokens de contexte, plus de— | Tokens de contexte, jusqu’à la limite incluseSans borne supérieure | Coût Entrée · Tokens en entrée **$0.0006** / 1K tokens Sortie · Tokens en sortie **$0.0018** / 1K tokens Entrée · Lecture du cache **$0.00012** / 1K tokens Entrée · Écriture dans le cache **—** / 1K tokens Entrée · Écriture dans le cache, 1 h **—** / 1K tokens |
| ConfigurationPalier 1 de longueur de requête | Barème tarifaire— | Tokens de contexte, plus de0 | Tokens de contexte, jusqu’à la limite incluseSans borne supérieure | Coût Entrée · Tokens en entrée **$0.0006** / 1K tokens Sortie · Tokens en sortie **$0.0018** / 1K tokens Entrée · Lecture du cache **$0.00012** / 1K tokens Entrée · Écriture dans le cache **—** / 1K tokens Entrée · Écriture dans le cache, 1 h **—** / 1K tokens |

Ailoot réserve un montant estimé avant une requête. Après le résultat, le montant final est débité selon l’utilisation mesurée. Pour le streaming, le montant final à débiter est calculé à partir du relevé final d’utilisation. [Fonctionnement de la réservation et du débit →](https://ailoot.ai/docs/fr/billing/reserve/)

### Exemples de requêtes

#### Ailoot Ultra · Messages Anthropic

Corps JSON minimal completcurl · utilisez votre document UTF-8Python · enregistrez le résultat complet

```json
{
  "model": "inclusionai/ling-3.1-flash",
  "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': 'inclusionai/ling-3.1-flash', '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': 'inclusionai/ling-3.1-flash', '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))
```

### Recevoir et enregistrer les résultats

#### Ailoot Ultra · Messages Anthropic

JSON ou SSE

##### Conserver tous les résultats terminés

Conservez chaque réponse, fichier et partie de contenu renvoyés dans leur intégralité.

Conservez tous les blocs de contenu, les signatures de raisonnement et les identifiants réels d’utilisation d’outils. Assemblez tous les deltas de blocs SSE ; un premier bloc de texte ne constitue pas la sortie complète.

##### Si la réponse d’origine doit être vérifiée

Conservez les identifiants de requête et de réponse ainsi que les en-têtes. Aucune URL générique de récupération des tâches textuelles n’est fournie.

Champs de la réponse

| Champ | Type |
| --- | --- |
| Champ`id` | Typestring |
| Champ`model` | Typestring |
| Champ`content[]` | Typetext\|thinking\|tool\_use\|other content block |
| Champ`stop_reason` | Typestring\|null |
| Champ`usage` | Typeobject |

Erreurs et étapes suivantes

| Réponse | Condition | Étape suivante |
| --- | --- | --- |
| Réponse400 · `invalid_request_error` | ConditionChamps obligatoires, représentation des contenus ou valeur de paramètre non valides | Étape suivanteCorrigez les champs indiqués avant une nouvelle requête de création. |

### Alias

#### Alias du modèle

**Ailoot Ultra** [`inclusionai/ling-3.1-flash`](https://ailoot.ai/models/fr/#m=inclusionai%2Fling-3.1-flash&route=Ultra&caller=inclusionai%2Fling-3.1-flash&fmt=messages)

#### Alias des chemins de méthode

`/chat/completions`

#### ID d’appel associés

[`inclusionai/ling-3.1-flash`](https://ailoot.ai/models/fr/#m=inclusionai%2Fling-3.1-flash&route=Ultra&caller=inclusionai%2Fling-3.1-flash&fmt=messages)

FAQ · inclusionAI: Ling 3.1 Flash

Quelles entrées et quels résultats sont disponibles ?

`POST /v1/chat/completions` · `inclusionai/ling-3.1-flash`: `text` → `text` `POST /v1/messages` · `inclusionai/ling-3.1-flash`: `text` → `json`, `sse`

Quels champs la requête utilise-t-elle ?

`POST /v1/chat/completions` · `inclusionai/ling-3.1-flash`: `model`, `messages`, `stream` `POST /v1/messages` · `inclusionai/ling-3.1-flash`: `model`, `messages`, `max_tokens`, `stream`

Quelles limites s’appliquent ?

`POST /v1/chat/completions` · `inclusionai/ling-3.1-flash`: `messages.min_items`: `1`

Connectez Ailoot à Claude Code, OpenCode, Hermes ou à votre application.

## L’entreprise et son portefeuille de projets

L’entreprise et son portefeuille de projets : des millions de clients ; des ventes qui se chiffrent en milliards chaque mois.

## Achetez des tokens à prix réduit.

Une remise d’abonnement pour le travail régulier. Des codes promo jusqu’à 50% sur l’achat de tokens.

Abonnement

Choisissez une offre à tarif réduit pour vos requêtes régulières.

Code promo jusqu’à 50%

Saisissez le code à l’achat. Le prix est recalculé selon la promotion en cours.

Dépenses dans l’historique

Modèle, tokens et montant sont enregistrés pour chaque requête.

[Choisir un abonnement](https://ailoot.ai/docs/fr/billing/subscriptions/) · [Voir les prix des modèles](https://ailoot.ai/models/fr/)

## Connectez l’API au produit que vous vendez.

SaaS, applications et bots selon l’offre officielle et le contrat de licence Ailoot. Pour la revente, demandez une licence revendeur.

Application commerciale

Intégrez la génération de texte, d’images, de vidéo et de son aux fonctions payantes de votre service.

Licence revendeur

Envoyez la description du projet et le mode d’accès. Demandez des conditions écrites d’utilisation et de revente.

Documents sur le site

L’offre officielle, le contrat de licence et la politique de traitement des données sont accessibles avant connexion.

[Demander une licence revendeur](mailto:support@ailoot.ai) · [Offre officielle et contrat de licence](https://ailoot.ai/legal/offer?lang=fr)

## Ailoot · L’entreprise et son portefeuille de projets





Ailoot s’appuie sur une expérience opérationnelle éprouvée, une large clientèle, un service stable et un suivi continu des KPI.





L’entreprise et son portefeuille de projets : des millions de clients ; des ventes qui se chiffrent en milliards chaque mois.





Ailoot met cette expérience opérationnelle au service de l’accès API aux fonctions d’IA dans les produits des clients, leurs agents, applications et automatisations.