Qwen3-32B-FP8 est le checkpoint officiel FP8 du modèle dense Qwen3-32B. Le fabricant décrit les mathématiques, le raisonnement logique, la génération de code, l’écriture créative, le dialogue par rôle et le suivi des instructions sur plusieurs tours. La famille couvre plus de 100 langues et dialectes. Entrée et sortie sont textuelles ; cette version propose des réponses en mode Thinking et des réponses directes en mode Non-Thinking.
Le modèle comporte 32,8 milliards de paramètres, dont 31,2 hors embeddings, et 64 couches. L’attention à requêtes groupées utilise 64 têtes de requête et huit de clé/valeur. C’est une architecture dense, distincte des mélanges d’experts avec paramètres totaux et actifs. FP8 appartient à l’identité exacte. Pour développer, donnez fonction, spécification et entrées puis demandez explication et révision préservant l’interface. Pour éditer, fournissez source, lecteur et terminologie plutôt qu’un contexte indéfini.
Le démarrage rapide emploie le gabarit désigné. Séparez tâche et sources et précisez la forme finale. Une analyse peut comparer deux validations avec mêmes règles de champs, cas acceptés et fonction proposée. Incluez les règles relatives aux valeurs manquantes, des données représentatives et les messages d’erreur requis. Pour un contenu multilingue, fournissez un glossaire et demandez une traduction accompagnée d’une liste de termes à revoir. Cela rend le résultat vérifiable sur une entrée précise. L’intégration attend Qwen3 ; Transformers avant 4.51.0 ne reconnaît pas l’architecture selon la fiche.
La note FP8 décrit une quantification à granularité fine avec des blocs de taille 128, et la configuration identifie le paramétrage de quantification FP8. Le fabricant cite Transformers, SGLang et vLLM mais signale un problème lié au FP8 à granularité fine en inférence distribuée avec Transformers ; plusieurs appareils peuvent nécessiter CUDA_LAUNCH_BLOCKING=1. Séparez compatibilité et texte. L’identité quantifiée seule ne prouve ni latence, ni économie matérielle, ni équivalence de réponse au checkpoint original.
Le gabarit active le mode Thinking par défaut. Une désactivation ferme supprime sa section. Sinon /think et /no_think contrôlent souplement chaque tour avec priorité à la dernière instruction, sans annuler un arrêt ferme. Demandez le raisonnement pour des contradictions puis une réponse directe concise du résultat accepté. Gardez la réponse finale distincte et utilisez-la, non le raisonnement précédent, en historique. Même une demande souple de mode Non-Thinking conserve un bloc Thinking potentiellement vide si le mode Thinking reste activé ; le réglage ferme le retire.
La fiche recommande Qwen-Agent pour le formatage et l’analyse syntaxique des appels d’outils. L’application définit, vérifie et exécute les appels puis renvoie les résultats. Un exécuteur contrôlé peut tester le code sur les cas fournis. Demandez le résumé des réussites et échecs réels et la révision d’une condition fautive nommée. Un appel proposé ne vaut pas preuve d’exécution. Définissez périmètre et champs avant le processus. Qwen3 décrit aussi appels parallèles et en plusieurs étapes avec arguments objets et résultats dans la conversation.
La fiche exacte indique 32 768 tokens natifs et 131 072 avec YaRN. L’extension dépend des réglages ; l’échelle statique peut affecter les textes courts. Entrée et sortie partagent la séquence. Étiquetez les sources et réservez assez de place pour code et explication. Exemples et longueurs recommandées ne fixent pas un plafond universel. Pour générer long, vérifiez cohérence et exigences. L’explication des longueurs d’entraînement Qwen3 mentionne 38 912 tokens assistant en mode Thinking et 16 384 en mode Non-Thinking, et conseille la vérification qualitative des longues générations. Ces chiffres diffèrent du contexte et ne sont pas un plafond ferme d’endpoint. La fiche explique 40 960 positions par défaut comme 8 192 pour prompts typiques et 32 768 pour sortie, conseil distinct du contexte d’entraînement natif et des limites d’endpoint.
Les réglages conseillés sont temperature 0,6, top-p 0,95, top-k 20 et min-p 0 en mode Thinking, et 0,7, 0,8, 20 et 0 en mode de réponse directe (Non-Thinking). Le fabricant déconseille le raisonnement glouton pour répétition ; de fortes pénalités de présence peuvent mélanger les langues. Exigez un résultat inspectable comme tableau de décision, fonction achevée et cas. Vérifiez champs structurés, calculs et code dans l’environnement prévu en conservant l’identité FP8 dans les résultats.
", "aboutText": "Qwen3-32B-FP8 est le checkpoint officiel FP8 du modèle dense Qwen3-32B. Le fabricant décrit les mathématiques, le raisonnement logique, la génération de code, l’écriture créative, le dialogue par rôle et le suivi des instructions sur plusieurs tours. La famille couvre plus de 100 langues et dialectes. Entrée et sortie sont textuelles ; cette version propose des réponses en mode Thinking et des réponses directes en mode Non-Thinking.\n\nLe modèle comporte 32,8 milliards de paramètres, dont 31,2 hors embeddings, et 64 couches. L’attention à requêtes groupées utilise 64 têtes de requête et huit de clé/valeur. C’est une architecture dense, distincte des mélanges d’experts avec paramètres totaux et actifs. FP8 appartient à l’identité exacte. Pour développer, donnez fonction, spécification et entrées puis demandez explication et révision préservant l’interface. Pour éditer, fournissez source, lecteur et terminologie plutôt qu’un contexte indéfini.\n\nLe démarrage rapide emploie le gabarit désigné. Séparez tâche et sources et précisez la forme finale. Une analyse peut comparer deux validations avec mêmes règles de champs, cas acceptés et fonction proposée. Incluez les règles relatives aux valeurs manquantes, des données représentatives et les messages d’erreur requis. Pour un contenu multilingue, fournissez un glossaire et demandez une traduction accompagnée d’une liste de termes à revoir. Cela rend le résultat vérifiable sur une entrée précise. L’intégration attend Qwen3 ; Transformers avant 4.51.0 ne reconnaît pas l’architecture selon la fiche.\n\nLa note FP8 décrit une quantification à granularité fine avec des blocs de taille 128, et la configuration identifie le paramétrage de quantification FP8. Le fabricant cite Transformers, SGLang et vLLM mais signale un problème lié au FP8 à granularité fine en inférence distribuée avec Transformers ; plusieurs appareils peuvent nécessiter CUDA_LAUNCH_BLOCKING=1. Séparez compatibilité et texte. L’identité quantifiée seule ne prouve ni latence, ni économie matérielle, ni équivalence de réponse au checkpoint original.\n\nLe gabarit active le mode Thinking par défaut. Une désactivation ferme supprime sa section. Sinon /think et /no_think contrôlent souplement chaque tour avec priorité à la dernière instruction, sans annuler un arrêt ferme. Demandez le raisonnement pour des contradictions puis une réponse directe concise du résultat accepté. Gardez la réponse finale distincte et utilisez-la, non le raisonnement précédent, en historique. Même une demande souple de mode Non-Thinking conserve un bloc Thinking potentiellement vide si le mode Thinking reste activé ; le réglage ferme le retire.\n\nLa fiche recommande Qwen-Agent pour le formatage et l’analyse syntaxique des appels d’outils. L’application définit, vérifie et exécute les appels puis renvoie les résultats. Un exécuteur contrôlé peut tester le code sur les cas fournis. Demandez le résumé des réussites et échecs réels et la révision d’une condition fautive nommée. Un appel proposé ne vaut pas preuve d’exécution. Définissez périmètre et champs avant le processus. Qwen3 décrit aussi appels parallèles et en plusieurs étapes avec arguments objets et résultats dans la conversation.\n\nLa fiche exacte indique 32 768 tokens natifs et 131 072 avec YaRN. L’extension dépend des réglages ; l’échelle statique peut affecter les textes courts. Entrée et sortie partagent la séquence. Étiquetez les sources et réservez assez de place pour code et explication. Exemples et longueurs recommandées ne fixent pas un plafond universel. Pour générer long, vérifiez cohérence et exigences. L’explication des longueurs d’entraînement Qwen3 mentionne 38 912 tokens assistant en mode Thinking et 16 384 en mode Non-Thinking, et conseille la vérification qualitative des longues générations. Ces chiffres diffèrent du contexte et ne sont pas un plafond ferme d’endpoint. La fiche explique 40 960 positions par défaut comme 8 192 pour prompts typiques et 32 768 pour sortie, conseil distinct du contexte d’entraînement natif et des limites d’endpoint.\n\nLes réglages conseillés sont temperature 0,6, top-p 0,95, top-k 20 et min-p 0 en mode Thinking, et 0,7, 0,8, 20 et 0 en mode de réponse directe (Non-Thinking). Le fabricant déconseille le raisonnement glouton pour répétition ; de fortes pénalités de présence peuvent mélanger les langues. Exigez un résultat inspectable comme tableau de décision, fonction achevée et cas. Vérifiez champs structurés, calculs et code dans l’environnement prévu en conservant l’identité FP8 dans les résultats.", "editorialOverlay": { "copy_fields": { "practical_html": "Exemple technique en anglais
Compare missing-value validators\n\nCompare two Python validators for an optional quantity: A uses if not value: return None; B uses if value is None: return None. Requirement: None means omitted, integer zero is valid, and negative quantities are invalid. Explain each validator's behavior for None, 0 and -1, then propose a complete function with explicit validation errors.A three-input comparison table and a proposed function implementing the supplied rules.Check zero is preserved rather than treated as missing, and negatives are rejected explicitly.qwen/qwen3-32b-fp8Qwen3-32B-FP8 est l’édition FP8 à granularité fine du modèle textuel dense Qwen3 de 32,8 milliards de paramètres. Elle associe réponses directes et réponses en mode Thinking pour rédaction multilingue, code et analyse, avec identité de checkpoint et compatibilité propres.
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.
Qwen3-32B-FP8 est le checkpoint officiel FP8 du modèle dense Qwen3-32B. Le fabricant décrit les mathématiques, le raisonnement logique, la génération de code, l’écriture créative, le dialogue par rôle et le suivi des instructions sur plusieurs tours. La famille couvre plus de 100 langues et dialectes. Entrée et sortie sont textuelles ; cette version propose des réponses en mode Thinking et des réponses directes en mode Non-Thinking.
Le modèle comporte 32,8 milliards de paramètres, dont 31,2 hors embeddings, et 64 couches. L’attention à requêtes groupées utilise 64 têtes de requête et huit de clé/valeur. C’est une architecture dense, distincte des mélanges d’experts avec paramètres totaux et actifs. FP8 appartient à l’identité exacte. Pour développer, donnez fonction, spécification et entrées puis demandez explication et révision préservant l’interface. Pour éditer, fournissez source, lecteur et terminologie plutôt qu’un contexte indéfini.
Le démarrage rapide emploie le gabarit désigné. Séparez tâche et sources et précisez la forme finale. Une analyse peut comparer deux validations avec mêmes règles de champs, cas acceptés et fonction proposée. Incluez les règles relatives aux valeurs manquantes, des données représentatives et les messages d’erreur requis. Pour un contenu multilingue, fournissez un glossaire et demandez une traduction accompagnée d’une liste de termes à revoir. Cela rend le résultat vérifiable sur une entrée précise. L’intégration attend Qwen3 ; Transformers avant 4.51.0 ne reconnaît pas l’architecture selon la fiche.
La note FP8 décrit une quantification à granularité fine avec des blocs de taille 128, et la configuration identifie le paramétrage de quantification FP8. Le fabricant cite Transformers, SGLang et vLLM mais signale un problème lié au FP8 à granularité fine en inférence distribuée avec Transformers ; plusieurs appareils peuvent nécessiter CUDA_LAUNCH_BLOCKING=1. Séparez compatibilité et texte. L’identité quantifiée seule ne prouve ni latence, ni économie matérielle, ni équivalence de réponse au checkpoint original.
Le gabarit active le mode Thinking par défaut. Une désactivation ferme supprime sa section. Sinon /think et /no_think contrôlent souplement chaque tour avec priorité à la dernière instruction, sans annuler un arrêt ferme. Demandez le raisonnement pour des contradictions puis une réponse directe concise du résultat accepté. Gardez la réponse finale distincte et utilisez-la, non le raisonnement précédent, en historique. Même une demande souple de mode Non-Thinking conserve un bloc Thinking potentiellement vide si le mode Thinking reste activé ; le réglage ferme le retire.
La fiche recommande Qwen-Agent pour le formatage et l’analyse syntaxique des appels d’outils. L’application définit, vérifie et exécute les appels puis renvoie les résultats. Un exécuteur contrôlé peut tester le code sur les cas fournis. Demandez le résumé des réussites et échecs réels et la révision d’une condition fautive nommée. Un appel proposé ne vaut pas preuve d’exécution. Définissez périmètre et champs avant le processus. Qwen3 décrit aussi appels parallèles et en plusieurs étapes avec arguments objets et résultats dans la conversation.
La fiche exacte indique 32 768 tokens natifs et 131 072 avec YaRN. L’extension dépend des réglages ; l’échelle statique peut affecter les textes courts. Entrée et sortie partagent la séquence. Étiquetez les sources et réservez assez de place pour code et explication. Exemples et longueurs recommandées ne fixent pas un plafond universel. Pour générer long, vérifiez cohérence et exigences. L’explication des longueurs d’entraînement Qwen3 mentionne 38 912 tokens assistant en mode Thinking et 16 384 en mode Non-Thinking, et conseille la vérification qualitative des longues générations. Ces chiffres diffèrent du contexte et ne sont pas un plafond ferme d’endpoint. La fiche explique 40 960 positions par défaut comme 8 192 pour prompts typiques et 32 768 pour sortie, conseil distinct du contexte d’entraînement natif et des limites d’endpoint.
Les réglages conseillés sont temperature 0,6, top-p 0,95, top-k 20 et min-p 0 en mode Thinking, et 0,7, 0,8, 20 et 0 en mode de réponse directe (Non-Thinking). Le fabricant déconseille le raisonnement glouton pour répétition ; de fortes pénalités de présence peuvent mélanger les langues. Exigez un résultat inspectable comme tableau de décision, fonction achevée et cas. Vérifiez champs structurés, calculs et code dans l’environnement prévu en conservant l’identité FP8 dans les résultats.
POST /v1/chat/completionstexttext| Champ | Type | Exigence | Valeurs et limites | Par défaut |
|---|---|---|---|---|
Champmodel | Typestring | ExigenceObligatoire | Valeurs et limites qwen/qwen3-32b-fp8 | Par défaut— |
Champmessages | Typemessage[] | ExigenceObligatoire | Valeurs et limites Nombre minimal d’éléments: 1 | Par défaut— |
Champmessages[].role | Typestring | ExigenceObligatoire | Valeurs et limites Exemples : system, user, assistant, tool, function Conditions: Ces rôles sont explicitement représentés par les types de compatibilité du code source ; l’ensemble exact des rôles reste propre à chaque modèle. Selon le modèle | Par défaut— |
Champmessages[].content | Typestring|content_part[]|null | ExigenceFacultatif | Valeurs et limites | Par défaut— |
Champmessages[].tool_calls | Typetool_call[] | ExigenceFacultatif | Valeurs et limites | Par défaut— |
Champmessages[].tool_call_id | Typestring | ExigenceFacultatif | Valeurs et limites S’applique lorsque: role=tool ; utilisez l’identifiant réellement renvoyé | Par défaut— |
Champmessages[].name | Typestring | ExigenceFacultatif | Valeurs et limites | Par défaut— |
Champmessages[].reasoning_content | Typestring | ExigenceFacultatif | Valeurs et limites S’applique lorsque: Réinjectez le raisonnement réellement renvoyé lorsque ce modèle l’utilise | Par défaut— |
Champmessages[].reasoning_details | Typeobject|array | ExigenceFacultatif | Valeurs et limites Selon le modèle | Par défaut— |
Champmax_tokens | Typeinteger | ExigenceFacultatif | Valeurs et limites Minimum: 1 Selon le modèle | Par défaut— |
Champmax_completion_tokens | Typeinteger | ExigenceFacultatif | Valeurs et limites Minimum: 1 Selon le modèle | Par défaut— |
Champstream | Typeboolean | ExigenceFacultatif | Valeurs et limites | Par défautfalse |
Champstream_options.include_usage | Typeboolean | ExigenceFacultatif | Valeurs et limites Selon le modèle | Par défaut— |
Champtemperature | Typenumber | ExigenceFacultatif | Valeurs et limites Selon le modèle | Par défaut— |
Champtop_p | Typenumber | ExigenceFacultatif | Valeurs et limites Selon le modèle | Par défaut— |
Champstop | Typestring|string[] | ExigenceFacultatif | Valeurs et limites Selon le modèle | Par défaut— |
Champtools | Typefunction_tool[] | ExigenceFacultatif | Valeurs et limites Selon le modèle | Par défaut— |
Champtools[].type | Typestring | ExigenceFacultatif | Valeurs et limites function Selon le modèle | Par défaut— |
Champtools[].function.name | Typestring | ExigenceObligatoire | Valeurs et limites S’applique lorsque: outil de fonction fourni | Par défaut— |
Champtools[].function.description | Typestring | ExigenceFacultatif | Valeurs et limites | Par défaut— |
Champtools[].function.parameters | TypeJSON_schema | ExigenceFacultatif | Valeurs et limites | Par défaut— |
Champtool_choice | Typestring|object | ExigenceFacultatif | Valeurs et limites Selon le modèle | Par défaut— |
Champparallel_tool_calls | Typeboolean | ExigenceFacultatif | Valeurs et limites Selon le modèle | Par défaut— |
Champresponse_format | Typeobject | ExigenceFacultatif | Valeurs et limites Selon le modèle | Par défaut— |
Champreasoning_effort | Typestring | ExigenceFacultatif | Valeurs et limites Selon le modèle | Par défaut— |
Champreasoning | Typeobject | ExigenceFacultatif | Valeurs et limites Selon le modèle | Par défaut— |
Champservice_tier | Typestring | ExigenceFacultatif | Valeurs et limites Selon le modèle | Par défaut— |
Champinstructions | Typestring | ExigenceFacultatif | Valeurs et limites Champ de compatibilité | Par défaut— |
Champfunctions | Typefunction[] | ExigenceFacultatif | Valeurs et limites Selon le modèle | Par défaut— |
Champfunction_call | Typestring|object | ExigenceFacultatif | Valeurs et limites Selon le modèle | Par défaut— |
Champprompt_cache_options | Typeobject | ExigenceFacultatif | Valeurs et limites Selon le modèle | Par défaut— |
Champmodalities | Typestring[] | ExigenceFacultatif | Valeurs et limites text | Par défaut— |
Champprovider | Typeobject | ExigenceFacultatif | Valeurs et limites Conditions: provider.options est rejeté sur cette route textuelle Ultra | Par défaut— |
Champcache_control.ttl | Typestring | ExigenceFacultatif | Valeurs et limites Conditions: 1h est rejeté dans les emplacements réels du cache de prompt | Par défaut— |
Texte · Texte UTF8
messages[].content
| Paramètre | Contrat |
|---|---|
Paramètrecontent_type | Contratapplication/json |
Paramètrerequired | Contratmodel, messages |
Paramètrematerial_types | Contrattext |
Paramètremessages | Contrattableau de messages avec une structure role/content |
Paramètrefile_material | Contratdocument UTF-8 réel inséré sous forme de texte littéral ; aucun identifiant de fichier déduit |
Paramètreoptional_controls | Contratstream, temperature, top_p, stop, max_tokens, max_completion_tokens, reasoning, response_format, tools, tool_choice |
Paramètrecontrol_scope | Contratpropre au modèle ; les outils de fonctions de l’utilisateur diffèrent des outils hébergés |
Paramètreoutput_modalities | Contrattext |
Paramètrehosted_operations | Contratfalse |
Paramètremultimodal_input_binding | Contratnull |
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.
Les tarifs n’ajoutent pas d’options de requête. Les paramètres pris en charge figurent dans la méthode sélectionnée.
| Configuration | Barème tarifaire | Coût |
|---|---|---|
| ConfigurationTarifs de base des tokens | Barème tarifaireTarif de base | Coût Entrée · Tokens en entrée $0.0002 / 1K tokens Sortie · Tokens en sortie $0.001 / 1K tokens Entrée · Lecture du cache $0 / 1K tokens Entrée · Écriture dans le cache $0 / 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 →
set -eu\n: "${AILOOT_API_KEY:?Set your Ailoot API key}"\npython3 - <<'PY_REQUEST'\nimport json,os\nfrom pathlib import Path\np=json.loads('{"model": "qwen/qwen3-32b-fp8", "messages": [{"role": "user", "content": "Explain the difference between an observation and a hypothesis in three sentences."}]}')\n\nPath("request.json").write_text(json.dumps(p,ensure_ascii=False))\nPY_REQUEST\ncurl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/chat/completions \\\n -H "Authorization: Bearer $AILOOT_API_KEY" -H 'Content-Type: application/json' \\\n --data-binary @request.json -D response-headers.txt -o result.json\npython3 - <<'PY_RESULT'\nimport json\nfrom pathlib import Path\nr=json.loads(Path("result.json").read_text())\nfor x in r.get("choices",[]):\n if x.get("message",{}).get("content"): print(x["message"]["content"])\nPY_RESULT\nfrom openai import OpenAI\nimport os\n\nif not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")\nclient=OpenAI(base_url="https://api.ailoot.ai/v1",api_key=os.environ["AILOOT_API_KEY"],max_retries=0)\nresult=client.chat.completions.create(model='qwen/qwen3-32b-fp8',messages=[{"role":"user","content":"Explain observations and hypotheses in three sentences."}])\nimport base64, json\nfrom pathlib import Path\n\ndef save_result(data, stem="result"):\n # Keep every field, including usage, IDs, reasoning and tool requests.\n Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")\n print(json.dumps(data, ensure_ascii=False, indent=2))\n def save_blob(encoded, suffix, label):\n raw = base64.b64decode(encoded, altchars=b"-_", validate=True)\n 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\n file = Path(stem + "-" + label + "." + ext)\n file.write_bytes(raw)\n print("Saved", file)\n for index, block in enumerate(data.get("content") or []):\n print("Content", index, json.dumps(block, ensure_ascii=False))\n for choice in data.get("choices") or []:\n print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))\n for index, item in enumerate(data.get("output") or []):\n print("Output", index, json.dumps(item, ensure_ascii=False))\n if item.get("type") == "image_generation_call" and item.get("result"):\n save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))\n for ci, candidate in enumerate(data.get("candidates") or []):\n for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):\n print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))\n blob = part.get("inlineData") or part.get("inline_data")\n if blob and blob.get("data"):\n mime = blob.get("mimeType") or blob.get("mime_type")\n suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")\n save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))\n\nsave_result(result.to_dict(mode="json"))\nfrom openai import OpenAI\nimport os\nfrom pathlib import Path\n\nif not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")\nclient=OpenAI(base_url="https://api.ailoot.ai/v1",api_key=os.environ["AILOOT_API_KEY"],max_retries=0)\nimport base64, json\nfrom pathlib import Path\n\ndef save_result(data, stem="result"):\n # Keep every field, including usage, IDs, reasoning and tool requests.\n Path(stem + ".json").write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")\n print(json.dumps(data, ensure_ascii=False, indent=2))\n def save_blob(encoded, suffix, label):\n raw = base64.b64decode(encoded, altchars=b"-_", validate=True)\n 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\n file = Path(stem + "-" + label + "." + ext)\n file.write_bytes(raw)\n print("Saved", file)\n for index, block in enumerate(data.get("content") or []):\n print("Content", index, json.dumps(block, ensure_ascii=False))\n for choice in data.get("choices") or []:\n print("Choice", choice.get("index"), json.dumps(choice.get("message", choice.get("delta", {})), ensure_ascii=False))\n for index, item in enumerate(data.get("output") or []):\n print("Output", index, json.dumps(item, ensure_ascii=False))\n if item.get("type") == "image_generation_call" and item.get("result"):\n save_blob(item["result"], item.get("output_format") or "bin", "output-" + str(index))\n for ci, candidate in enumerate(data.get("candidates") or []):\n for pi, part in enumerate((candidate.get("content") or {}).get("parts") or []):\n print("Candidate/part", ci, pi, json.dumps(part, ensure_ascii=False))\n blob = part.get("inlineData") or part.get("inline_data")\n if blob and blob.get("data"):\n mime = blob.get("mimeType") or blob.get("mime_type")\n suffix = {"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"}.get(mime, "bin")\n save_blob(blob["data"], suffix, "candidate-" + str(ci) + "-part-" + str(pi))\n\nwith client.chat.completions.stream(model='qwen/qwen3-32b-fp8',messages=[{"role":"user","content":"Explain observations and hypotheses in three sentences."}]) as stream:\n with Path("stream-events.jsonl").open("w",encoding="utf-8") as log:\n for event in stream:\n payload=event.to_dict(mode="json")\n log.write(json.dumps(payload,ensure_ascii=False)+"\\n"); log.flush()\n print(json.dumps(payload,ensure_ascii=False))\n final=stream.get_final_completion()\n save_result(final.to_dict(mode="json"),"stream-result")\njson ou SSE
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.
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.
| Champ | Type |
|---|---|
Champchoices[].index | Typeinteger |
Champchoices[].message.content | Typestring|null |
Champchoices[].message.tool_calls | Typetool_call[] |
Champchoices[].message.reasoning_content | Typestring |
Champchoices[].message.reasoning_details | Typeobject|array |
Champchoices[].finish_reason | Typestring|null |
Champusage | Typeobject |
| 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. |
Ailoot Ultra qwen/qwen3-32b-fp8
Utilisez les chemins de méthode indiqués ci-dessus.
qwen/qwen3-32b-fp8Qwen3-32B-FP8 est l’édition FP8 à granularité fine du modèle textuel dense Qwen3 de 32,8 milliards de paramètres. Elle associe réponses directes et réponses en mode Thinking pour rédaction multilingue, code et analyse, avec identité de checkpoint et compatibilité propres.
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.
Qwen3-32B-FP8 est le checkpoint officiel FP8 du modèle dense Qwen3-32B. Le fabricant décrit les mathématiques, le raisonnement logique, la génération de code, l’écriture créative, le dialogue par rôle et le suivi des instructions sur plusieurs tours. La famille couvre plus de 100 langues et dialectes. Entrée et sortie sont textuelles ; cette version propose des réponses en mode Thinking et des réponses directes en mode Non-Thinking.
Le modèle comporte 32,8 milliards de paramètres, dont 31,2 hors embeddings, et 64 couches. L’attention à requêtes groupées utilise 64 têtes de requête et huit de clé/valeur. C’est une architecture dense, distincte des mélanges d’experts avec paramètres totaux et actifs. FP8 appartient à l’identité exacte. Pour développer, donnez fonction, spécification et entrées puis demandez explication et révision préservant l’interface. Pour éditer, fournissez source, lecteur et terminologie plutôt qu’un contexte indéfini.
Le démarrage rapide emploie le gabarit désigné. Séparez tâche et sources et précisez la forme finale. Une analyse peut comparer deux validations avec mêmes règles de champs, cas acceptés et fonction proposée. Incluez les règles relatives aux valeurs manquantes, des données représentatives et les messages d’erreur requis. Pour un contenu multilingue, fournissez un glossaire et demandez une traduction accompagnée d’une liste de termes à revoir. Cela rend le résultat vérifiable sur une entrée précise. L’intégration attend Qwen3 ; Transformers avant 4.51.0 ne reconnaît pas l’architecture selon la fiche.
La note FP8 décrit une quantification à granularité fine avec des blocs de taille 128, et la configuration identifie le paramétrage de quantification FP8. Le fabricant cite Transformers, SGLang et vLLM mais signale un problème lié au FP8 à granularité fine en inférence distribuée avec Transformers ; plusieurs appareils peuvent nécessiter CUDA_LAUNCH_BLOCKING=1. Séparez compatibilité et texte. L’identité quantifiée seule ne prouve ni latence, ni économie matérielle, ni équivalence de réponse au checkpoint original.
Le gabarit active le mode Thinking par défaut. Une désactivation ferme supprime sa section. Sinon /think et /no_think contrôlent souplement chaque tour avec priorité à la dernière instruction, sans annuler un arrêt ferme. Demandez le raisonnement pour des contradictions puis une réponse directe concise du résultat accepté. Gardez la réponse finale distincte et utilisez-la, non le raisonnement précédent, en historique. Même une demande souple de mode Non-Thinking conserve un bloc Thinking potentiellement vide si le mode Thinking reste activé ; le réglage ferme le retire.
La fiche recommande Qwen-Agent pour le formatage et l’analyse syntaxique des appels d’outils. L’application définit, vérifie et exécute les appels puis renvoie les résultats. Un exécuteur contrôlé peut tester le code sur les cas fournis. Demandez le résumé des réussites et échecs réels et la révision d’une condition fautive nommée. Un appel proposé ne vaut pas preuve d’exécution. Définissez périmètre et champs avant le processus. Qwen3 décrit aussi appels parallèles et en plusieurs étapes avec arguments objets et résultats dans la conversation.
La fiche exacte indique 32 768 tokens natifs et 131 072 avec YaRN. L’extension dépend des réglages ; l’échelle statique peut affecter les textes courts. Entrée et sortie partagent la séquence. Étiquetez les sources et réservez assez de place pour code et explication. Exemples et longueurs recommandées ne fixent pas un plafond universel. Pour générer long, vérifiez cohérence et exigences. L’explication des longueurs d’entraînement Qwen3 mentionne 38 912 tokens assistant en mode Thinking et 16 384 en mode Non-Thinking, et conseille la vérification qualitative des longues générations. Ces chiffres diffèrent du contexte et ne sont pas un plafond ferme d’endpoint. La fiche explique 40 960 positions par défaut comme 8 192 pour prompts typiques et 32 768 pour sortie, conseil distinct du contexte d’entraînement natif et des limites d’endpoint.
Les réglages conseillés sont temperature 0,6, top-p 0,95, top-k 20 et min-p 0 en mode Thinking, et 0,7, 0,8, 20 et 0 en mode de réponse directe (Non-Thinking). Le fabricant déconseille le raisonnement glouton pour répétition ; de fortes pénalités de présence peuvent mélanger les langues. Exigez un résultat inspectable comme tableau de décision, fonction achevée et cas. Vérifiez champs structurés, calculs et code dans l’environnement prévu en conservant l’identité FP8 dans les résultats.
POST /v1/messagestextjson, sse| Champ | Type | Exigence | Valeurs et limites | Par défaut |
|---|---|---|---|---|
Champmodel | Typestring | ExigenceObligatoire | Valeurs et limites qwen/qwen3-32b-fp8 | Par défaut— |
Champmessages | Typemessage[] | ExigenceObligatoire | Valeurs et limites | Par défaut— |
Champmessages[].role | Typestring | ExigenceObligatoire | Valeurs et limites user, assistant | Par défaut— |
Champmessages[].content | Typestring | ExigenceObligatoire | Valeurs et limites | Par défaut— |
Champmax_tokens | Typeinteger | ExigenceObligatoire | Valeurs et limites | Par défaut— |
Champstream | Typeboolean | ExigenceFacultatif | Valeurs et limites | Par défautfalse |
Texte · Texte UTF-8
chaîne messages[].content
| Paramètre | Contrat |
|---|---|
Paramètrecontent_type | Contratapplication/json |
Paramètrerequired | Contratmodel, messages, max_tokens |
Paramètreoptional_controls | Contratstream |
Paramètrematerial_types | Contrattext |
Paramètretext_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
Les tarifs n’ajoutent pas d’options de requête. Les paramètres pris en charge figurent dans la méthode sélectionnée.
| Configuration | Barème tarifaire | Coût |
|---|---|---|
| ConfigurationTarifs de base des tokens | Barème tarifaireTarif de base | Coût Entrée · Tokens en entrée $0.0002 / 1K tokens Sortie · Tokens en sortie $0.001 / 1K tokens Entrée · Lecture du cache $0 / 1K tokens Entrée · Écriture dans le cache $0 / 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 →
{\n "model": "qwen/qwen3-32b-fp8",\n "max_tokens": 128,\n "messages": [\n {\n "role": "user",\n "content": "Summarize the incident report."\n }\n ],\n "stream": false\n}set -eu\n: "${AILOOT_API_KEY:?Set your Ailoot API key}"\n: "${AILOOT_TEXT_FILE:?Set your actual UTF-8 document}"\nexport AILOOT_TEXT_FILE\npython3 - <<'PY_REQUEST'\nimport json, os\nfrom pathlib import Path\n\nsource_file = Path(os.environ['AILOOT_TEXT_FILE'])\nif not source_file.is_file():\n raise SystemExit('Set AILOOT_TEXT_FILE to your actual UTF-8 document')\ntext = source_file.read_text(encoding='utf-8')\nif not text.strip():\n raise SystemExit('Choose a document containing text')\npayload = {'model': 'qwen/qwen3-32b-fp8', 'max_tokens': 128, 'messages': [{'role': 'user', 'content': 'Summarize the incident report.'}]}\npayload['messages'][0]['content'] = 'Summarize this material and quote supporting source passages.\\n\\n' + text\nPath('request.json').write_text(json.dumps(payload, ensure_ascii=False), encoding='utf-8')\nPY_REQUEST\ncurl --fail-with-body --silent --show-error https://api.ailoot.ai/v1/messages \\\n -H "x-api-key: $AILOOT_API_KEY" -H 'anthropic-version: 2023-06-01' -H 'Content-Type: application/json' \\\n --data-binary @request.json -D response-headers.txt -o result.json\npython3 - <<'PY_RESULT'\nimport json\nfrom pathlib import Path\n\nresult = json.loads(Path('result.json').read_text(encoding='utf-8'))\nprint(json.dumps(result, ensure_ascii=False, indent=2))\nPY_RESULT\nimport json, os\nfrom pathlib import Path\n\nsource_file = Path(os.environ['AILOOT_TEXT_FILE'])\nif not source_file.is_file():\n raise SystemExit('Set AILOOT_TEXT_FILE to your actual UTF-8 document')\ntext = source_file.read_text(encoding='utf-8')\nif not text.strip():\n raise SystemExit('Choose a document containing text')\npayload = {'model': 'qwen/qwen3-32b-fp8', 'max_tokens': 128, 'messages': [{'role': 'user', 'content': 'Summarize the incident report.'}]}\npayload['messages'][0]['content'] = 'Summarize this material and quote supporting source passages.\\n\\n' + text\nfrom urllib.request import Request, urlopen\nfrom urllib.error import HTTPError\n\napi_key = os.environ['AILOOT_API_KEY']\nif not api_key.strip():\n raise SystemExit('Set AILOOT_API_KEY before making a request')\nheaders = {'x-api-key': 'PLACEHOLDER_KEY', 'anthropic-version': '2023-06-01', 'Content-Type': 'application/json'}\nheaders['x-api-key'] = api_key\nrequest = Request('https://api.ailoot.ai/v1/messages', data=json.dumps(payload, ensure_ascii=False).encode('utf-8'), headers=headers, method='POST')\ntry:\n with urlopen(request, timeout=120) as response:\n raw = response.read()\n Path('response-headers.txt').write_text(str(response.headers), encoding='utf-8')\nexcept HTTPError as error:\n Path('result.json').write_bytes(error.read())\n Path('response-headers.txt').write_text(str(error.headers), encoding='utf-8')\n raise\nPath('result.json').write_bytes(raw)\nimport json\nfrom pathlib import Path\n\nresult = json.loads(Path('result.json').read_text(encoding='utf-8'))\nprint(json.dumps(result, ensure_ascii=False, indent=2))\nJSON ou SSE
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.
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.
| Champ | Type |
|---|---|
Champid | Typestring |
Champmodel | Typestring |
Champcontent[] | Typetext|thinking|tool_use|other content block |
Champstop_reason | Typestring|null |
Champusage | Typeobject |
| 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. |
Ailoot Ultra qwen/qwen3-32b-fp8
Utilisez les chemins de méthode indiqués ci-dessus.
Exemple technique en anglais
Compare missing-value validators\n\nCompare two Python validators for an optional quantity: A uses if not value: return None; B uses if value is None: return None. Requirement: None means omitted, integer zero is valid, and negative quantities are invalid. Explain each validator's behavior for None, 0 and -1, then propose a complete function with explicit validation errors.A three-input comparison table and a proposed function implementing the supplied rules.Check zero is preserved rather than treated as missing, and negatives are rejected explicitly.