Qwen3-235B-A22B-FP8 est l’édition FP8 officielle de Qwen3-235B-A22B. Ses capacités textuelles annoncées couvrent le raisonnement mathématique et logique, la génération de code, la rédaction créative, le dialogue fondé sur un rôle et le suivi d’instructions à plusieurs tours dans plus de 100 langues et dialectes. Il combine modes Thinking et réponse directe. Utilisez-le pour une tâche associant plusieurs contraintes, comme comparer deux implémentations à une même spécification puis transformer cette comparaison en proposition concrète de modification.
L’architecture sous-jacente est un mélange d’experts : 235 milliards de paramètres au total, 22 milliards actifs pendant le traitement, 94 couches et 128 experts, dont huit sélectionnés par token. L’attention à requêtes groupées utilise 64 têtes de requête et quatre têtes de clé/valeur. Le suffixe FP8 identifie un checkpoint publié séparément, pas une modalité de réponse supplémentaire ni un nombre de paramètres différent. Le modèle reçoit du texte et en génère. Fournissez à un assistant de revue de code la spécification, les fichiers sources pertinents et le comportement attendu ; demandez un tableau de décision, la modification retenue et des exemples illustrant le résultat voulu.
Le processus initial du fabricant formate sources et instructions comme une conversation. Pour comparer des documents, identifiez les versions, précisez l’autorité de chaque source et indiquez les exigences qui doivent rester inchangées. Pour une question mathématique, incluez l’énoncé complet et la forme de réponse finale souhaitée. Pour une tâche d’implémentation, indiquez le langage, la structure réelle de l’entrée, le cas d’échec et les interfaces à conserver. Explicitez le livrable final afin qu’une réponse longue résolve toujours la demande d’origine. L’intégration publiée attend un environnement d’exécution reconnaissant Qwen3 ; la fiche avertit que les versions de Transformers antérieures à 4.51.0 ne reconnaissent pas l’architecture requise.
Cette édition possède une note FP8 dédiée. Le checkpoint utilise une quantification FP8 à granularité fine avec une taille de bloc de 128 ; sa configuration publiée enregistre le schéma de quantification. Le fabricant cite Transformers, SGLang et vLLM comme options d’inférence, tout en signalant des problèmes de FP8 à granularité fine dans l’inférence distribuée avec Transformers. L’utilisation de plusieurs appareils peut nécessiter CUDA_LAUNCH_BLOCKING=1. C’est un détail de compatibilité propre à l’édition, pas une raison de supposer une vitesse, une utilisation mémoire ou une qualité de sortie identiques entre environnements. Conservez le nom FP8 complet lorsque vous comparez ou enregistrez des résultats et évaluez le checkpoint réel dans l’environnement prévu.
Thinking est activé par défaut dans le gabarit de conversation fourni et peut être désactivé par un commutateur explicite de configuration. Si Thinking est activé, /think et /no_think peuvent contrôler chaque tour ; l’instruction la plus récente prévaut. Les commutateurs textuels n’annulent pas une désactivation explicite. Séparez la réponse finale de la section de raisonnement générée et conservez-la dans l’historique du dialogue ultérieur. Une analyse détaillée de contradictions peut demander Thinking, tandis qu’une suite reformatant une conclusion acceptée peut demander une réponse directe. Lorsque Thinking est activé, même une demande textuelle de non-Thinking conserve un bloc de raisonnement, dont le contenu peut être vide. La désactivation explicite supprime ce bloc.
La fiche recommande Qwen-Agent pour les gabarits et l’analyse des appels d’outils. Dans un assistant d’ingénierie, l’application pourrait proposer un exécuteur de tests ou une recherche source en lecture seule, exécuter l’appel accepté et renvoyer des éléments pour la réponse suivante. Précisez les entrées, autorisations et champs de résultat de l’outil. Exigez que l’assistant relie sa modification proposée au résultat renvoyé et distingue un test demandé d’un test réellement terminé par l’application. Les capacités du modèle liées aux outils dépendent de ce processus d’exécution environnant. Le guide Qwen3 décrit aussi des appels d’outils parallèles et en plusieurs étapes, avec des arguments représentés comme des objets et des résultats renvoyés dans la conversation.
Le contexte natif est de 32 768 tokens, avec 131 072 documentés par extension YaRN. Entrée et sortie générée partagent le budget de séquence. La fenêtre plus grande nécessite la configuration pertinente et le YaRN statique peut affecter les entrées courtes. Organisez les longues sources par fichier ou section et réservez de la place pour la comparaison finale ou le code. Les longueurs de sortie du démarrage rapide et des recommandations sont des conseils de génération, pas la preuve d’un maximum indépendant de sortie valable pour tout le service. La documentation Qwen3 traite de longueurs de messages d’assistant de 38 912 tokens en mode Thinking et 16 384 en mode non-Thinking dans son explication de la longueur d’entraînement, et recommande d’évaluer la qualité des générations plus longues. Ces chiffres se distinguent de la fenêtre globale de contexte et ne constituent pas une limite stricte propre à un endpoint. La fiche explique aussi son allocation positionnelle par défaut de 40 960 tokens comme 8 192 pour les prompts typiques plus 32 768 pour la sortie ; ce sont des conseils de configuration du fabricant, distincts du contexte natif d’entraînement et de toute limite d’endpoint.
L’échantillonnage recommandé en mode Thinking est temperature 0,6, top-p 0,95, top-k 20 et min-p 0 ; le mode direct utilise 0,7, 0,8, 20 et 0. Le décodage glouton en mode Thinking peut provoquer des répétitions et de fortes pénalités de présence peuvent mélanger les langues. Demandez une structure finale vérifiable, par exemple un tableau de résultats suivi de la fonction modifiée et des cas pertinents. Vérifiez les conclusions numériques, exécutez le code dans l’environnement cible et examinez les résultats des outils avant d’appliquer une modification proposée. L’identité du checkpoint FP8 et ses précautions d’exécution devraient rester associées à cette évaluation.
", "aboutText": "Qwen3-235B-A22B-FP8 est l’édition FP8 officielle de Qwen3-235B-A22B. Ses capacités textuelles annoncées couvrent le raisonnement mathématique et logique, la génération de code, la rédaction créative, le dialogue fondé sur un rôle et le suivi d’instructions à plusieurs tours dans plus de 100 langues et dialectes. Il combine modes Thinking et réponse directe. Utilisez-le pour une tâche associant plusieurs contraintes, comme comparer deux implémentations à une même spécification puis transformer cette comparaison en proposition concrète de modification.\n\nL’architecture sous-jacente est un mélange d’experts : 235 milliards de paramètres au total, 22 milliards actifs pendant le traitement, 94 couches et 128 experts, dont huit sélectionnés par token. L’attention à requêtes groupées utilise 64 têtes de requête et quatre têtes de clé/valeur. Le suffixe FP8 identifie un checkpoint publié séparément, pas une modalité de réponse supplémentaire ni un nombre de paramètres différent. Le modèle reçoit du texte et en génère. Fournissez à un assistant de revue de code la spécification, les fichiers sources pertinents et le comportement attendu ; demandez un tableau de décision, la modification retenue et des exemples illustrant le résultat voulu.\n\nLe processus initial du fabricant formate sources et instructions comme une conversation. Pour comparer des documents, identifiez les versions, précisez l’autorité de chaque source et indiquez les exigences qui doivent rester inchangées. Pour une question mathématique, incluez l’énoncé complet et la forme de réponse finale souhaitée. Pour une tâche d’implémentation, indiquez le langage, la structure réelle de l’entrée, le cas d’échec et les interfaces à conserver. Explicitez le livrable final afin qu’une réponse longue résolve toujours la demande d’origine. L’intégration publiée attend un environnement d’exécution reconnaissant Qwen3 ; la fiche avertit que les versions de Transformers antérieures à 4.51.0 ne reconnaissent pas l’architecture requise.\n\nCette édition possède une note FP8 dédiée. Le checkpoint utilise une quantification FP8 à granularité fine avec une taille de bloc de 128 ; sa configuration publiée enregistre le schéma de quantification. Le fabricant cite Transformers, SGLang et vLLM comme options d’inférence, tout en signalant des problèmes de FP8 à granularité fine dans l’inférence distribuée avec Transformers. L’utilisation de plusieurs appareils peut nécessiter CUDA_LAUNCH_BLOCKING=1. C’est un détail de compatibilité propre à l’édition, pas une raison de supposer une vitesse, une utilisation mémoire ou une qualité de sortie identiques entre environnements. Conservez le nom FP8 complet lorsque vous comparez ou enregistrez des résultats et évaluez le checkpoint réel dans l’environnement prévu.\n\nThinking est activé par défaut dans le gabarit de conversation fourni et peut être désactivé par un commutateur explicite de configuration. Si Thinking est activé, /think et /no_think peuvent contrôler chaque tour ; l’instruction la plus récente prévaut. Les commutateurs textuels n’annulent pas une désactivation explicite. Séparez la réponse finale de la section de raisonnement générée et conservez-la dans l’historique du dialogue ultérieur. Une analyse détaillée de contradictions peut demander Thinking, tandis qu’une suite reformatant une conclusion acceptée peut demander une réponse directe. Lorsque Thinking est activé, même une demande textuelle de non-Thinking conserve un bloc de raisonnement, dont le contenu peut être vide. La désactivation explicite supprime ce bloc.\n\nLa fiche recommande Qwen-Agent pour les gabarits et l’analyse des appels d’outils. Dans un assistant d’ingénierie, l’application pourrait proposer un exécuteur de tests ou une recherche source en lecture seule, exécuter l’appel accepté et renvoyer des éléments pour la réponse suivante. Précisez les entrées, autorisations et champs de résultat de l’outil. Exigez que l’assistant relie sa modification proposée au résultat renvoyé et distingue un test demandé d’un test réellement terminé par l’application. Les capacités du modèle liées aux outils dépendent de ce processus d’exécution environnant. Le guide Qwen3 décrit aussi des appels d’outils parallèles et en plusieurs étapes, avec des arguments représentés comme des objets et des résultats renvoyés dans la conversation.\n\nLe contexte natif est de 32 768 tokens, avec 131 072 documentés par extension YaRN. Entrée et sortie générée partagent le budget de séquence. La fenêtre plus grande nécessite la configuration pertinente et le YaRN statique peut affecter les entrées courtes. Organisez les longues sources par fichier ou section et réservez de la place pour la comparaison finale ou le code. Les longueurs de sortie du démarrage rapide et des recommandations sont des conseils de génération, pas la preuve d’un maximum indépendant de sortie valable pour tout le service. La documentation Qwen3 traite de longueurs de messages d’assistant de 38 912 tokens en mode Thinking et 16 384 en mode non-Thinking dans son explication de la longueur d’entraînement, et recommande d’évaluer la qualité des générations plus longues. Ces chiffres se distinguent de la fenêtre globale de contexte et ne constituent pas une limite stricte propre à un endpoint. La fiche explique aussi son allocation positionnelle par défaut de 40 960 tokens comme 8 192 pour les prompts typiques plus 32 768 pour la sortie ; ce sont des conseils de configuration du fabricant, distincts du contexte natif d’entraînement et de toute limite d’endpoint.\n\nL’échantillonnage recommandé en mode Thinking est temperature 0,6, top-p 0,95, top-k 20 et min-p 0 ; le mode direct utilise 0,7, 0,8, 20 et 0. Le décodage glouton en mode Thinking peut provoquer des répétitions et de fortes pénalités de présence peuvent mélanger les langues. Demandez une structure finale vérifiable, par exemple un tableau de résultats suivi de la fonction modifiée et des cas pertinents. Vérifiez les conclusions numériques, exécutez le code dans l’environnement cible et examinez les résultats des outils avant d’appliquer une modification proposée. L’identité du checkpoint FP8 et ses précautions d’exécution devraient rester associées à cette évaluation.", "editorialOverlay": { "copy_fields": { "practical_html": "Exemple technique en anglais
Compare two normalizers to a contract\n\nThe contract requires unique case-sensitive tags in first-occurrence order. Compare Python A: return sorted(set(tags)) with B: return list(dict.fromkeys(tags)). Input: ["red", "Blue", "red", "blue"]. Give a criterion table, select the compliant implementation and provide tests for order and case preservation. Do not alter the contract to fit either implementation.A two-implementation decision table, a selected implementation and two contract-focused tests.Check that sorting is recognized as an order violation and Blue remains distinct from blue.qwen/qwen3-235b-a22b-fp8Qwen3-235B-A22B-FP8 est le checkpoint FP8 officiel à granularité fine du grand modèle à mélange d’experts de Qwen3. Il conserve les capacités hybrides de raisonnement textuel et de dialogue, avec sa propre identité de quantification et ses considérations d’exécution.
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-235B-A22B-FP8 est l’édition FP8 officielle de Qwen3-235B-A22B. Ses capacités textuelles annoncées couvrent le raisonnement mathématique et logique, la génération de code, la rédaction créative, le dialogue fondé sur un rôle et le suivi d’instructions à plusieurs tours dans plus de 100 langues et dialectes. Il combine modes Thinking et réponse directe. Utilisez-le pour une tâche associant plusieurs contraintes, comme comparer deux implémentations à une même spécification puis transformer cette comparaison en proposition concrète de modification.
L’architecture sous-jacente est un mélange d’experts : 235 milliards de paramètres au total, 22 milliards actifs pendant le traitement, 94 couches et 128 experts, dont huit sélectionnés par token. L’attention à requêtes groupées utilise 64 têtes de requête et quatre têtes de clé/valeur. Le suffixe FP8 identifie un checkpoint publié séparément, pas une modalité de réponse supplémentaire ni un nombre de paramètres différent. Le modèle reçoit du texte et en génère. Fournissez à un assistant de revue de code la spécification, les fichiers sources pertinents et le comportement attendu ; demandez un tableau de décision, la modification retenue et des exemples illustrant le résultat voulu.
Le processus initial du fabricant formate sources et instructions comme une conversation. Pour comparer des documents, identifiez les versions, précisez l’autorité de chaque source et indiquez les exigences qui doivent rester inchangées. Pour une question mathématique, incluez l’énoncé complet et la forme de réponse finale souhaitée. Pour une tâche d’implémentation, indiquez le langage, la structure réelle de l’entrée, le cas d’échec et les interfaces à conserver. Explicitez le livrable final afin qu’une réponse longue résolve toujours la demande d’origine. L’intégration publiée attend un environnement d’exécution reconnaissant Qwen3 ; la fiche avertit que les versions de Transformers antérieures à 4.51.0 ne reconnaissent pas l’architecture requise.
Cette édition possède une note FP8 dédiée. Le checkpoint utilise une quantification FP8 à granularité fine avec une taille de bloc de 128 ; sa configuration publiée enregistre le schéma de quantification. Le fabricant cite Transformers, SGLang et vLLM comme options d’inférence, tout en signalant des problèmes de FP8 à granularité fine dans l’inférence distribuée avec Transformers. L’utilisation de plusieurs appareils peut nécessiter CUDA_LAUNCH_BLOCKING=1. C’est un détail de compatibilité propre à l’édition, pas une raison de supposer une vitesse, une utilisation mémoire ou une qualité de sortie identiques entre environnements. Conservez le nom FP8 complet lorsque vous comparez ou enregistrez des résultats et évaluez le checkpoint réel dans l’environnement prévu.
Thinking est activé par défaut dans le gabarit de conversation fourni et peut être désactivé par un commutateur explicite de configuration. Si Thinking est activé, /think et /no_think peuvent contrôler chaque tour ; l’instruction la plus récente prévaut. Les commutateurs textuels n’annulent pas une désactivation explicite. Séparez la réponse finale de la section de raisonnement générée et conservez-la dans l’historique du dialogue ultérieur. Une analyse détaillée de contradictions peut demander Thinking, tandis qu’une suite reformatant une conclusion acceptée peut demander une réponse directe. Lorsque Thinking est activé, même une demande textuelle de non-Thinking conserve un bloc de raisonnement, dont le contenu peut être vide. La désactivation explicite supprime ce bloc.
La fiche recommande Qwen-Agent pour les gabarits et l’analyse des appels d’outils. Dans un assistant d’ingénierie, l’application pourrait proposer un exécuteur de tests ou une recherche source en lecture seule, exécuter l’appel accepté et renvoyer des éléments pour la réponse suivante. Précisez les entrées, autorisations et champs de résultat de l’outil. Exigez que l’assistant relie sa modification proposée au résultat renvoyé et distingue un test demandé d’un test réellement terminé par l’application. Les capacités du modèle liées aux outils dépendent de ce processus d’exécution environnant. Le guide Qwen3 décrit aussi des appels d’outils parallèles et en plusieurs étapes, avec des arguments représentés comme des objets et des résultats renvoyés dans la conversation.
Le contexte natif est de 32 768 tokens, avec 131 072 documentés par extension YaRN. Entrée et sortie générée partagent le budget de séquence. La fenêtre plus grande nécessite la configuration pertinente et le YaRN statique peut affecter les entrées courtes. Organisez les longues sources par fichier ou section et réservez de la place pour la comparaison finale ou le code. Les longueurs de sortie du démarrage rapide et des recommandations sont des conseils de génération, pas la preuve d’un maximum indépendant de sortie valable pour tout le service. La documentation Qwen3 traite de longueurs de messages d’assistant de 38 912 tokens en mode Thinking et 16 384 en mode non-Thinking dans son explication de la longueur d’entraînement, et recommande d’évaluer la qualité des générations plus longues. Ces chiffres se distinguent de la fenêtre globale de contexte et ne constituent pas une limite stricte propre à un endpoint. La fiche explique aussi son allocation positionnelle par défaut de 40 960 tokens comme 8 192 pour les prompts typiques plus 32 768 pour la sortie ; ce sont des conseils de configuration du fabricant, distincts du contexte natif d’entraînement et de toute limite d’endpoint.
L’échantillonnage recommandé en mode Thinking est temperature 0,6, top-p 0,95, top-k 20 et min-p 0 ; le mode direct utilise 0,7, 0,8, 20 et 0. Le décodage glouton en mode Thinking peut provoquer des répétitions et de fortes pénalités de présence peuvent mélanger les langues. Demandez une structure finale vérifiable, par exemple un tableau de résultats suivi de la fonction modifiée et des cas pertinents. Vérifiez les conclusions numériques, exécutez le code dans l’environnement cible et examinez les résultats des outils avant d’appliquer une modification proposée. L’identité du checkpoint FP8 et ses précautions d’exécution devraient rester associées à cette évaluation.
POST /v1/chat/completionstexttext| Champ | Type | Exigence | Valeurs et limites | Par défaut |
|---|---|---|---|---|
Champmodel | Typestring | ExigenceObligatoire | Valeurs et limites qwen/qwen3-235b-a22b-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.0004 / 1K tokens Sortie · Tokens en sortie $0.0016 / 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-235b-a22b-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-235b-a22b-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-235b-a22b-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-235b-a22b-fp8
Utilisez les chemins de méthode indiqués ci-dessus.
qwen/qwen3-235b-a22b-fp8Qwen3-235B-A22B-FP8 est le checkpoint FP8 officiel à granularité fine du grand modèle à mélange d’experts de Qwen3. Il conserve les capacités hybrides de raisonnement textuel et de dialogue, avec sa propre identité de quantification et ses considérations d’exécution.
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-235B-A22B-FP8 est l’édition FP8 officielle de Qwen3-235B-A22B. Ses capacités textuelles annoncées couvrent le raisonnement mathématique et logique, la génération de code, la rédaction créative, le dialogue fondé sur un rôle et le suivi d’instructions à plusieurs tours dans plus de 100 langues et dialectes. Il combine modes Thinking et réponse directe. Utilisez-le pour une tâche associant plusieurs contraintes, comme comparer deux implémentations à une même spécification puis transformer cette comparaison en proposition concrète de modification.
L’architecture sous-jacente est un mélange d’experts : 235 milliards de paramètres au total, 22 milliards actifs pendant le traitement, 94 couches et 128 experts, dont huit sélectionnés par token. L’attention à requêtes groupées utilise 64 têtes de requête et quatre têtes de clé/valeur. Le suffixe FP8 identifie un checkpoint publié séparément, pas une modalité de réponse supplémentaire ni un nombre de paramètres différent. Le modèle reçoit du texte et en génère. Fournissez à un assistant de revue de code la spécification, les fichiers sources pertinents et le comportement attendu ; demandez un tableau de décision, la modification retenue et des exemples illustrant le résultat voulu.
Le processus initial du fabricant formate sources et instructions comme une conversation. Pour comparer des documents, identifiez les versions, précisez l’autorité de chaque source et indiquez les exigences qui doivent rester inchangées. Pour une question mathématique, incluez l’énoncé complet et la forme de réponse finale souhaitée. Pour une tâche d’implémentation, indiquez le langage, la structure réelle de l’entrée, le cas d’échec et les interfaces à conserver. Explicitez le livrable final afin qu’une réponse longue résolve toujours la demande d’origine. L’intégration publiée attend un environnement d’exécution reconnaissant Qwen3 ; la fiche avertit que les versions de Transformers antérieures à 4.51.0 ne reconnaissent pas l’architecture requise.
Cette édition possède une note FP8 dédiée. Le checkpoint utilise une quantification FP8 à granularité fine avec une taille de bloc de 128 ; sa configuration publiée enregistre le schéma de quantification. Le fabricant cite Transformers, SGLang et vLLM comme options d’inférence, tout en signalant des problèmes de FP8 à granularité fine dans l’inférence distribuée avec Transformers. L’utilisation de plusieurs appareils peut nécessiter CUDA_LAUNCH_BLOCKING=1. C’est un détail de compatibilité propre à l’édition, pas une raison de supposer une vitesse, une utilisation mémoire ou une qualité de sortie identiques entre environnements. Conservez le nom FP8 complet lorsque vous comparez ou enregistrez des résultats et évaluez le checkpoint réel dans l’environnement prévu.
Thinking est activé par défaut dans le gabarit de conversation fourni et peut être désactivé par un commutateur explicite de configuration. Si Thinking est activé, /think et /no_think peuvent contrôler chaque tour ; l’instruction la plus récente prévaut. Les commutateurs textuels n’annulent pas une désactivation explicite. Séparez la réponse finale de la section de raisonnement générée et conservez-la dans l’historique du dialogue ultérieur. Une analyse détaillée de contradictions peut demander Thinking, tandis qu’une suite reformatant une conclusion acceptée peut demander une réponse directe. Lorsque Thinking est activé, même une demande textuelle de non-Thinking conserve un bloc de raisonnement, dont le contenu peut être vide. La désactivation explicite supprime ce bloc.
La fiche recommande Qwen-Agent pour les gabarits et l’analyse des appels d’outils. Dans un assistant d’ingénierie, l’application pourrait proposer un exécuteur de tests ou une recherche source en lecture seule, exécuter l’appel accepté et renvoyer des éléments pour la réponse suivante. Précisez les entrées, autorisations et champs de résultat de l’outil. Exigez que l’assistant relie sa modification proposée au résultat renvoyé et distingue un test demandé d’un test réellement terminé par l’application. Les capacités du modèle liées aux outils dépendent de ce processus d’exécution environnant. Le guide Qwen3 décrit aussi des appels d’outils parallèles et en plusieurs étapes, avec des arguments représentés comme des objets et des résultats renvoyés dans la conversation.
Le contexte natif est de 32 768 tokens, avec 131 072 documentés par extension YaRN. Entrée et sortie générée partagent le budget de séquence. La fenêtre plus grande nécessite la configuration pertinente et le YaRN statique peut affecter les entrées courtes. Organisez les longues sources par fichier ou section et réservez de la place pour la comparaison finale ou le code. Les longueurs de sortie du démarrage rapide et des recommandations sont des conseils de génération, pas la preuve d’un maximum indépendant de sortie valable pour tout le service. La documentation Qwen3 traite de longueurs de messages d’assistant de 38 912 tokens en mode Thinking et 16 384 en mode non-Thinking dans son explication de la longueur d’entraînement, et recommande d’évaluer la qualité des générations plus longues. Ces chiffres se distinguent de la fenêtre globale de contexte et ne constituent pas une limite stricte propre à un endpoint. La fiche explique aussi son allocation positionnelle par défaut de 40 960 tokens comme 8 192 pour les prompts typiques plus 32 768 pour la sortie ; ce sont des conseils de configuration du fabricant, distincts du contexte natif d’entraînement et de toute limite d’endpoint.
L’échantillonnage recommandé en mode Thinking est temperature 0,6, top-p 0,95, top-k 20 et min-p 0 ; le mode direct utilise 0,7, 0,8, 20 et 0. Le décodage glouton en mode Thinking peut provoquer des répétitions et de fortes pénalités de présence peuvent mélanger les langues. Demandez une structure finale vérifiable, par exemple un tableau de résultats suivi de la fonction modifiée et des cas pertinents. Vérifiez les conclusions numériques, exécutez le code dans l’environnement cible et examinez les résultats des outils avant d’appliquer une modification proposée. L’identité du checkpoint FP8 et ses précautions d’exécution devraient rester associées à cette évaluation.
POST /v1/messagestextjson, sse| Champ | Type | Exigence | Valeurs et limites | Par défaut |
|---|---|---|---|---|
Champmodel | Typestring | ExigenceObligatoire | Valeurs et limites qwen/qwen3-235b-a22b-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.0004 / 1K tokens Sortie · Tokens en sortie $0.0016 / 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-235b-a22b-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-235b-a22b-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-235b-a22b-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-235b-a22b-fp8
Utilisez les chemins de méthode indiqués ci-dessus.
Exemple technique en anglais
Compare two normalizers to a contract\n\nThe contract requires unique case-sensitive tags in first-occurrence order. Compare Python A: return sorted(set(tags)) with B: return list(dict.fromkeys(tags)). Input: ["red", "Blue", "red", "blue"]. Give a criterion table, select the compliant implementation and provide tests for order and case preservation. Do not alter the contract to fit either implementation.A two-implementation decision table, a selected implementation and two contract-focused tests.Check that sorting is recognized as an order violation and Blue remains distinct from blue.