Gemini 3.8 Flash est le modèle à sortie textuelle de Google pour le génie logiciel soutenu, les agents à plusieurs étapes et les flux de travail complexes sur les connaissances. Il s’appuie sur Gemini 3.7 Flash, avec des améliorations en génie logiciel et dans le travail sur les connaissances effectué par des agents. Il accepte le texte, les images, l’audio, la vidéo et les PDF, de sorte qu’une tâche peut combiner un objectif écrit avec les éléments réels nécessaires pour la résoudre. Le résultat utile est une modification de code, une analyse expliquée, une réponse écrite ou un enregistrement structuré.
Pour une tâche de programmation, fournissez l’exigence, les fichiers pertinents, le comportement observé et les contraintes à préserver. Une capture d’écran peut établir l’interface souhaitée, tandis que des journaux ou un exemple reproductible montrent la défaillance. Pour une tâche de débogage, demandez au modèle de retracer un écart entre l’état visible d’un formulaire et sa valeur enregistrée, d’identifier le chemin de code responsable et de proposer une correction ciblée. Gardez le livrable final souhaité clair afin qu’une séquence d’investigation et d’utilisation d’outils plus longue conserve une condition de fin précise.
Pour les travaux de longue durée, utilisez des étapes de raisonnement plus petites, des appels d’outils itératifs et des vérifications des résultats intermédiaires. Les niveaux de réflexion faible, moyen et élevé contrôlent la quantité de raisonnement; le niveau moyen est la valeur par défaut documentée. Le niveau faible convient à une ébauche rapide ou à une analyse délimitée, tandis que le niveau élevé vise les mathématiques difficiles, la programmation ou les tâches à plusieurs étapes. Gemini 3.8 Flash ne prend pas en charge le niveau de réflexion minimal. Une tâche de débogage soutenue et une simple extraction de champs demandent donc des choix de raisonnement différents plutôt que le même réglage pour toutes les requêtes.
Les outils documentés comprennent les appels de fonctions, l’exécution de code, la recherche de fichiers, l’ancrage par recherche, l’ancrage avec Google Maps et le contexte URL, Computer Use étant présenté comme une capacité en préversion. Les sorties structurées définissent un résultat lisible par machine. Les fonctions doivent avoir une finalité claire et des paramètres définis : le modèle peut demander une fonction, tandis que l’application connectée réalise l’opération et renvoie son résultat. Préservez l’identité des fonctions et les éléments réellement renvoyés d’un tour à l’autre. Une réponse finale utile explique quelles données probantes appuient la correction proposée ou la valeur extraite.
Le guide de migration 3.8 utilise des contrôles de niveau de réflexion à la place de l’ancienne configuration du budget de raisonnement et conseille de retirer les paramètres d’échantillonnage obsolètes et les tours de modèle préremplis. Il exige aussi de préserver les signatures de pensée dans le flux sans état pertinent et de faire correspondre les réponses de fonctions à leurs appels par identité et nom. Ces détails comptent lorsqu’on poursuit une tâche à plusieurs étapes : le tour suivant a besoin du contexte réel antérieur plutôt que d’un récit réécrit qui perd le résultat d’outil ou la signature. Gardez la question et la sortie demandée explicites dans le nouveau tour utilisateur.
Pour le travail multimodal sur les connaissances, identifiez les pages de document, le graphique, l’intervalle audio ou l’événement vidéo pertinents et indiquez comment ils doivent contribuer à la réponse. Une comparaison de documents peut demander un tableau des différences avec des passages sources; une question sur un graphique peut demander les valeurs visibles et la conclusion qu’elles appuient. Une analyse vidéo peut demander une description des événements qui justifient un constat. Le modèle renvoie du texte à partir de ces entrées. Les images générées, la parole et les interactions audio en direct relèvent de profils de modèles distincts.
Ses limites Gemini API sont de 1 048 576 jetons d’entrée et de 65 536 jetons de sortie, ce qui correspond au contexte natif allant jusqu’à 1M et à la sortie textuelle de 64K du modèle. Les instructions, l’historique de conversation et les médias fournis consomment le contexte d’entrée, et le raisonnement ou un long livrable final doivent respecter la capacité de sortie documentée. Google indique aussi la mise en cache, le traitement par lots, Flex et Priority pour ce profil du producteur. Pour des éléments indépendants, conservez un identifiant stable et un format de sortie explicite afin que chaque résultat reste lié à sa source.
Les limites possibles comprennent des hallucinations, des lenteurs ou des dépassements de délai occasionnels et une consommation plus élevée de jetons avec un effort accru. Ses connaissances s’arrêtent en mars 2026, certains domaines restant limités à janvier 2025. Fournissez des données actuelles ou utilisez les outils d’ancrage documentés lorsque la tâche dépend d’informations plus récentes. Vérifiez les citations de sources, les calculs et le code proposé à partir des entrées réelles et des résultats d’exécution. Le livrable final utile doit distinguer un constat appuyé d’une question non résolue, sans supposer qu’une réponse fluide établit le résultat demandé.
", "aboutText": "Gemini 3.8 Flash est le modèle à sortie textuelle de Google pour le génie logiciel soutenu, les agents à plusieurs étapes et les flux de travail complexes sur les connaissances. Il s’appuie sur Gemini 3.7 Flash, avec des améliorations en génie logiciel et dans le travail sur les connaissances effectué par des agents. Il accepte le texte, les images, l’audio, la vidéo et les PDF, de sorte qu’une tâche peut combiner un objectif écrit avec les éléments réels nécessaires pour la résoudre. Le résultat utile est une modification de code, une analyse expliquée, une réponse écrite ou un enregistrement structuré.\n\nPour une tâche de programmation, fournissez l’exigence, les fichiers pertinents, le comportement observé et les contraintes à préserver. Une capture d’écran peut établir l’interface souhaitée, tandis que des journaux ou un exemple reproductible montrent la défaillance. Pour une tâche de débogage, demandez au modèle de retracer un écart entre l’état visible d’un formulaire et sa valeur enregistrée, d’identifier le chemin de code responsable et de proposer une correction ciblée. Gardez le livrable final souhaité clair afin qu’une séquence d’investigation et d’utilisation d’outils plus longue conserve une condition de fin précise.\n\nPour les travaux de longue durée, utilisez des étapes de raisonnement plus petites, des appels d’outils itératifs et des vérifications des résultats intermédiaires. Les niveaux de réflexion faible, moyen et élevé contrôlent la quantité de raisonnement; le niveau moyen est la valeur par défaut documentée. Le niveau faible convient à une ébauche rapide ou à une analyse délimitée, tandis que le niveau élevé vise les mathématiques difficiles, la programmation ou les tâches à plusieurs étapes. Gemini 3.8 Flash ne prend pas en charge le niveau de réflexion minimal. Une tâche de débogage soutenue et une simple extraction de champs demandent donc des choix de raisonnement différents plutôt que le même réglage pour toutes les requêtes.\n\nLes outils documentés comprennent les appels de fonctions, l’exécution de code, la recherche de fichiers, l’ancrage par recherche, l’ancrage avec Google Maps et le contexte URL, Computer Use étant présenté comme une capacité en préversion. Les sorties structurées définissent un résultat lisible par machine. Les fonctions doivent avoir une finalité claire et des paramètres définis : le modèle peut demander une fonction, tandis que l’application connectée réalise l’opération et renvoie son résultat. Préservez l’identité des fonctions et les éléments réellement renvoyés d’un tour à l’autre. Une réponse finale utile explique quelles données probantes appuient la correction proposée ou la valeur extraite.\n\nLe guide de migration 3.8 utilise des contrôles de niveau de réflexion à la place de l’ancienne configuration du budget de raisonnement et conseille de retirer les paramètres d’échantillonnage obsolètes et les tours de modèle préremplis. Il exige aussi de préserver les signatures de pensée dans le flux sans état pertinent et de faire correspondre les réponses de fonctions à leurs appels par identité et nom. Ces détails comptent lorsqu’on poursuit une tâche à plusieurs étapes : le tour suivant a besoin du contexte réel antérieur plutôt que d’un récit réécrit qui perd le résultat d’outil ou la signature. Gardez la question et la sortie demandée explicites dans le nouveau tour utilisateur.\n\nPour le travail multimodal sur les connaissances, identifiez les pages de document, le graphique, l’intervalle audio ou l’événement vidéo pertinents et indiquez comment ils doivent contribuer à la réponse. Une comparaison de documents peut demander un tableau des différences avec des passages sources; une question sur un graphique peut demander les valeurs visibles et la conclusion qu’elles appuient. Une analyse vidéo peut demander une description des événements qui justifient un constat. Le modèle renvoie du texte à partir de ces entrées. Les images générées, la parole et les interactions audio en direct relèvent de profils de modèles distincts.\n\nSes limites Gemini API sont de 1 048 576 jetons d’entrée et de 65 536 jetons de sortie, ce qui correspond au contexte natif allant jusqu’à 1M et à la sortie textuelle de 64K du modèle. Les instructions, l’historique de conversation et les médias fournis consomment le contexte d’entrée, et le raisonnement ou un long livrable final doivent respecter la capacité de sortie documentée. Google indique aussi la mise en cache, le traitement par lots, Flex et Priority pour ce profil du producteur. Pour des éléments indépendants, conservez un identifiant stable et un format de sortie explicite afin que chaque résultat reste lié à sa source.\n\nLes limites possibles comprennent des hallucinations, des lenteurs ou des dépassements de délai occasionnels et une consommation plus élevée de jetons avec un effort accru. Ses connaissances s’arrêtent en mars 2026, certains domaines restant limités à janvier 2025. Fournissez des données actuelles ou utilisez les outils d’ancrage documentés lorsque la tâche dépend d’informations plus récentes. Vérifiez les citations de sources, les calculs et le code proposé à partir des entrées réelles et des résultats d’exécution. Le livrable final utile doit distinguer un constat appuyé d’une question non résolue, sans supposer qu’une réponse fluide établit le résultat demandé.", "editorialOverlay": { "copy_fields": { "practical_html": "Exemple technique en anglais
Diagnose an unsaved form value\n\nReview this form flow: the input displays draft.name; typing updates draft.name; Save sends original.name; after reload the old name reappears. Explain the mismatch and propose a minimal correction in framework-neutral pseudocode. Include a regression scenario that types a new name, saves, reloads, and checks the stored value. Do not claim any browser action occurred.A cause explanation, corrected Save pseudocode and an end-to-end regression scenario.The submitted value comes from the edited draft, and the reload check verifies persistence rather than just the visible input.gemini-3.8-flashGemini 3.8 Flash est le modèle multimodal polyvalent de Google pour le génie logiciel soutenu, les agents et les tâches complexes de traitement des connaissances. Il accepte le texte, les images, l’audio, la vidéo et les PDF, renvoie du texte et offre un raisonnement faible, moyen ou élevé avec des outils et une sortie structurée. Ses limites d’entrée/sortie documentées sont de 1 048 576/65 536 jetons.
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.
Gemini 3.8 Flash est le modèle à sortie textuelle de Google pour le génie logiciel soutenu, les agents à plusieurs étapes et les flux de travail complexes sur les connaissances. Il s’appuie sur Gemini 3.7 Flash, avec des améliorations en génie logiciel et dans le travail sur les connaissances effectué par des agents. Il accepte le texte, les images, l’audio, la vidéo et les PDF, de sorte qu’une tâche peut combiner un objectif écrit avec les éléments réels nécessaires pour la résoudre. Le résultat utile est une modification de code, une analyse expliquée, une réponse écrite ou un enregistrement structuré.
Pour une tâche de programmation, fournissez l’exigence, les fichiers pertinents, le comportement observé et les contraintes à préserver. Une capture d’écran peut établir l’interface souhaitée, tandis que des journaux ou un exemple reproductible montrent la défaillance. Pour une tâche de débogage, demandez au modèle de retracer un écart entre l’état visible d’un formulaire et sa valeur enregistrée, d’identifier le chemin de code responsable et de proposer une correction ciblée. Gardez le livrable final souhaité clair afin qu’une séquence d’investigation et d’utilisation d’outils plus longue conserve une condition de fin précise.
Pour les travaux de longue durée, utilisez des étapes de raisonnement plus petites, des appels d’outils itératifs et des vérifications des résultats intermédiaires. Les niveaux de réflexion faible, moyen et élevé contrôlent la quantité de raisonnement; le niveau moyen est la valeur par défaut documentée. Le niveau faible convient à une ébauche rapide ou à une analyse délimitée, tandis que le niveau élevé vise les mathématiques difficiles, la programmation ou les tâches à plusieurs étapes. Gemini 3.8 Flash ne prend pas en charge le niveau de réflexion minimal. Une tâche de débogage soutenue et une simple extraction de champs demandent donc des choix de raisonnement différents plutôt que le même réglage pour toutes les requêtes.
Les outils documentés comprennent les appels de fonctions, l’exécution de code, la recherche de fichiers, l’ancrage par recherche, l’ancrage avec Google Maps et le contexte URL, Computer Use étant présenté comme une capacité en préversion. Les sorties structurées définissent un résultat lisible par machine. Les fonctions doivent avoir une finalité claire et des paramètres définis : le modèle peut demander une fonction, tandis que l’application connectée réalise l’opération et renvoie son résultat. Préservez l’identité des fonctions et les éléments réellement renvoyés d’un tour à l’autre. Une réponse finale utile explique quelles données probantes appuient la correction proposée ou la valeur extraite.
Le guide de migration 3.8 utilise des contrôles de niveau de réflexion à la place de l’ancienne configuration du budget de raisonnement et conseille de retirer les paramètres d’échantillonnage obsolètes et les tours de modèle préremplis. Il exige aussi de préserver les signatures de pensée dans le flux sans état pertinent et de faire correspondre les réponses de fonctions à leurs appels par identité et nom. Ces détails comptent lorsqu’on poursuit une tâche à plusieurs étapes : le tour suivant a besoin du contexte réel antérieur plutôt que d’un récit réécrit qui perd le résultat d’outil ou la signature. Gardez la question et la sortie demandée explicites dans le nouveau tour utilisateur.
Pour le travail multimodal sur les connaissances, identifiez les pages de document, le graphique, l’intervalle audio ou l’événement vidéo pertinents et indiquez comment ils doivent contribuer à la réponse. Une comparaison de documents peut demander un tableau des différences avec des passages sources; une question sur un graphique peut demander les valeurs visibles et la conclusion qu’elles appuient. Une analyse vidéo peut demander une description des événements qui justifient un constat. Le modèle renvoie du texte à partir de ces entrées. Les images générées, la parole et les interactions audio en direct relèvent de profils de modèles distincts.
Ses limites Gemini API sont de 1 048 576 jetons d’entrée et de 65 536 jetons de sortie, ce qui correspond au contexte natif allant jusqu’à 1M et à la sortie textuelle de 64K du modèle. Les instructions, l’historique de conversation et les médias fournis consomment le contexte d’entrée, et le raisonnement ou un long livrable final doivent respecter la capacité de sortie documentée. Google indique aussi la mise en cache, le traitement par lots, Flex et Priority pour ce profil du producteur. Pour des éléments indépendants, conservez un identifiant stable et un format de sortie explicite afin que chaque résultat reste lié à sa source.
Les limites possibles comprennent des hallucinations, des lenteurs ou des dépassements de délai occasionnels et une consommation plus élevée de jetons avec un effort accru. Ses connaissances s’arrêtent en mars 2026, certains domaines restant limités à janvier 2025. Fournissez des données actuelles ou utilisez les outils d’ancrage documentés lorsque la tâche dépend d’informations plus récentes. Vérifiez les citations de sources, les calculs et le code proposé à partir des entrées réelles et des résultats d’exécution. Le livrable final utile doit distinguer un constat appuyé d’une question non résolue, sans supposer qu’une réponse fluide établit le résultat demandé.
POST /v1/messagestext, imagetext| Champ | Type | Exigence | Valeurs et limites | Par défaut |
|---|---|---|---|---|
Champmodel | Typestring | ExigenceObligatoire | Valeurs et limites gemini-3.8-flash | 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 user, assistant | Par défaut— |
Champmessages[].content | Typestring|content_block[] | ExigenceObligatoire | Valeurs et limites | Par défaut— |
Champsystem | Typestring|content_block[] | ExigenceFacultatif | Valeurs et limites | Par défaut— |
Champmax_tokens | Typeinteger | ExigenceObligatoire | Valeurs et limites Minimum: 1 La limite s’applique à: Plafond exact du modèle ou de la fiche sélectionnés | Par défaut— |
Champstream | Typeboolean | ExigenceFacultatif | Valeurs et limites | Par défautfalse |
Champtemperature | Typenumber | ExigenceFacultatif | Valeurs et limites Model-specific | Par défaut— |
Champtop_p | Typenumber | ExigenceFacultatif | Valeurs et limites Model-specific | Par défaut— |
Champstop_sequences | Typestring[] | ExigenceFacultatif | Valeurs et limites Model-specific | Par défaut— |
Champtools | Typetool[] | ExigenceFacultatif | Valeurs et limites Model-specific | Par défaut— |
Champtools[].name | Typestring | ExigenceFacultatif | Valeurs et limites S’applique lorsque: Outil fourni | Par défaut— |
Champtools[].description | Typestring | ExigenceFacultatif | Valeurs et limites | Par défaut— |
Champtools[].input_schema | TypeJSON_schema | ExigenceFacultatif | Valeurs et limites | Par défaut— |
Champtool_choice | Typeobject | ExigenceFacultatif | Valeurs et limites Model-specific | Par défaut— |
Champthinking.type | Typestring | ExigenceFacultatif | Valeurs et limites Model-specific | Par défaut— |
Champthinking.budget_tokens | Typeinteger | ExigenceFacultatif | Valeurs et limites Model-specific | Par défaut— |
Champoutput_config.effort | Typestring | ExigenceFacultatif | Valeurs et limites Model-specific | Par défaut— |
Champmetadata | Typeobject | ExigenceFacultatif | Valeurs et limites | Par défaut— |
Champcache_control | Typeobject | ExigenceFacultatif | Valeurs et limites Model-specific | Par défaut— |
Texte · Texte UTF8
messages[].content ou bloc type=text
Texte + image
{type:image,source:{type:base64,media_type,data}} ou source type=url
| Paramètre | Contrat |
|---|---|
Paramètrematerial_types | Contrattext, image |
Paramètrerequired | Contratmodel, messages, max_tokens |
Paramètreoptional_controls | Contratnull |
Paramètrecontent_type | Contratapplication/json |
Paramètretext_file_material | ContratContenu UTF-8 réel inséré comme texte ; les ID de fichier/URLs nécessitent une prise en charge distincte et exacte |
Cycle de vie : exact retained published method
Les structures des méthodes et les ID sont exacts ; la capacité du fournisseur est distincte de l’admission des requêtes.
POST /v1/messagesAiloot 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 →
Les barèmes de référence du modèle ne modifient ni la sélection de méthode, ni les devis, ni les coûts. Les frais actifs utilisent les tarifs de la méthode Ailoot sélectionnée.
Associez chaque coût aux conditions indiquées. Utilisez un seul tarif pour chaque ensemble de configurations alternatives.
| Configuration | Barème tarifaire | Coût |
|---|---|---|
| ConfigurationOpenAI Chat · Tarifs de base des jetons | Barème tarifaireTarif de base | Coût Entrée · Jetons en entrée $0.003 / 1K jetons Sortie · Jetons en sortie $0.015 / 1K jetons Entrée · Lecture du cache $0.0003 / 1K jetons Entrée · Écriture dans le cache — / 1K jetons Entrée · Écriture dans le cache, 1 h — / 1K jetons |
| ConfigurationAnthropic Messages · Tarifs de base des jetons | Barème tarifaireTarif de base | Coût Entrée · Jetons en entrée $0.003 / 1K jetons Sortie · Jetons en sortie $0.015 / 1K jetons Entrée · Lecture du cache $0.0003 / 1K jetons Entrée · Écriture dans le cache — / 1K jetons Entrée · Écriture dans le cache, 1 h — / 1K jetons |
set -eu\n: "${AILOOT_API_KEY:?Set your Ailoot API key}"\n: "${AILOOT_TEXT_FILE:?Set your actual UTF-8 source-material file}"\nexport AILOOT_TEXT_FILE\npython3 - <<'PY_REQUEST'\nimport json,os\nfrom pathlib import Path\np=json.loads('{"model": "gemini-3.8-flash", "max_tokens": 1024, "messages": []}')\nf=Path(os.environ["AILOOT_TEXT_FILE"])\nif not f.is_file():raise SystemExit("Choose your actual UTF-8 source material")\ntext=f.read_text(encoding="utf-8")\nif not text.strip():raise SystemExit("Source material must contain text")\np["messages"]=[{"role":"user","content":"Summarize this material and quote supporting source passages.\\n\\n"+text}]\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/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\nprint(json.dumps(json.loads(Path("result.json").read_text()),ensure_ascii=False,indent=2))\nPY_RESULT\nset -eu\n: "${AILOOT_API_KEY:?Set your Ailoot API key}"\n: "${AILOOT_IMAGE_FILE:?Set your actual PNG JPEG or WebP image}"\nexport AILOOT_IMAGE_FILE\npython3 - <<'PY_REQUEST'\nimport json,os\nfrom pathlib import Path\np=json.loads('{"model": "gemini-3.8-flash", "max_tokens": 1024, "messages": [{"role": "user", "content": [{"type": "text", "text": "Read labels and numbers in this image; flag unreadable text."}]}]}')\nimport base64\nf=Path(os.environ["AILOOT_IMAGE_FILE"])\nif not f.is_file():raise SystemExit("Choose an actual PNG JPEG or WebP image")\nraw=f.read_bytes()\nmime="image/png" if raw.startswith(b"\\x89PNG\\r\\n\\x1a\\n") else "image/jpeg" if raw.startswith(b"\\xff\\xd8") else "image/webp" if raw[:4]==b"RIFF" and raw[8:12]==b"WEBP" else None\nif not mime:raise SystemExit("Use PNG JPEG or WebP")\nb64=base64.b64encode(raw).decode()\np["messages"][0]["content"].append({"type":"image","source":{"type":"base64","media_type":mime,"data":b64}})\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/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\nprint(json.dumps(json.loads(Path("result.json").read_text()),ensure_ascii=False,indent=2))\nPY_RESULT\nimport anthropic\nimport os\n\nif not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")\nclient = anthropic.Anthropic(base_url="https://api.ailoot.ai", api_key=os.environ["AILOOT_API_KEY"], max_retries=0)\nmsg = client.messages.create(\n model="gemini-3.8-flash",\n max_tokens=1024,\n messages=[{"role": "user", "content": "Explain the difference between an observation and a hypothesis in three sentences."}],\n)\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(msg.to_dict(mode="json"))\nimport Anthropic from "@anthropic-ai/sdk";\n\nif (!process.env.AILOOT_API_KEY?.trim()) throw new Error("Set AILOOT_API_KEY before making a request");\nconst client = new Anthropic({ baseURL: "https://api.ailoot.ai", apiKey: process.env.AILOOT_API_KEY, maxRetries: 0 });\nconst msg = await client.messages.create({\n model: "gemini-3.8-flash",\n max_tokens: 1024,\n messages: [{ role: "user", content: "Explain the difference between an observation and a hypothesis in three sentences." }],\n});\nimport { writeFileSync } from "node:fs";\n\nfunction saveResult(data, stem = "result") {\n writeFileSync(stem + ".json", JSON.stringify(data, null, 2));\n console.log(JSON.stringify(data, null, 2));\n const saveBlob = (encoded, suffix, label) => {\n const raw = Buffer.from(encoded, "base64");\n const ext = raw.subarray(0,8).equals(Buffer.from([137,80,78,71,13,10,26,10])) ? "png" : raw[0]===255 && raw[1]===216 ? "jpg" : raw.subarray(0,4).toString()==="RIFF" && raw.subarray(8,12).toString()==="WEBP" ? "webp" : suffix;\n const file = `${stem}-${label}.${ext}`;\n writeFileSync(file, raw); console.log("Saved", file);\n };\n for (const [i, block] of (data.content || []).entries()) console.log("Content", i, JSON.stringify(block));\n for (const choice of data.choices || []) console.log("Choice", choice.index, JSON.stringify(choice.message || choice.delta || {}));\n for (const [i, item] of (data.output || []).entries()) {\n console.log("Output", i, JSON.stringify(item));\n if (item.type === "image_generation_call" && item.result) saveBlob(item.result, item.output_format || "bin", `output-${i}`);\n }\n for (const [ci, candidate] of (data.candidates || []).entries()) {\n for (const [pi, part] of (candidate.content?.parts || []).entries()) {\n console.log("Candidate/part", ci, pi, JSON.stringify(part));\n const blob = part.inlineData || part.inline_data;\n if (blob?.data) {\n const mime = blob.mimeType || blob.mime_type;\n const suffix = ({"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"})[mime] || "bin";\n saveBlob(blob.data, suffix, `candidate-${ci}-part-${pi}`);\n }\n }\n }\n}\n\nsaveResult(msg);\nimport anthropic,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=anthropic.Anthropic(base_url="https://api.ailoot.ai",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.messages.stream(model='gemini-3.8-flash',max_tokens=1024,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_message()\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 tous les blocs de contenu, les signatures de raisonnement et les ID 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 ID et les en-têtes de requête/réponse. Aucune URL générique de récupération de tâche textuelle 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 éléments fournis ou valeur de paramètre invalides | Étape suivanteCorrigez les champs indiqués avant une nouvelle requête de création. |
Ailoot gemini-3.8-flash
Ailoot Ultra gemini-3.8-flash, google/gemini-3.8-flash, ~google/gemini-flash-latest
/chat/completions
google/gemini-3.8-flash, ~google/gemini-flash-latest, gemini-3.8-flash, gemini-3.8-flash
gemini-3.8-flashGemini 3.8 Flash est le modèle multimodal polyvalent de Google pour le génie logiciel soutenu, les agents et les tâches complexes de traitement des connaissances. Il accepte le texte, les images, l’audio, la vidéo et les PDF, renvoie du texte et offre un raisonnement faible, moyen ou élevé avec des outils et une sortie structurée. Ses limites d’entrée/sortie documentées sont de 1 048 576/65 536 jetons.
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.
Gemini 3.8 Flash est le modèle à sortie textuelle de Google pour le génie logiciel soutenu, les agents à plusieurs étapes et les flux de travail complexes sur les connaissances. Il s’appuie sur Gemini 3.7 Flash, avec des améliorations en génie logiciel et dans le travail sur les connaissances effectué par des agents. Il accepte le texte, les images, l’audio, la vidéo et les PDF, de sorte qu’une tâche peut combiner un objectif écrit avec les éléments réels nécessaires pour la résoudre. Le résultat utile est une modification de code, une analyse expliquée, une réponse écrite ou un enregistrement structuré.
Pour une tâche de programmation, fournissez l’exigence, les fichiers pertinents, le comportement observé et les contraintes à préserver. Une capture d’écran peut établir l’interface souhaitée, tandis que des journaux ou un exemple reproductible montrent la défaillance. Pour une tâche de débogage, demandez au modèle de retracer un écart entre l’état visible d’un formulaire et sa valeur enregistrée, d’identifier le chemin de code responsable et de proposer une correction ciblée. Gardez le livrable final souhaité clair afin qu’une séquence d’investigation et d’utilisation d’outils plus longue conserve une condition de fin précise.
Pour les travaux de longue durée, utilisez des étapes de raisonnement plus petites, des appels d’outils itératifs et des vérifications des résultats intermédiaires. Les niveaux de réflexion faible, moyen et élevé contrôlent la quantité de raisonnement; le niveau moyen est la valeur par défaut documentée. Le niveau faible convient à une ébauche rapide ou à une analyse délimitée, tandis que le niveau élevé vise les mathématiques difficiles, la programmation ou les tâches à plusieurs étapes. Gemini 3.8 Flash ne prend pas en charge le niveau de réflexion minimal. Une tâche de débogage soutenue et une simple extraction de champs demandent donc des choix de raisonnement différents plutôt que le même réglage pour toutes les requêtes.
Les outils documentés comprennent les appels de fonctions, l’exécution de code, la recherche de fichiers, l’ancrage par recherche, l’ancrage avec Google Maps et le contexte URL, Computer Use étant présenté comme une capacité en préversion. Les sorties structurées définissent un résultat lisible par machine. Les fonctions doivent avoir une finalité claire et des paramètres définis : le modèle peut demander une fonction, tandis que l’application connectée réalise l’opération et renvoie son résultat. Préservez l’identité des fonctions et les éléments réellement renvoyés d’un tour à l’autre. Une réponse finale utile explique quelles données probantes appuient la correction proposée ou la valeur extraite.
Le guide de migration 3.8 utilise des contrôles de niveau de réflexion à la place de l’ancienne configuration du budget de raisonnement et conseille de retirer les paramètres d’échantillonnage obsolètes et les tours de modèle préremplis. Il exige aussi de préserver les signatures de pensée dans le flux sans état pertinent et de faire correspondre les réponses de fonctions à leurs appels par identité et nom. Ces détails comptent lorsqu’on poursuit une tâche à plusieurs étapes : le tour suivant a besoin du contexte réel antérieur plutôt que d’un récit réécrit qui perd le résultat d’outil ou la signature. Gardez la question et la sortie demandée explicites dans le nouveau tour utilisateur.
Pour le travail multimodal sur les connaissances, identifiez les pages de document, le graphique, l’intervalle audio ou l’événement vidéo pertinents et indiquez comment ils doivent contribuer à la réponse. Une comparaison de documents peut demander un tableau des différences avec des passages sources; une question sur un graphique peut demander les valeurs visibles et la conclusion qu’elles appuient. Une analyse vidéo peut demander une description des événements qui justifient un constat. Le modèle renvoie du texte à partir de ces entrées. Les images générées, la parole et les interactions audio en direct relèvent de profils de modèles distincts.
Ses limites Gemini API sont de 1 048 576 jetons d’entrée et de 65 536 jetons de sortie, ce qui correspond au contexte natif allant jusqu’à 1M et à la sortie textuelle de 64K du modèle. Les instructions, l’historique de conversation et les médias fournis consomment le contexte d’entrée, et le raisonnement ou un long livrable final doivent respecter la capacité de sortie documentée. Google indique aussi la mise en cache, le traitement par lots, Flex et Priority pour ce profil du producteur. Pour des éléments indépendants, conservez un identifiant stable et un format de sortie explicite afin que chaque résultat reste lié à sa source.
Les limites possibles comprennent des hallucinations, des lenteurs ou des dépassements de délai occasionnels et une consommation plus élevée de jetons avec un effort accru. Ses connaissances s’arrêtent en mars 2026, certains domaines restant limités à janvier 2025. Fournissez des données actuelles ou utilisez les outils d’ancrage documentés lorsque la tâche dépend d’informations plus récentes. Vérifiez les citations de sources, les calculs et le code proposé à partir des entrées réelles et des résultats d’exécution. Le livrable final utile doit distinguer un constat appuyé d’une question non résolue, sans supposer qu’une réponse fluide établit le résultat demandé.
POST /v1beta/models/{model}:generateContenttext, imagetext| Champ | Type | Exigence | Valeurs et limites | Par défaut |
|---|---|---|---|---|
Champpath.model | Typestring | ExigenceObligatoire | Valeurs et limites gemini-3.8-flash | Par défaut— |
Champcontents | Typecontent[] | ExigenceObligatoire | Valeurs et limites Nombre minimal d’éléments: 1 | Par défaut— |
Champcontents[].role | Typestring | ExigenceFacultatif | Valeurs et limites user, model | Par défaut— |
Champcontents[].parts | Typepart[] | ExigenceObligatoire | Valeurs et limites | Par défaut— |
ChampsystemInstruction | Typecontent | ExigenceFacultatif | Valeurs et limites | Par défaut— |
ChampgenerationConfig.maxOutputTokens | Typeinteger | ExigenceFacultatif | Valeurs et limites Minimum: 1 Model-specific | Par défaut— |
ChampgenerationConfig.temperature | Typenumber | ExigenceFacultatif | Valeurs et limites Model-specific | Par défaut— |
ChampgenerationConfig.topP | Typenumber | ExigenceFacultatif | Valeurs et limites Model-specific | Par défaut— |
ChampgenerationConfig.topK | Typeinteger | ExigenceFacultatif | Valeurs et limites Model-specific | Par défaut— |
ChampgenerationConfig.stopSequences | Typestring[] | ExigenceFacultatif | Valeurs et limites Model-specific | Par défaut— |
ChampgenerationConfig.thinkingConfig.includeThoughts | Typeboolean | ExigenceFacultatif | Valeurs et limites Model-specific | Par défaut— |
ChampgenerationConfig.thinkingConfig.thinkingBudget | Typeinteger | ExigenceFacultatif | Valeurs et limites Model-specific | Par défaut— |
Champtools[].functionDeclarations | Typefunction_declaration[] | ExigenceFacultatif | Valeurs et limites Model-specific | Par défaut— |
ChamptoolConfig.functionCallingConfig.mode | Typestring | ExigenceFacultatif | Valeurs et limites Model-specific | Par défaut— |
ChampsafetySettings | Typeobject[] | ExigenceFacultatif | Valeurs et limites Model-specific | Par défaut— |
ChampsessionId | Typestring | ExigenceFacultatif | Valeurs et limites | Par défaut— |
Texte · Texte UTF8
contents[].parts[].text
Texte + image
parts[].inlineData={mimeType,data}
| Paramètre | Contrat |
|---|---|
Paramètrematerial_types | Contrattext, image |
Paramètrerequired | Contratcontents |
Paramètreoptional_controls | Contratnull |
Paramètrecontent_type | Contratapplication/json |
Paramètretext_file_material | ContratContenu UTF-8 réel inséré comme texte ; les ID de fichier/URLs nécessitent une prise en charge distincte et exacte |
Cycle de vie : exact retained published method
Les structures des méthodes et les ID sont exacts ; la capacité du fournisseur est distincte de l’admission des requêtes.
POST /v1beta/models/{model}:generateContentAiloot 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 →
Les barèmes de référence du modèle ne modifient ni la sélection de méthode, ni les devis, ni les coûts. Les frais actifs utilisent les tarifs de la méthode Ailoot sélectionnée.
Associez chaque coût aux conditions indiquées. Utilisez un seul tarif pour chaque ensemble de configurations alternatives.
| Configuration | Barème tarifaire | Coût |
|---|---|---|
| ConfigurationOpenAI Chat · Tarifs de base des jetons | Barème tarifaireTarif de base | Coût Entrée · Jetons en entrée $0.003 / 1K jetons Sortie · Jetons en sortie $0.015 / 1K jetons Entrée · Lecture du cache $0.0003 / 1K jetons Entrée · Écriture dans le cache — / 1K jetons Entrée · Écriture dans le cache, 1 h — / 1K jetons |
| ConfigurationAnthropic Messages · Tarifs de base des jetons | Barème tarifaireTarif de base | Coût Entrée · Jetons en entrée $0.003 / 1K jetons Sortie · Jetons en sortie $0.015 / 1K jetons Entrée · Lecture du cache $0.0003 / 1K jetons Entrée · Écriture dans le cache — / 1K jetons Entrée · Écriture dans le cache, 1 h — / 1K jetons |
set -eu\n: "${AILOOT_API_KEY:?Set your Ailoot API key}"\n: "${AILOOT_TEXT_FILE:?Set your actual UTF-8 source-material file}"\nexport AILOOT_TEXT_FILE\npython3 - <<'PY_REQUEST'\nimport json,os\nfrom pathlib import Path\np=json.loads('{"contents": []}')\nf=Path(os.environ["AILOOT_TEXT_FILE"])\nif not f.is_file():raise SystemExit("Choose your actual UTF-8 source material")\ntext=f.read_text(encoding="utf-8")\nif not text.strip():raise SystemExit("Source material must contain text")\np["contents"]=[{"role":"user","parts":[{"text":"Summarize this material and quote supporting source passages.\\n\\n"+text}]}]\nPath("request.json").write_text(json.dumps(p,ensure_ascii=False))\nPY_REQUEST\ncurl --fail-with-body --silent --show-error https://api.ailoot.ai/v1beta/models/gemini-3.8-flash:generateContent \\\n -H "x-goog-api-key: $AILOOT_API_KEY" -H 'Content-Type: application/json' \\\n --data-binary @request.json -D response-headers.txt -o result.json\npython3 - <<'PY_RESULT'\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(json.loads(Path("result.json").read_text(encoding="utf-8")))\nPY_RESULT\nset -eu\n: "${AILOOT_API_KEY:?Set your Ailoot API key}"\n: "${AILOOT_IMAGE_FILE:?Set your actual PNG JPEG or WebP image}"\nexport AILOOT_IMAGE_FILE\npython3 - <<'PY_REQUEST'\nimport json,os\nfrom pathlib import Path\np=json.loads('{"contents": [{"role": "user", "parts": [{"text": "Read labels and numbers in this image; flag unreadable text."}]}]}')\nimport base64\nf=Path(os.environ["AILOOT_IMAGE_FILE"])\nif not f.is_file():raise SystemExit("Choose an actual PNG JPEG or WebP image")\nraw=f.read_bytes()\nmime="image/png" if raw.startswith(b"\\x89PNG\\r\\n\\x1a\\n") else "image/jpeg" if raw.startswith(b"\\xff\\xd8") else "image/webp" if raw[:4]==b"RIFF" and raw[8:12]==b"WEBP" else None\nif not mime:raise SystemExit("Use PNG JPEG or WebP")\nb64=base64.b64encode(raw).decode()\np["contents"][0]["parts"].append({"inlineData":{"mimeType":mime,"data":b64}})\nPath("request.json").write_text(json.dumps(p,ensure_ascii=False))\nPY_REQUEST\ncurl --fail-with-body --silent --show-error https://api.ailoot.ai/v1beta/models/gemini-3.8-flash:generateContent \\\n -H "x-goog-api-key: $AILOOT_API_KEY" -H 'Content-Type: application/json' \\\n --data-binary @request.json -D response-headers.txt -o result.json\npython3 - <<'PY_RESULT'\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(json.loads(Path("result.json").read_text(encoding="utf-8")))\nPY_RESULT\nfrom google import genai\nfrom google.genai import types\nimport os\n\nif not os.environ.get("AILOOT_API_KEY", "").strip(): raise SystemExit("Set AILOOT_API_KEY before making a request")\nclient = genai.Client(\n api_key=os.environ["AILOOT_API_KEY"],\n http_options=types.HttpOptions(base_url="https://api.ailoot.ai"),\n)\nresp = client.models.generate_content(model="gemini-3.8-flash", contents="Explain the difference between an observation and a hypothesis 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(resp.to_json_dict())\nimport { GoogleGenAI } from "@google/genai";\n\nif (!process.env.AILOOT_API_KEY?.trim()) throw new Error("Set AILOOT_API_KEY before making a request");\nconst ai = new GoogleGenAI({ apiKey: process.env.AILOOT_API_KEY, httpOptions: { baseUrl: "https://api.ailoot.ai" } });\nconst resp = await ai.models.generateContent({ model: "gemini-3.8-flash", contents: "Explain the difference between an observation and a hypothesis in three sentences." });\nimport { writeFileSync } from "node:fs";\n\nfunction saveResult(data, stem = "result") {\n writeFileSync(stem + ".json", JSON.stringify(data, null, 2));\n console.log(JSON.stringify(data, null, 2));\n const saveBlob = (encoded, suffix, label) => {\n const raw = Buffer.from(encoded, "base64");\n const ext = raw.subarray(0,8).equals(Buffer.from([137,80,78,71,13,10,26,10])) ? "png" : raw[0]===255 && raw[1]===216 ? "jpg" : raw.subarray(0,4).toString()==="RIFF" && raw.subarray(8,12).toString()==="WEBP" ? "webp" : suffix;\n const file = `${stem}-${label}.${ext}`;\n writeFileSync(file, raw); console.log("Saved", file);\n };\n for (const [i, block] of (data.content || []).entries()) console.log("Content", i, JSON.stringify(block));\n for (const choice of data.choices || []) console.log("Choice", choice.index, JSON.stringify(choice.message || choice.delta || {}));\n for (const [i, item] of (data.output || []).entries()) {\n console.log("Output", i, JSON.stringify(item));\n if (item.type === "image_generation_call" && item.result) saveBlob(item.result, item.output_format || "bin", `output-${i}`);\n }\n for (const [ci, candidate] of (data.candidates || []).entries()) {\n for (const [pi, part] of (candidate.content?.parts || []).entries()) {\n console.log("Candidate/part", ci, pi, JSON.stringify(part));\n const blob = part.inlineData || part.inline_data;\n if (blob?.data) {\n const mime = blob.mimeType || blob.mime_type;\n const suffix = ({"image/png":"png", "image/jpeg":"jpg", "image/webp":"webp", "audio/wav":"wav", "audio/mpeg":"mp3", "video/mp4":"mp4"})[mime] || "bin";\n saveBlob(blob.data, suffix, `candidate-${ci}-part-${pi}`);\n }\n }\n }\n}\n\nsaveResult(resp);\nfrom google import genai\nfrom google.genai import types\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=genai.Client(api_key=os.environ["AILOOT_API_KEY"],http_options=types.HttpOptions(base_url="https://api.ailoot.ai"))\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\ncount=0\nwith Path("stream-events.jsonl").open("w",encoding="utf-8") as log:\n for chunk in client.models.generate_content_stream(model='gemini-3.8-flash',contents="Explain observations and hypotheses in three sentences."):\n payload=chunk.to_json_dict()\n log.write(json.dumps(payload,ensure_ascii=False)+"\\n"); log.flush()\n save_result(payload,"stream-chunk-"+str(count))\n count+=1\njson ou diffusion en continu prise en charge
Conservez chaque réponse, fichier et partie de contenu renvoyés dans leur intégralité.
Conservez tous les candidats et toutes les parties, y compris les appels de fonctions, les signatures de raisonnement et les données d’utilisation ; assemblez les fragments du flux dans l’ordre.
Conservez les ID et les en-têtes de requête/réponse. Aucune URL générique de récupération de tâche textuelle n’est fournie.
| Champ | Type |
|---|---|
ChampresponseId | Typestring |
ChampmodelVersion | Typestring |
Champcandidates[].content.parts[] | Typetext|inlineData|functionCall|other part |
Champcandidates[].finishReason | Typestring |
ChampusageMetadata | Typeobject |
| Réponse | Condition | Étape suivante |
|---|---|---|
Réponse400 · invalid_request_error | ConditionChamps obligatoires, représentation des éléments fournis ou valeur de paramètre invalides | Étape suivanteCorrigez les champs indiqués avant une nouvelle requête de création. |
Ailoot gemini-3.8-flash
Ailoot Ultra gemini-3.8-flash, google/gemini-3.8-flash, ~google/gemini-flash-latest
/chat/completions
google/gemini-3.8-flash, ~google/gemini-flash-latest, gemini-3.8-flash, gemini-3.8-flash
gemini-3.8-flashGemini 3.8 Flash est le modèle multimodal polyvalent de Google pour le génie logiciel soutenu, les agents et les tâches complexes de traitement des connaissances. Il accepte le texte, les images, l’audio, la vidéo et les PDF, renvoie du texte et offre un raisonnement faible, moyen ou élevé avec des outils et une sortie structurée. Ses limites d’entrée/sortie documentées sont de 1 048 576/65 536 jetons.
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.
Gemini 3.8 Flash est le modèle à sortie textuelle de Google pour le génie logiciel soutenu, les agents à plusieurs étapes et les flux de travail complexes sur les connaissances. Il s’appuie sur Gemini 3.7 Flash, avec des améliorations en génie logiciel et dans le travail sur les connaissances effectué par des agents. Il accepte le texte, les images, l’audio, la vidéo et les PDF, de sorte qu’une tâche peut combiner un objectif écrit avec les éléments réels nécessaires pour la résoudre. Le résultat utile est une modification de code, une analyse expliquée, une réponse écrite ou un enregistrement structuré.
Pour une tâche de programmation, fournissez l’exigence, les fichiers pertinents, le comportement observé et les contraintes à préserver. Une capture d’écran peut établir l’interface souhaitée, tandis que des journaux ou un exemple reproductible montrent la défaillance. Pour une tâche de débogage, demandez au modèle de retracer un écart entre l’état visible d’un formulaire et sa valeur enregistrée, d’identifier le chemin de code responsable et de proposer une correction ciblée. Gardez le livrable final souhaité clair afin qu’une séquence d’investigation et d’utilisation d’outils plus longue conserve une condition de fin précise.
Pour les travaux de longue durée, utilisez des étapes de raisonnement plus petites, des appels d’outils itératifs et des vérifications des résultats intermédiaires. Les niveaux de réflexion faible, moyen et élevé contrôlent la quantité de raisonnement; le niveau moyen est la valeur par défaut documentée. Le niveau faible convient à une ébauche rapide ou à une analyse délimitée, tandis que le niveau élevé vise les mathématiques difficiles, la programmation ou les tâches à plusieurs étapes. Gemini 3.8 Flash ne prend pas en charge le niveau de réflexion minimal. Une tâche de débogage soutenue et une simple extraction de champs demandent donc des choix de raisonnement différents plutôt que le même réglage pour toutes les requêtes.
Les outils documentés comprennent les appels de fonctions, l’exécution de code, la recherche de fichiers, l’ancrage par recherche, l’ancrage avec Google Maps et le contexte URL, Computer Use étant présenté comme une capacité en préversion. Les sorties structurées définissent un résultat lisible par machine. Les fonctions doivent avoir une finalité claire et des paramètres définis : le modèle peut demander une fonction, tandis que l’application connectée réalise l’opération et renvoie son résultat. Préservez l’identité des fonctions et les éléments réellement renvoyés d’un tour à l’autre. Une réponse finale utile explique quelles données probantes appuient la correction proposée ou la valeur extraite.
Le guide de migration 3.8 utilise des contrôles de niveau de réflexion à la place de l’ancienne configuration du budget de raisonnement et conseille de retirer les paramètres d’échantillonnage obsolètes et les tours de modèle préremplis. Il exige aussi de préserver les signatures de pensée dans le flux sans état pertinent et de faire correspondre les réponses de fonctions à leurs appels par identité et nom. Ces détails comptent lorsqu’on poursuit une tâche à plusieurs étapes : le tour suivant a besoin du contexte réel antérieur plutôt que d’un récit réécrit qui perd le résultat d’outil ou la signature. Gardez la question et la sortie demandée explicites dans le nouveau tour utilisateur.
Pour le travail multimodal sur les connaissances, identifiez les pages de document, le graphique, l’intervalle audio ou l’événement vidéo pertinents et indiquez comment ils doivent contribuer à la réponse. Une comparaison de documents peut demander un tableau des différences avec des passages sources; une question sur un graphique peut demander les valeurs visibles et la conclusion qu’elles appuient. Une analyse vidéo peut demander une description des événements qui justifient un constat. Le modèle renvoie du texte à partir de ces entrées. Les images générées, la parole et les interactions audio en direct relèvent de profils de modèles distincts.
Ses limites Gemini API sont de 1 048 576 jetons d’entrée et de 65 536 jetons de sortie, ce qui correspond au contexte natif allant jusqu’à 1M et à la sortie textuelle de 64K du modèle. Les instructions, l’historique de conversation et les médias fournis consomment le contexte d’entrée, et le raisonnement ou un long livrable final doivent respecter la capacité de sortie documentée. Google indique aussi la mise en cache, le traitement par lots, Flex et Priority pour ce profil du producteur. Pour des éléments indépendants, conservez un identifiant stable et un format de sortie explicite afin que chaque résultat reste lié à sa source.
Les limites possibles comprennent des hallucinations, des lenteurs ou des dépassements de délai occasionnels et une consommation plus élevée de jetons avec un effort accru. Ses connaissances s’arrêtent en mars 2026, certains domaines restant limités à janvier 2025. Fournissez des données actuelles ou utilisez les outils d’ancrage documentés lorsque la tâche dépend d’informations plus récentes. Vérifiez les citations de sources, les calculs et le code proposé à partir des entrées réelles et des résultats d’exécution. Le livrable final utile doit distinguer un constat appuyé d’une question non résolue, sans supposer qu’une réponse fluide établit le résultat demandé.
POST /v1/chat/completionstexttext| Champ | Type | Exigence | Valeurs et limites | Par défaut |
|---|---|---|---|---|
Champmodel | Typestring | ExigenceObligatoire | Valeurs et limites gemini-3.8-flash | 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 Model-specific | Par défaut— |
Champmessages[].content | Typestring | ExigenceFacultatif | Valeurs et limites S’applique lorsque: Conversation textuelle | Par défaut— |
Champstream | Typeboolean | ExigenceFacultatif | Valeurs et limites | Par défautfalse |
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é comme texte littéral ; aucun ID de fichier déduit |
Paramètreoptional_controls | Contratstream |
Paramètrecontrol_scope | ContratConversation textuelle ; stream est un booléen dont la valeur par défaut est false. |
Paramètreoutput_modalities | Contrattext |
Paramètrehosted_operations | Contratfalse |
Paramètremultimodal_input_binding | Contratnull |
Alias de méthode : /chat/completions
Cycle de vie : synchronous_or_streamed
Envoyez l’ID 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/objet 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 jetons | Barème tarifaireTarif de base | Coût Entrée · Jetons en entrée $0.003 / 1K jetons Sortie · Jetons en sortie $0.015 / 1K jetons Entrée · Lecture du cache $0.0003 / 1K jetons Entrée · Écriture dans le cache — / 1K jetons Entrée · Écriture dans le cache, 1 h — / 1K jetons |
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":"gemini-3.8-flash","messages":[{"role":"user","content":"hello"}],"stream":false}')\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="gemini-3.8-flash", messages=[{"role":"user","content":"hello"}], stream=False)\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"))\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, et conservez le motif final d’arrêt et les données d’utilisation.
Conservez les ID et les en-têtes de requête/réponse. Aucune URL générique de récupération de tâche textuelle 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 éléments fournis ou valeur de paramètre invalides | Étape suivanteCorrigez les champs indiqués avant une nouvelle requête de création. |
Ailoot gemini-3.8-flash
Ailoot Ultra gemini-3.8-flash, google/gemini-3.8-flash, ~google/gemini-flash-latest
/chat/completions
google/gemini-3.8-flash, ~google/gemini-flash-latest, gemini-3.8-flash, gemini-3.8-flash
gemini-3.8-flashGemini 3.8 Flash est le modèle multimodal polyvalent de Google pour le génie logiciel soutenu, les agents et les tâches complexes de traitement des connaissances. Il accepte le texte, les images, l’audio, la vidéo et les PDF, renvoie du texte et offre un raisonnement faible, moyen ou élevé avec des outils et une sortie structurée. Ses limites d’entrée/sortie documentées sont de 1 048 576/65 536 jetons.
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.
Gemini 3.8 Flash est le modèle à sortie textuelle de Google pour le génie logiciel soutenu, les agents à plusieurs étapes et les flux de travail complexes sur les connaissances. Il s’appuie sur Gemini 3.7 Flash, avec des améliorations en génie logiciel et dans le travail sur les connaissances effectué par des agents. Il accepte le texte, les images, l’audio, la vidéo et les PDF, de sorte qu’une tâche peut combiner un objectif écrit avec les éléments réels nécessaires pour la résoudre. Le résultat utile est une modification de code, une analyse expliquée, une réponse écrite ou un enregistrement structuré.
Pour une tâche de programmation, fournissez l’exigence, les fichiers pertinents, le comportement observé et les contraintes à préserver. Une capture d’écran peut établir l’interface souhaitée, tandis que des journaux ou un exemple reproductible montrent la défaillance. Pour une tâche de débogage, demandez au modèle de retracer un écart entre l’état visible d’un formulaire et sa valeur enregistrée, d’identifier le chemin de code responsable et de proposer une correction ciblée. Gardez le livrable final souhaité clair afin qu’une séquence d’investigation et d’utilisation d’outils plus longue conserve une condition de fin précise.
Pour les travaux de longue durée, utilisez des étapes de raisonnement plus petites, des appels d’outils itératifs et des vérifications des résultats intermédiaires. Les niveaux de réflexion faible, moyen et élevé contrôlent la quantité de raisonnement; le niveau moyen est la valeur par défaut documentée. Le niveau faible convient à une ébauche rapide ou à une analyse délimitée, tandis que le niveau élevé vise les mathématiques difficiles, la programmation ou les tâches à plusieurs étapes. Gemini 3.8 Flash ne prend pas en charge le niveau de réflexion minimal. Une tâche de débogage soutenue et une simple extraction de champs demandent donc des choix de raisonnement différents plutôt que le même réglage pour toutes les requêtes.
Les outils documentés comprennent les appels de fonctions, l’exécution de code, la recherche de fichiers, l’ancrage par recherche, l’ancrage avec Google Maps et le contexte URL, Computer Use étant présenté comme une capacité en préversion. Les sorties structurées définissent un résultat lisible par machine. Les fonctions doivent avoir une finalité claire et des paramètres définis : le modèle peut demander une fonction, tandis que l’application connectée réalise l’opération et renvoie son résultat. Préservez l’identité des fonctions et les éléments réellement renvoyés d’un tour à l’autre. Une réponse finale utile explique quelles données probantes appuient la correction proposée ou la valeur extraite.
Le guide de migration 3.8 utilise des contrôles de niveau de réflexion à la place de l’ancienne configuration du budget de raisonnement et conseille de retirer les paramètres d’échantillonnage obsolètes et les tours de modèle préremplis. Il exige aussi de préserver les signatures de pensée dans le flux sans état pertinent et de faire correspondre les réponses de fonctions à leurs appels par identité et nom. Ces détails comptent lorsqu’on poursuit une tâche à plusieurs étapes : le tour suivant a besoin du contexte réel antérieur plutôt que d’un récit réécrit qui perd le résultat d’outil ou la signature. Gardez la question et la sortie demandée explicites dans le nouveau tour utilisateur.
Pour le travail multimodal sur les connaissances, identifiez les pages de document, le graphique, l’intervalle audio ou l’événement vidéo pertinents et indiquez comment ils doivent contribuer à la réponse. Une comparaison de documents peut demander un tableau des différences avec des passages sources; une question sur un graphique peut demander les valeurs visibles et la conclusion qu’elles appuient. Une analyse vidéo peut demander une description des événements qui justifient un constat. Le modèle renvoie du texte à partir de ces entrées. Les images générées, la parole et les interactions audio en direct relèvent de profils de modèles distincts.
Ses limites Gemini API sont de 1 048 576 jetons d’entrée et de 65 536 jetons de sortie, ce qui correspond au contexte natif allant jusqu’à 1M et à la sortie textuelle de 64K du modèle. Les instructions, l’historique de conversation et les médias fournis consomment le contexte d’entrée, et le raisonnement ou un long livrable final doivent respecter la capacité de sortie documentée. Google indique aussi la mise en cache, le traitement par lots, Flex et Priority pour ce profil du producteur. Pour des éléments indépendants, conservez un identifiant stable et un format de sortie explicite afin que chaque résultat reste lié à sa source.
Les limites possibles comprennent des hallucinations, des lenteurs ou des dépassements de délai occasionnels et une consommation plus élevée de jetons avec un effort accru. Ses connaissances s’arrêtent en mars 2026, certains domaines restant limités à janvier 2025. Fournissez des données actuelles ou utilisez les outils d’ancrage documentés lorsque la tâche dépend d’informations plus récentes. Vérifiez les citations de sources, les calculs et le code proposé à partir des entrées réelles et des résultats d’exécution. Le livrable final utile doit distinguer un constat appuyé d’une question non résolue, sans supposer qu’une réponse fluide établit le résultat demandé.
POST /v1/messagestextjson, sse| Champ | Type | Exigence | Valeurs et limites | Par défaut |
|---|---|---|---|---|
Champmodel | Typestring | ExigenceObligatoire | Valeurs et limites gemini-3.8-flash | 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 jetons | Barème tarifaireTarif de base | Coût Entrée · Jetons en entrée $0.003 / 1K jetons Sortie · Jetons en sortie $0.015 / 1K jetons Entrée · Lecture du cache $0.0003 / 1K jetons Entrée · Écriture dans le cache — / 1K jetons Entrée · Écriture dans le cache, 1 h — / 1K jetons |
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": "gemini-3.8-flash",\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': 'gemini-3.8-flash', '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': 'gemini-3.8-flash', '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 ID 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 ID et les en-têtes de requête/réponse. Aucune URL générique de récupération de tâche textuelle 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 éléments fournis ou valeur de paramètre invalides | Étape suivanteCorrigez les champs indiqués avant une nouvelle requête de création. |
Ailoot gemini-3.8-flash
Ailoot Ultra gemini-3.8-flash, google/gemini-3.8-flash, ~google/gemini-flash-latest
/chat/completions
google/gemini-3.8-flash, ~google/gemini-flash-latest, gemini-3.8-flash, gemini-3.8-flash
google/gemini-3.8-flashGemini 3.8 Flash est le modèle multimodal polyvalent de Google pour le génie logiciel soutenu, les agents et les tâches complexes de traitement des connaissances. Il accepte le texte, les images, l’audio, la vidéo et les PDF, renvoie du texte et offre un raisonnement faible, moyen ou élevé avec des outils et une sortie structurée. Ses limites d’entrée/sortie documentées sont de 1 048 576/65 536 jetons.
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.
Gemini 3.8 Flash est le modèle à sortie textuelle de Google pour le génie logiciel soutenu, les agents à plusieurs étapes et les flux de travail complexes sur les connaissances. Il s’appuie sur Gemini 3.7 Flash, avec des améliorations en génie logiciel et dans le travail sur les connaissances effectué par des agents. Il accepte le texte, les images, l’audio, la vidéo et les PDF, de sorte qu’une tâche peut combiner un objectif écrit avec les éléments réels nécessaires pour la résoudre. Le résultat utile est une modification de code, une analyse expliquée, une réponse écrite ou un enregistrement structuré.
Pour une tâche de programmation, fournissez l’exigence, les fichiers pertinents, le comportement observé et les contraintes à préserver. Une capture d’écran peut établir l’interface souhaitée, tandis que des journaux ou un exemple reproductible montrent la défaillance. Pour une tâche de débogage, demandez au modèle de retracer un écart entre l’état visible d’un formulaire et sa valeur enregistrée, d’identifier le chemin de code responsable et de proposer une correction ciblée. Gardez le livrable final souhaité clair afin qu’une séquence d’investigation et d’utilisation d’outils plus longue conserve une condition de fin précise.
Pour les travaux de longue durée, utilisez des étapes de raisonnement plus petites, des appels d’outils itératifs et des vérifications des résultats intermédiaires. Les niveaux de réflexion faible, moyen et élevé contrôlent la quantité de raisonnement; le niveau moyen est la valeur par défaut documentée. Le niveau faible convient à une ébauche rapide ou à une analyse délimitée, tandis que le niveau élevé vise les mathématiques difficiles, la programmation ou les tâches à plusieurs étapes. Gemini 3.8 Flash ne prend pas en charge le niveau de réflexion minimal. Une tâche de débogage soutenue et une simple extraction de champs demandent donc des choix de raisonnement différents plutôt que le même réglage pour toutes les requêtes.
Les outils documentés comprennent les appels de fonctions, l’exécution de code, la recherche de fichiers, l’ancrage par recherche, l’ancrage avec Google Maps et le contexte URL, Computer Use étant présenté comme une capacité en préversion. Les sorties structurées définissent un résultat lisible par machine. Les fonctions doivent avoir une finalité claire et des paramètres définis : le modèle peut demander une fonction, tandis que l’application connectée réalise l’opération et renvoie son résultat. Préservez l’identité des fonctions et les éléments réellement renvoyés d’un tour à l’autre. Une réponse finale utile explique quelles données probantes appuient la correction proposée ou la valeur extraite.
Le guide de migration 3.8 utilise des contrôles de niveau de réflexion à la place de l’ancienne configuration du budget de raisonnement et conseille de retirer les paramètres d’échantillonnage obsolètes et les tours de modèle préremplis. Il exige aussi de préserver les signatures de pensée dans le flux sans état pertinent et de faire correspondre les réponses de fonctions à leurs appels par identité et nom. Ces détails comptent lorsqu’on poursuit une tâche à plusieurs étapes : le tour suivant a besoin du contexte réel antérieur plutôt que d’un récit réécrit qui perd le résultat d’outil ou la signature. Gardez la question et la sortie demandée explicites dans le nouveau tour utilisateur.
Pour le travail multimodal sur les connaissances, identifiez les pages de document, le graphique, l’intervalle audio ou l’événement vidéo pertinents et indiquez comment ils doivent contribuer à la réponse. Une comparaison de documents peut demander un tableau des différences avec des passages sources; une question sur un graphique peut demander les valeurs visibles et la conclusion qu’elles appuient. Une analyse vidéo peut demander une description des événements qui justifient un constat. Le modèle renvoie du texte à partir de ces entrées. Les images générées, la parole et les interactions audio en direct relèvent de profils de modèles distincts.
Ses limites Gemini API sont de 1 048 576 jetons d’entrée et de 65 536 jetons de sortie, ce qui correspond au contexte natif allant jusqu’à 1M et à la sortie textuelle de 64K du modèle. Les instructions, l’historique de conversation et les médias fournis consomment le contexte d’entrée, et le raisonnement ou un long livrable final doivent respecter la capacité de sortie documentée. Google indique aussi la mise en cache, le traitement par lots, Flex et Priority pour ce profil du producteur. Pour des éléments indépendants, conservez un identifiant stable et un format de sortie explicite afin que chaque résultat reste lié à sa source.
Les limites possibles comprennent des hallucinations, des lenteurs ou des dépassements de délai occasionnels et une consommation plus élevée de jetons avec un effort accru. Ses connaissances s’arrêtent en mars 2026, certains domaines restant limités à janvier 2025. Fournissez des données actuelles ou utilisez les outils d’ancrage documentés lorsque la tâche dépend d’informations plus récentes. Vérifiez les citations de sources, les calculs et le code proposé à partir des entrées réelles et des résultats d’exécution. Le livrable final utile doit distinguer un constat appuyé d’une question non résolue, sans supposer qu’une réponse fluide établit le résultat demandé.
POST /v1/chat/completionstexttext| Champ | Type | Exigence | Valeurs et limites | Par défaut |
|---|---|---|---|---|
Champmodel | Typestring | ExigenceObligatoire | Valeurs et limites google/gemini-3.8-flash | 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. Model-specific | 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’ID 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 Model-specific | Par défaut— |
Champmax_tokens | Typeinteger | ExigenceFacultatif | Valeurs et limites Minimum: 1 Model-specific | Par défaut— |
Champmax_completion_tokens | Typeinteger | ExigenceFacultatif | Valeurs et limites Minimum: 1 Model-specific | Par défaut— |
Champstream | Typeboolean | ExigenceFacultatif | Valeurs et limites | Par défautfalse |
Champstream_options.include_usage | Typeboolean | ExigenceFacultatif | Valeurs et limites Model-specific | Par défaut— |
Champtemperature | Typenumber | ExigenceFacultatif | Valeurs et limites Model-specific | Par défaut— |
Champtop_p | Typenumber | ExigenceFacultatif | Valeurs et limites Model-specific | Par défaut— |
Champstop | Typestring|string[] | ExigenceFacultatif | Valeurs et limites Model-specific | Par défaut— |
Champtools | Typefunction_tool[] | ExigenceFacultatif | Valeurs et limites Model-specific | Par défaut— |
Champtools[].type | Typestring | ExigenceFacultatif | Valeurs et limites function Model-specific | Par défaut— |
Champtools[].function.name | Typestring | ExigenceObligatoire | Valeurs et limites S’applique lorsque: Fonction fournie comme outil | 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 Model-specific | Par défaut— |
Champparallel_tool_calls | Typeboolean | ExigenceFacultatif | Valeurs et limites Model-specific | Par défaut— |
Champresponse_format | Typeobject | ExigenceFacultatif | Valeurs et limites Model-specific | Par défaut— |
Champreasoning_effort | Typestring | ExigenceFacultatif | Valeurs et limites Model-specific | Par défaut— |
Champreasoning | Typeobject | ExigenceFacultatif | Valeurs et limites Model-specific | Par défaut— |
Champservice_tier | Typestring | ExigenceFacultatif | Valeurs et limites Model-specific | Par défaut— |
Champinstructions | Typestring | ExigenceFacultatif | Valeurs et limites Champ de compatibilité | Par défaut— |
Champfunctions | Typefunction[] | ExigenceFacultatif | Valeurs et limites Model-specific | Par défaut— |
Champfunction_call | Typestring|object | ExigenceFacultatif | Valeurs et limites Model-specific | Par défaut— |
Champprompt_cache_options | Typeobject | ExigenceFacultatif | Valeurs et limites Model-specific | Par défaut— |
Champmodalities | Typestring[] | ExigenceFacultatif | Valeurs et limites text | Par défaut— |
Champprovider | Typeobject | ExigenceFacultatif | Valeurs et limites Conditions: provider.options est refusé sur cette route textuelle Ultra | Par défaut— |
Champcache_control.ttl | Typestring | ExigenceFacultatif | Valeurs et limites Conditions: La valeur 1h est refusée là où le cache des prompts est configuré | 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é comme texte littéral ; aucun ID 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’ID 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/objet 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 jetons | Barème tarifaireTarif de base | Coût Entrée · Jetons en entrée $0.003 / 1K jetons Sortie · Jetons en sortie $0.015 / 1K jetons Entrée · Lecture du cache $0.0003 / 1K jetons Entrée · Écriture dans le cache — / 1K jetons Entrée · Écriture dans le cache, 1 h — / 1K jetons |
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": "google/gemini-3.8-flash", "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='google/gemini-3.8-flash',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='google/gemini-3.8-flash',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, et conservez le motif final d’arrêt et les données d’utilisation.
Conservez les ID et les en-têtes de requête/réponse. Aucune URL générique de récupération de tâche textuelle 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 éléments fournis ou valeur de paramètre invalides | Étape suivanteCorrigez les champs indiqués avant une nouvelle requête de création. |
Ailoot gemini-3.8-flash
Ailoot Ultra gemini-3.8-flash, google/gemini-3.8-flash, ~google/gemini-flash-latest
/chat/completions
google/gemini-3.8-flash, ~google/gemini-flash-latest, gemini-3.8-flash, gemini-3.8-flash
google/gemini-3.8-flashGemini 3.8 Flash est le modèle multimodal polyvalent de Google pour le génie logiciel soutenu, les agents et les tâches complexes de traitement des connaissances. Il accepte le texte, les images, l’audio, la vidéo et les PDF, renvoie du texte et offre un raisonnement faible, moyen ou élevé avec des outils et une sortie structurée. Ses limites d’entrée/sortie documentées sont de 1 048 576/65 536 jetons.
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.
Gemini 3.8 Flash est le modèle à sortie textuelle de Google pour le génie logiciel soutenu, les agents à plusieurs étapes et les flux de travail complexes sur les connaissances. Il s’appuie sur Gemini 3.7 Flash, avec des améliorations en génie logiciel et dans le travail sur les connaissances effectué par des agents. Il accepte le texte, les images, l’audio, la vidéo et les PDF, de sorte qu’une tâche peut combiner un objectif écrit avec les éléments réels nécessaires pour la résoudre. Le résultat utile est une modification de code, une analyse expliquée, une réponse écrite ou un enregistrement structuré.
Pour une tâche de programmation, fournissez l’exigence, les fichiers pertinents, le comportement observé et les contraintes à préserver. Une capture d’écran peut établir l’interface souhaitée, tandis que des journaux ou un exemple reproductible montrent la défaillance. Pour une tâche de débogage, demandez au modèle de retracer un écart entre l’état visible d’un formulaire et sa valeur enregistrée, d’identifier le chemin de code responsable et de proposer une correction ciblée. Gardez le livrable final souhaité clair afin qu’une séquence d’investigation et d’utilisation d’outils plus longue conserve une condition de fin précise.
Pour les travaux de longue durée, utilisez des étapes de raisonnement plus petites, des appels d’outils itératifs et des vérifications des résultats intermédiaires. Les niveaux de réflexion faible, moyen et élevé contrôlent la quantité de raisonnement; le niveau moyen est la valeur par défaut documentée. Le niveau faible convient à une ébauche rapide ou à une analyse délimitée, tandis que le niveau élevé vise les mathématiques difficiles, la programmation ou les tâches à plusieurs étapes. Gemini 3.8 Flash ne prend pas en charge le niveau de réflexion minimal. Une tâche de débogage soutenue et une simple extraction de champs demandent donc des choix de raisonnement différents plutôt que le même réglage pour toutes les requêtes.
Les outils documentés comprennent les appels de fonctions, l’exécution de code, la recherche de fichiers, l’ancrage par recherche, l’ancrage avec Google Maps et le contexte URL, Computer Use étant présenté comme une capacité en préversion. Les sorties structurées définissent un résultat lisible par machine. Les fonctions doivent avoir une finalité claire et des paramètres définis : le modèle peut demander une fonction, tandis que l’application connectée réalise l’opération et renvoie son résultat. Préservez l’identité des fonctions et les éléments réellement renvoyés d’un tour à l’autre. Une réponse finale utile explique quelles données probantes appuient la correction proposée ou la valeur extraite.
Le guide de migration 3.8 utilise des contrôles de niveau de réflexion à la place de l’ancienne configuration du budget de raisonnement et conseille de retirer les paramètres d’échantillonnage obsolètes et les tours de modèle préremplis. Il exige aussi de préserver les signatures de pensée dans le flux sans état pertinent et de faire correspondre les réponses de fonctions à leurs appels par identité et nom. Ces détails comptent lorsqu’on poursuit une tâche à plusieurs étapes : le tour suivant a besoin du contexte réel antérieur plutôt que d’un récit réécrit qui perd le résultat d’outil ou la signature. Gardez la question et la sortie demandée explicites dans le nouveau tour utilisateur.
Pour le travail multimodal sur les connaissances, identifiez les pages de document, le graphique, l’intervalle audio ou l’événement vidéo pertinents et indiquez comment ils doivent contribuer à la réponse. Une comparaison de documents peut demander un tableau des différences avec des passages sources; une question sur un graphique peut demander les valeurs visibles et la conclusion qu’elles appuient. Une analyse vidéo peut demander une description des événements qui justifient un constat. Le modèle renvoie du texte à partir de ces entrées. Les images générées, la parole et les interactions audio en direct relèvent de profils de modèles distincts.
Ses limites Gemini API sont de 1 048 576 jetons d’entrée et de 65 536 jetons de sortie, ce qui correspond au contexte natif allant jusqu’à 1M et à la sortie textuelle de 64K du modèle. Les instructions, l’historique de conversation et les médias fournis consomment le contexte d’entrée, et le raisonnement ou un long livrable final doivent respecter la capacité de sortie documentée. Google indique aussi la mise en cache, le traitement par lots, Flex et Priority pour ce profil du producteur. Pour des éléments indépendants, conservez un identifiant stable et un format de sortie explicite afin que chaque résultat reste lié à sa source.
Les limites possibles comprennent des hallucinations, des lenteurs ou des dépassements de délai occasionnels et une consommation plus élevée de jetons avec un effort accru. Ses connaissances s’arrêtent en mars 2026, certains domaines restant limités à janvier 2025. Fournissez des données actuelles ou utilisez les outils d’ancrage documentés lorsque la tâche dépend d’informations plus récentes. Vérifiez les citations de sources, les calculs et le code proposé à partir des entrées réelles et des résultats d’exécution. Le livrable final utile doit distinguer un constat appuyé d’une question non résolue, sans supposer qu’une réponse fluide établit le résultat demandé.
POST /v1/messagestextjson, sse| Champ | Type | Exigence | Valeurs et limites | Par défaut |
|---|---|---|---|---|
Champmodel | Typestring | ExigenceObligatoire | Valeurs et limites google/gemini-3.8-flash | 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 jetons | Barème tarifaireTarif de base | Coût Entrée · Jetons en entrée $0.003 / 1K jetons Sortie · Jetons en sortie $0.015 / 1K jetons Entrée · Lecture du cache $0.0003 / 1K jetons Entrée · Écriture dans le cache — / 1K jetons Entrée · Écriture dans le cache, 1 h — / 1K jetons |
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": "google/gemini-3.8-flash",\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': 'google/gemini-3.8-flash', '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': 'google/gemini-3.8-flash', '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 ID 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 ID et les en-têtes de requête/réponse. Aucune URL générique de récupération de tâche textuelle 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 éléments fournis ou valeur de paramètre invalides | Étape suivanteCorrigez les champs indiqués avant une nouvelle requête de création. |
Ailoot gemini-3.8-flash
Ailoot Ultra gemini-3.8-flash, google/gemini-3.8-flash, ~google/gemini-flash-latest
/chat/completions
google/gemini-3.8-flash, ~google/gemini-flash-latest, gemini-3.8-flash, gemini-3.8-flash
~google/gemini-flash-latestGemini 3.8 Flash est le modèle multimodal polyvalent de Google pour le génie logiciel soutenu, les agents et les tâches complexes de traitement des connaissances. Il accepte le texte, les images, l’audio, la vidéo et les PDF, renvoie du texte et offre un raisonnement faible, moyen ou élevé avec des outils et une sortie structurée. Ses limites d’entrée/sortie documentées sont de 1 048 576/65 536 jetons.
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.
Gemini 3.8 Flash est le modèle à sortie textuelle de Google pour le génie logiciel soutenu, les agents à plusieurs étapes et les flux de travail complexes sur les connaissances. Il s’appuie sur Gemini 3.7 Flash, avec des améliorations en génie logiciel et dans le travail sur les connaissances effectué par des agents. Il accepte le texte, les images, l’audio, la vidéo et les PDF, de sorte qu’une tâche peut combiner un objectif écrit avec les éléments réels nécessaires pour la résoudre. Le résultat utile est une modification de code, une analyse expliquée, une réponse écrite ou un enregistrement structuré.
Pour une tâche de programmation, fournissez l’exigence, les fichiers pertinents, le comportement observé et les contraintes à préserver. Une capture d’écran peut établir l’interface souhaitée, tandis que des journaux ou un exemple reproductible montrent la défaillance. Pour une tâche de débogage, demandez au modèle de retracer un écart entre l’état visible d’un formulaire et sa valeur enregistrée, d’identifier le chemin de code responsable et de proposer une correction ciblée. Gardez le livrable final souhaité clair afin qu’une séquence d’investigation et d’utilisation d’outils plus longue conserve une condition de fin précise.
Pour les travaux de longue durée, utilisez des étapes de raisonnement plus petites, des appels d’outils itératifs et des vérifications des résultats intermédiaires. Les niveaux de réflexion faible, moyen et élevé contrôlent la quantité de raisonnement; le niveau moyen est la valeur par défaut documentée. Le niveau faible convient à une ébauche rapide ou à une analyse délimitée, tandis que le niveau élevé vise les mathématiques difficiles, la programmation ou les tâches à plusieurs étapes. Gemini 3.8 Flash ne prend pas en charge le niveau de réflexion minimal. Une tâche de débogage soutenue et une simple extraction de champs demandent donc des choix de raisonnement différents plutôt que le même réglage pour toutes les requêtes.
Les outils documentés comprennent les appels de fonctions, l’exécution de code, la recherche de fichiers, l’ancrage par recherche, l’ancrage avec Google Maps et le contexte URL, Computer Use étant présenté comme une capacité en préversion. Les sorties structurées définissent un résultat lisible par machine. Les fonctions doivent avoir une finalité claire et des paramètres définis : le modèle peut demander une fonction, tandis que l’application connectée réalise l’opération et renvoie son résultat. Préservez l’identité des fonctions et les éléments réellement renvoyés d’un tour à l’autre. Une réponse finale utile explique quelles données probantes appuient la correction proposée ou la valeur extraite.
Le guide de migration 3.8 utilise des contrôles de niveau de réflexion à la place de l’ancienne configuration du budget de raisonnement et conseille de retirer les paramètres d’échantillonnage obsolètes et les tours de modèle préremplis. Il exige aussi de préserver les signatures de pensée dans le flux sans état pertinent et de faire correspondre les réponses de fonctions à leurs appels par identité et nom. Ces détails comptent lorsqu’on poursuit une tâche à plusieurs étapes : le tour suivant a besoin du contexte réel antérieur plutôt que d’un récit réécrit qui perd le résultat d’outil ou la signature. Gardez la question et la sortie demandée explicites dans le nouveau tour utilisateur.
Pour le travail multimodal sur les connaissances, identifiez les pages de document, le graphique, l’intervalle audio ou l’événement vidéo pertinents et indiquez comment ils doivent contribuer à la réponse. Une comparaison de documents peut demander un tableau des différences avec des passages sources; une question sur un graphique peut demander les valeurs visibles et la conclusion qu’elles appuient. Une analyse vidéo peut demander une description des événements qui justifient un constat. Le modèle renvoie du texte à partir de ces entrées. Les images générées, la parole et les interactions audio en direct relèvent de profils de modèles distincts.
Ses limites Gemini API sont de 1 048 576 jetons d’entrée et de 65 536 jetons de sortie, ce qui correspond au contexte natif allant jusqu’à 1M et à la sortie textuelle de 64K du modèle. Les instructions, l’historique de conversation et les médias fournis consomment le contexte d’entrée, et le raisonnement ou un long livrable final doivent respecter la capacité de sortie documentée. Google indique aussi la mise en cache, le traitement par lots, Flex et Priority pour ce profil du producteur. Pour des éléments indépendants, conservez un identifiant stable et un format de sortie explicite afin que chaque résultat reste lié à sa source.
Les limites possibles comprennent des hallucinations, des lenteurs ou des dépassements de délai occasionnels et une consommation plus élevée de jetons avec un effort accru. Ses connaissances s’arrêtent en mars 2026, certains domaines restant limités à janvier 2025. Fournissez des données actuelles ou utilisez les outils d’ancrage documentés lorsque la tâche dépend d’informations plus récentes. Vérifiez les citations de sources, les calculs et le code proposé à partir des entrées réelles et des résultats d’exécution. Le livrable final utile doit distinguer un constat appuyé d’une question non résolue, sans supposer qu’une réponse fluide établit le résultat demandé.
POST /v1/chat/completionstexttext| Champ | Type | Exigence | Valeurs et limites | Par défaut |
|---|---|---|---|---|
Champmodel | Typestring | ExigenceObligatoire | Valeurs et limites ~google/gemini-flash-latest | 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: These roles are explicitly represented by Source compatibility types; the exact model role set remains model-specific. Model-specific | 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; use actual returned ID | Par défaut— |
Champmessages[].name | Typestring | ExigenceFacultatif | Valeurs et limites | Par défaut— |
Champmessages[].reasoning_content | Typestring | ExigenceFacultatif | Valeurs et limites S’applique lorsque: Round-trip actual returned reasoning where this model uses it | Par défaut— |
Champmessages[].reasoning_details | Typeobject|array | ExigenceFacultatif | Valeurs et limites Model-specific | Par défaut— |
Champmax_tokens | Typeinteger | ExigenceFacultatif | Valeurs et limites Minimum: 1 Model-specific | Par défaut— |
Champmax_completion_tokens | Typeinteger | ExigenceFacultatif | Valeurs et limites Minimum: 1 Model-specific | Par défaut— |
Champstream | Typeboolean | ExigenceFacultatif | Valeurs et limites | Par défautfalse |
Champstream_options.include_usage | Typeboolean | ExigenceFacultatif | Valeurs et limites Model-specific | Par défaut— |
Champtemperature | Typenumber | ExigenceFacultatif | Valeurs et limites Model-specific | Par défaut— |
Champtop_p | Typenumber | ExigenceFacultatif | Valeurs et limites Model-specific | Par défaut— |
Champstop | Typestring|string[] | ExigenceFacultatif | Valeurs et limites Model-specific | Par défaut— |
Champtools | Typefunction_tool[] | ExigenceFacultatif | Valeurs et limites Model-specific | Par défaut— |
Champtools[].type | Typestring | ExigenceFacultatif | Valeurs et limites function Model-specific | Par défaut— |
Champtools[].function.name | Typestring | ExigenceObligatoire | Valeurs et limites S’applique lorsque: function tool supplied | 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 Model-specific | Par défaut— |
Champparallel_tool_calls | Typeboolean | ExigenceFacultatif | Valeurs et limites Model-specific | Par défaut— |
Champresponse_format | Typeobject | ExigenceFacultatif | Valeurs et limites Model-specific | Par défaut— |
Champreasoning_effort | Typestring | ExigenceFacultatif | Valeurs et limites Model-specific | Par défaut— |
Champreasoning | Typeobject | ExigenceFacultatif | Valeurs et limites Model-specific | Par défaut— |
Champservice_tier | Typestring | ExigenceFacultatif | Valeurs et limites Model-specific | Par défaut— |
Champinstructions | Typestring | ExigenceFacultatif | Valeurs et limites Champ de compatibilité | Par défaut— |
Champfunctions | Typefunction[] | ExigenceFacultatif | Valeurs et limites Model-specific | Par défaut— |
Champfunction_call | Typestring|object | ExigenceFacultatif | Valeurs et limites Model-specific | Par défaut— |
Champprompt_cache_options | Typeobject | ExigenceFacultatif | Valeurs et limites Model-specific | Par défaut— |
Champmodalities | Typestring[] | ExigenceFacultatif | Valeurs et limites text | Par défaut— |
Champprovider | Typeobject | ExigenceFacultatif | Valeurs et limites Conditions: provider.options is rejected on this Ultra text route | Par défaut— |
Champcache_control.ttl | Typestring | ExigenceFacultatif | Valeurs et limites Conditions: 1h is rejected in actual prompt-cache locations | Par défaut— |
Texte · UTF8 text
messages[].content
| Paramètre | Contrat |
|---|---|
Paramètrecontent_type | Contratapplication/json |
Paramètrerequired | Contratmodel, messages |
Paramètrematerial_types | Contrattext |
Paramètremessages | Contratmessage array with role/content shape |
Paramètrefile_material | Contratactual UTF-8 document inserted as literal text; no file ID inferred |
Paramètreoptional_controls | Contratstream, temperature, top_p, stop, max_tokens, max_completion_tokens, reasoning, response_format, tools, tool_choice |
Paramètrecontrol_scope | Contratmodel-specific; user function tools differ from hosted tools |
Paramètreoutput_modalities | Contrattext |
Paramètrehosted_operations | Contratfalse |
Paramètremultimodal_input_binding | Contratnull |
Cycle de vie : synchronous_or_streamed
Send exact model ID with messages.
Context length is not an output cap.
A text file may supply literal text; image/audio/file-object inputs need exact binding.
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 jetons | Barème tarifaireTarif de base | Coût Entrée · Jetons en entrée $0.003 / 1K jetons Sortie · Jetons en sortie $0.015 / 1K jetons Entrée · Lecture du cache $0.0003 / 1K jetons Entrée · Écriture dans le cache — / 1K jetons Entrée · Écriture dans le cache, 1 h — / 1K jetons |
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": "~google/gemini-flash-latest", "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='~google/gemini-flash-latest',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='~google/gemini-flash-latest',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 or SSE
Conservez chaque réponse, fichier et partie de contenu renvoyés dans leur intégralité.
Keep every choice and its content/tool calls/reasoning. In SSE assemble deltas by choice/tool index, retain the final finish reason and usage.
Keep request/response IDs and headers. No generic text job retrieval URL is supplied.
| 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 | ConditionInvalid required fields, material representation or parameter value | Étape suivanteCorrect the indicated fields before a new creation request. |
Ailoot gemini-3.8-flash
Ailoot Ultra gemini-3.8-flash, google/gemini-3.8-flash, ~google/gemini-flash-latest
/chat/completions
google/gemini-3.8-flash, ~google/gemini-flash-latest, gemini-3.8-flash, gemini-3.8-flash
~google/gemini-flash-latestGemini 3.8 Flash est le modèle multimodal polyvalent de Google pour le génie logiciel soutenu, les agents et les tâches complexes de traitement des connaissances. Il accepte le texte, les images, l’audio, la vidéo et les PDF, renvoie du texte et offre un raisonnement faible, moyen ou élevé avec des outils et une sortie structurée. Ses limites d’entrée/sortie documentées sont de 1 048 576/65 536 jetons.
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.
Gemini 3.8 Flash est le modèle à sortie textuelle de Google pour le génie logiciel soutenu, les agents à plusieurs étapes et les flux de travail complexes sur les connaissances. Il s’appuie sur Gemini 3.7 Flash, avec des améliorations en génie logiciel et dans le travail sur les connaissances effectué par des agents. Il accepte le texte, les images, l’audio, la vidéo et les PDF, de sorte qu’une tâche peut combiner un objectif écrit avec les éléments réels nécessaires pour la résoudre. Le résultat utile est une modification de code, une analyse expliquée, une réponse écrite ou un enregistrement structuré.
Pour une tâche de programmation, fournissez l’exigence, les fichiers pertinents, le comportement observé et les contraintes à préserver. Une capture d’écran peut établir l’interface souhaitée, tandis que des journaux ou un exemple reproductible montrent la défaillance. Pour une tâche de débogage, demandez au modèle de retracer un écart entre l’état visible d’un formulaire et sa valeur enregistrée, d’identifier le chemin de code responsable et de proposer une correction ciblée. Gardez le livrable final souhaité clair afin qu’une séquence d’investigation et d’utilisation d’outils plus longue conserve une condition de fin précise.
Pour les travaux de longue durée, utilisez des étapes de raisonnement plus petites, des appels d’outils itératifs et des vérifications des résultats intermédiaires. Les niveaux de réflexion faible, moyen et élevé contrôlent la quantité de raisonnement; le niveau moyen est la valeur par défaut documentée. Le niveau faible convient à une ébauche rapide ou à une analyse délimitée, tandis que le niveau élevé vise les mathématiques difficiles, la programmation ou les tâches à plusieurs étapes. Gemini 3.8 Flash ne prend pas en charge le niveau de réflexion minimal. Une tâche de débogage soutenue et une simple extraction de champs demandent donc des choix de raisonnement différents plutôt que le même réglage pour toutes les requêtes.
Les outils documentés comprennent les appels de fonctions, l’exécution de code, la recherche de fichiers, l’ancrage par recherche, l’ancrage avec Google Maps et le contexte URL, Computer Use étant présenté comme une capacité en préversion. Les sorties structurées définissent un résultat lisible par machine. Les fonctions doivent avoir une finalité claire et des paramètres définis : le modèle peut demander une fonction, tandis que l’application connectée réalise l’opération et renvoie son résultat. Préservez l’identité des fonctions et les éléments réellement renvoyés d’un tour à l’autre. Une réponse finale utile explique quelles données probantes appuient la correction proposée ou la valeur extraite.
Le guide de migration 3.8 utilise des contrôles de niveau de réflexion à la place de l’ancienne configuration du budget de raisonnement et conseille de retirer les paramètres d’échantillonnage obsolètes et les tours de modèle préremplis. Il exige aussi de préserver les signatures de pensée dans le flux sans état pertinent et de faire correspondre les réponses de fonctions à leurs appels par identité et nom. Ces détails comptent lorsqu’on poursuit une tâche à plusieurs étapes : le tour suivant a besoin du contexte réel antérieur plutôt que d’un récit réécrit qui perd le résultat d’outil ou la signature. Gardez la question et la sortie demandée explicites dans le nouveau tour utilisateur.
Pour le travail multimodal sur les connaissances, identifiez les pages de document, le graphique, l’intervalle audio ou l’événement vidéo pertinents et indiquez comment ils doivent contribuer à la réponse. Une comparaison de documents peut demander un tableau des différences avec des passages sources; une question sur un graphique peut demander les valeurs visibles et la conclusion qu’elles appuient. Une analyse vidéo peut demander une description des événements qui justifient un constat. Le modèle renvoie du texte à partir de ces entrées. Les images générées, la parole et les interactions audio en direct relèvent de profils de modèles distincts.
Ses limites Gemini API sont de 1 048 576 jetons d’entrée et de 65 536 jetons de sortie, ce qui correspond au contexte natif allant jusqu’à 1M et à la sortie textuelle de 64K du modèle. Les instructions, l’historique de conversation et les médias fournis consomment le contexte d’entrée, et le raisonnement ou un long livrable final doivent respecter la capacité de sortie documentée. Google indique aussi la mise en cache, le traitement par lots, Flex et Priority pour ce profil du producteur. Pour des éléments indépendants, conservez un identifiant stable et un format de sortie explicite afin que chaque résultat reste lié à sa source.
Les limites possibles comprennent des hallucinations, des lenteurs ou des dépassements de délai occasionnels et une consommation plus élevée de jetons avec un effort accru. Ses connaissances s’arrêtent en mars 2026, certains domaines restant limités à janvier 2025. Fournissez des données actuelles ou utilisez les outils d’ancrage documentés lorsque la tâche dépend d’informations plus récentes. Vérifiez les citations de sources, les calculs et le code proposé à partir des entrées réelles et des résultats d’exécution. Le livrable final utile doit distinguer un constat appuyé d’une question non résolue, sans supposer qu’une réponse fluide établit le résultat demandé.
POST /v1/messagestextjson, sse| Champ | Type | Exigence | Valeurs et limites | Par défaut |
|---|---|---|---|---|
Champmodel | Typestring | ExigenceObligatoire | Valeurs et limites ~google/gemini-flash-latest | 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 · UTF-8 text
messages[].content string
| 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 | ContratRead the actual UTF-8 document and put its text in the indicated input or message content string. |
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 jetons | Barème tarifaireTarif de base | Coût Entrée · Jetons en entrée $0.003 / 1K jetons Sortie · Jetons en sortie $0.015 / 1K jetons Entrée · Lecture du cache $0.0003 / 1K jetons Entrée · Écriture dans le cache — / 1K jetons Entrée · Écriture dans le cache, 1 h — / 1K jetons |
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": "~google/gemini-flash-latest",\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': '~google/gemini-flash-latest', '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': '~google/gemini-flash-latest', '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 or SSE
Conservez chaque réponse, fichier et partie de contenu renvoyés dans leur intégralité.
Keep all content blocks, thinking signatures and actual tool-use IDs. Assemble all SSE block deltas; a first text block is not the complete output.
Keep request/response IDs and headers. No generic text job retrieval URL is supplied.
| 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 | ConditionInvalid required fields, material representation or parameter value | Étape suivanteCorrect the indicated fields before a new creation request. |
Ailoot gemini-3.8-flash
Ailoot Ultra gemini-3.8-flash, google/gemini-3.8-flash, ~google/gemini-flash-latest
/chat/completions
google/gemini-3.8-flash, ~google/gemini-flash-latest, gemini-3.8-flash, gemini-3.8-flash
Exemple technique en anglais
Diagnose an unsaved form value\n\nReview this form flow: the input displays draft.name; typing updates draft.name; Save sends original.name; after reload the old name reappears. Explain the mismatch and propose a minimal correction in framework-neutral pseudocode. Include a regression scenario that types a new name, saves, reloads, and checks the stored value. Do not claim any browser action occurred.A cause explanation, corrected Save pseudocode and an end-to-end regression scenario.The submitted value comes from the edited draft, and the reload check verifies persistence rather than just the visible input.