Comment utiliser l'API Qwen3.8-Flash : guide complet du développeur

Qwen3.8-Flash d’Alibaba est conçu pour les applications qui ont besoin d’un contexte long, de compréhension multimodale, de raisonnement et de capacités d’agent, sans recourir à un modèle phare pour chaque requête. L’API Qwen3.8-Flash de production sur CometAPI utilise l’ID de modèle qwen3.8-flash et est accessible via un flux de travail compatible OpenAI.

Qwen3.8-Flash-Next est la version de recherche à poids ouverts et l’aperçu d’architecture qui montre les orientations de conception pour Qwen4. Qwen3.8-Flash s’appuie sur la même architecture centrale qu’un service API de production sur QwenCloud et Model Studio. Choisissez l’API hébergée pour un accès managé, ou Flash-Next lorsque vous avez besoin de poids ouverts et du contrôle sur la pile de service.

Ce guide garde volontairement la couverture de l’architecture et des benchmarks concise, car CometAPI explique déjà ces sujets dans What is Qwen3.8-Flash-Next. L’accent est mis ici sur l’intégration pratique de l’API : configuration, code, streaming, réflexion, multimodalité, sortie structurée, outils, mise en cache, coût et ingénierie de production.

Qu’est-ce que Qwen3.8-Flash ?

Qwen3.8-Flash est le modèle de raisonnement multimodal de production à coût optimisé d’Alibaba Qwen. Selon la documentation officielle du modèle QwenCloud, il combine une architecture clairsemée à 125B paramètres avec 6B paramètres activés par token, une fenêtre de contexte de 1 million de tokens, une entrée texte/image/vidéo, l’appel de fonctions, la sortie structurée, la mise en cache du contexte et un support d’outils intégré.

Son design axé sur l’efficacité s’appuie sur Gated DeltaNet et Qwen Sparse Attention, ainsi que sur des connexions résiduelles gated et une activation MoE clairsemée. Ces composants visent à réduire le coût d’inférence tout en préservant la capacité pour le codage, l’automatisation bureautique, le raisonnement visuel et les tâches d’agent de longue durée.

Spécifications de Qwen3.8-Flash

Note d’architecture : QwenCloud décrit la version hébergée de Qwen3.8-Flash comme un modèle clairsemé de 125B avec 6B de paramètres activés par token et 51B de paramètres supplémentaires d’embeddings N-gram. Ceux-ci décrivent l’architecture partagée ; le tableau ci-dessus liste les limites et capacités de l’API de production. Consultez la documentation officielle du modèle QwenCloud pour ces deux ensembles de détails.

La combinaison d’un contexte 1M et jusqu’à 131,072 tokens de sortie rend le modèle adapté à l’analyse de code à l’échelle d’un dépôt, à de grandes collections de documents et à des sessions d’agent longues. Une grande fenêtre est une question de capacité, pas une raison d’envoyer du contexte hors sujet.

Quelle est la performance de Qwen3.8-Flash ?

L’analyse détaillée des benchmarks relève de l’existant « Qwen3.8-Flash-Next explainer » de CometAPI. Pour la sélection d’API, le signal le plus utile est que Qwen rapporte de bons résultats en codage, travail bureautique, outils, agents GUI, mathématiques visuelles et compréhension de longues vidéos.

La conclusion pratique n’est pas qu’un benchmark public détermine la qualité en production. Qwen3.8-Flash est explicitement optimisé pour l’ingénierie logicielle et l’usage d’outils, ainsi que pour les agents multimodaux et le travail de longue durée. Évaluez vos propres prompts et boucles d’outils avant migration.

Qwen3.8-Flash vs Qwen3.8-Max vs Qwen3.8-Flash-Next

Utilisez Qwen3.8-Flash lorsque le débit, la longueur de contexte, la multimodalité et le coût comptent simultanément. Utilisez Qwen3.8-Max lorsque la qualité incrémentale du modèle phare justifie un budget d’inférence plus élevé. Choisissez Qwen3.8-Flash-Next lorsque vous avez spécifiquement besoin de poids ouverts et du contrôle sur la pile de service.

Combien coûte l’API Qwen3.8-Flash ?

La page du modèle Qwen3.8-Flash sur CometAPI affiche actuellement un prix d’entrée de $0.12 par million de tokens après la remise affichée. Le billet de lancement officiel de Qwen listait $0.16/M en entrée et $0.47/M en sortie pour QwenCloud au lancement. Étant donné que les tarifs peuvent changer, considérez les pages modèles en direct comme source de vérité plutôt que de coder en dur d’anciens chiffres de blog.

Les prix évoluent plus vite que l’architecture. Revérifiez toujours la page modèle CometAPI en direct avant de publier un calculateur de coûts fixe ou une estimation d’approvisionnement.

Comment accéder à Qwen3.8-Flash via CometAPI

CometAPI expose Qwen3.8-Flash via une API unifiée. Le flux de base est simple : créez un compte, créez un jeton d’API, stockez-le comme variable d’environnement, pointez un SDK compatible OpenAI vers https://api.cometapi.com/v1, et sélectionnez qwen3.8-flash comme modèle.

• Créez un compte CometAPI et ouvrez le tableau de bord API.
• Créez un jeton d’API avec les privilèges minimum requis par votre application.
• Stockez le jeton dans une variable d’environnement ou un gestionnaire de secrets.
• Utilisez l’URL de base CometAPI depuis votre SDK côté serveur.
• Définissez le modèle sur qwen3.8-flash.

export COMETAPI_KEY="your_api_key_here"

$env:COMETAPI_KEY="your_api_key_here"

Ne validez pas de clés d’API dans le contrôle de version et n’exposez pas une clé privilégiée dans du JavaScript côté navigateur. Conservez les identifiants du fournisseur côté serveur.

## Comment appeler l’API Qwen3.8-Flash

### Exemple Python

Comme CometAPI expose une [interface Chat Completions compatible OpenAI](https://apidoc.cometapi.com/api/text/chat), vous pouvez utiliser le client Python OpenAI standard plutôt que d’apprendre un SDK spécifique au fournisseur pour les requêtes texte basiques.

Bash

pip install -U openai

Python

import os
from openai import OpenAI

client = OpenAI(
api_key=os.environ["COMETAPI_KEY"],
base_url="https://api.cometapi.com/v1",
)

response = client.chat.completions.create(
model="qwen3.8-flash",
messages=[
{"role": "system", "content": "You are a concise software engineering assistant."},
{"role": "user", "content": "Explain dependency injection with a short Python example."},
],
)

print(response.choices[0].message.content)

Pour une application déjà compatible OpenAI, les principaux changements concernent généralement `base_url` et l’identifiant du modèle. Cela réduit le travail d’intégration et facilite les tests A/B de modèles ultérieurs.

### Exemple cURL

cURL est utile pour les tests de fumée d’endpoint, les pipelines CI et pour isoler les problèmes d’authentification de la configuration SDK.

Bash

curl https://api.cometapi.com/v1/chat/completions
-H "Authorization: Bearer $COMETAPI_KEY"
-H "Content-Type: application/json"
-d '{
"model": "qwen3.8-flash",
"messages": [
{"role": "system", "content": "You are a technical assistant."},
{"role": "user", "content": "Give me three ways to reduce API latency."}
]
}'

Si la requête cURL réussit mais que votre application échoue, inspectez le chargement des variables d’environnement, la configuration de l’URL de base, les paramètres de proxy, la sérialisation de la requête et la version du SDK avant de mettre en cause l’endpoint du modèle.

### Exemple JavaScript / Node.js

Bash

npm install openai

JavaScript

import OpenAI from "openai";

const client = new OpenAI({
apiKey: process.env.COMETAPI_KEY,
baseURL: "https://api.cometapi.com/v1",
});

const response = await client.chat.completions.create({
model: "qwen3.8-flash",
messages: [
{ role: "system", content: "You are an experienced backend engineer." },
{ role: "user", content: "Design a Redis-backed rate limiter for an API." }
]
});

console.log(response.choices[0].message.content);

Pour les applications web, appelez le modèle depuis votre backend. Une clé d’API de production ne doit pas être livrée à des navigateurs non fiables.

## Capacités API centrales de Qwen3.8-Flash : streaming, entrée multimodale et appel d’outils

### Réponses en streaming

Pour les interfaces de chat et les assistants de codage, le streaming améliore la latence perçue en rendant les tokens dès leur arrivée. L’API Chat Completions de CometAPI prend en charge le streaming SSE sur les routes compatibles.

Python

import os
from openai import OpenAI

client = OpenAI(
api_key=os.environ["COMETAPI_KEY"],
base_url="https://api.cometapi.com/v1",
)

stream = client.chat.completions.create(
model="qwen3.8-flash",
messages=[{
"role": "user",
"content": "Design an authentication architecture for a SaaS API."
}],
stream=True,
stream_options={"include_usage": True},
)

for chunk in stream:
if not chunk.choices:
if getattr(chunk, "usage", None):
print("\nUsage:", chunk.usage)
continue

delta = chunk.choices[0].delta
if delta.content:
    print(delta.content, end="", flush=True)

En production, enregistrez le nom du modèle, le statut HTTP, le temps jusqu’au premier token, la latence totale, les tokens d’entrée, les tokens de sortie et le nombre de tentatives. Ces métriques sont plus exploitables qu’une simple latence moyenne.

### Mode de réflexion

Qwen3.8-Flash est un modèle de raisonnement et la réflexion est activée par défaut. La documentation officielle QwenCloud expose trois niveaux de raisonnement : `low`, `medium` et `xhigh`, avec `xhigh` comme valeur par défaut documentée.

| Mode   | Comportement officiel | Usage typique                             |
| ------ | --------------------- | ----------------------------------------- |
| low    | Raisonnement léger    | Extraction, classification, Q&R simple    |
| medium | Raisonnement équilibré| Développement général et travail sur docs |
| xhigh  | Raisonnement maximal  | Codage difficile, planification, archi, maths |

Python - exemple natif QwenCloud

import os
from openai import OpenAI

client = OpenAI(
api_key=os.environ["DASHSCOPE_API_KEY"],
base_url="https://dashscope-intl.aliyuncs.com/compatible-mode/v1",
)

response = client.chat.completions.create(
model="qwen3.8-flash",
messages=[{
"role": "user",
"content": "Review this system architecture and identify concurrency risks."
}],
extra_body={"enable_thinking": True},
reasoning_effort="medium",
)

print(response.choices[0].message.content)

Les paramètres spécifiques au fournisseur peuvent différer derrière des couches d’API unifiées. Validez les options natives Qwen par rapport à la [documentation API CometAPI actuelle](https://apidoc.cometapi.com/api/text/chat) ou au Playground avant de vous y fier en production.

N’utilisez pas automatiquement le raisonnement maximal pour chaque requête. Une extraction ou classification simple en a rarement besoin. À l’inverse, trop peu de raisonnement dans un flux d’outils multi-tours peut créer des actions échouées et des retries ; optimisez donc pour l’achèvement de tâche réussi plutôt que pour le coût le plus bas d’un seul tour.

### Compréhension d’images

Qwen3.8-Flash est nativement multimodal. La [documentation officielle vision de Qwen](https://docs.qwencloud.com/developer-guides/getting-started/vision-models) liste l’entrée texte, image et vidéo avec une sortie texte, ce qui rend le modèle adapté aux captures d’écran, documents, graphiques, inspection d’UI et workflows d’agents visuels.

Python

import os
from openai import OpenAI

client = OpenAI(
api_key=os.environ["COMETAPI_KEY"],
base_url="https://api.cometapi.com/v1",
)

response = client.chat.completions.create(
model="qwen3.8-flash",
messages=[{
"role": "user",
"content": [
{"type": "text", "text": "Identify the three most important anomalies in this dashboard."},
{
"type": "image_url",
"image_url": {"url": "https://example.com/dashboard.png"}
}
]
}],
)

print(response.choices[0].message.content)

Avant de livrer un workflow multimodal via un agrégateur, vérifiez que la route exacte expose actuellement la capacité image ou vidéo souhaitée. Les capacités du fournisseur et celles des routes unifiées peuvent évoluer indépendamment.

### Compréhension vidéo

Le service Qwen natif peut traiter la vidéo, et les [limites vision Qwen pour Qwen3.8-Flash](https://docs.qwencloud.com/developer-guides/getting-started/vision-models) incluent des charges de travail vidéo longues jusqu’à deux heures sous les contraintes documentées. L’échantillonnage de trames est réglable : un échantillonnage plus élevé capture plus de détails visuels mais augmente le traitement et le coût en tokens.

* Analyse de réunions et cours
* Synthèse de tutoriels et workflows
* Inspection d’UI ou de flux d’application
* Revue de contenu vidéo
* Workflows multimodaux longs pour documents

Ne supposez pas que la vidéo maximale acceptée soit la requête la plus efficace. En production, évaluez taux d’échantillonnage, segmentation, latence et précision sur vos propres contenus.

### Sortie JSON structurée

La sortie structurée est utile quand la réponse du modèle est consommée par du code plutôt que par un humain. Qwen3.8-Flash [prend en charge la sortie structurée](https://docs.qwencloud.com/developer-guides/getting-started/latest-model), tandis que les routes compatibles OpenAI peuvent exposer des formats de réponse JSON.

Python

response = client.chat.completions.create(
model="qwen3.8-flash",
messages=[{
"role": "user",
"content": (
"Analyze this support request and return category, priority, and summary as JSON: "
"Payment succeeded but my subscription is still inactive."
)
}],
response_format={"type": "json_object"},
)

print(response.choices[0].message.content)

JSON

{
"category": "billing",
"priority": "high",
"summary": "Subscription inactive after successful payment"
}

Pour les workflows critiques, validez le JSON parsé par rapport à votre propre schéma, même lorsque le fournisseur impose un format de réponse. La conformité du modèle ne remplace pas la validation côté application.

### Appel de fonctions

Qwen3.8-Flash prend en charge l’appel de fonctions et le raisonnement conscient des outils. Le modèle choisit un outil et des arguments ; votre application reste responsable de l’autorisation, de la validation, de l’exécution et de la valeur retournée.

Python

tools = [
{
"type": "function",
"function": {
"name": "get_order_status",
"description": "Retrieve the current status of an order.",
"parameters": {
"type": "object",
"properties": {
"order_id": {"type": "string"}
},
"required": ["order_id"]
}
}
}
]

response = client.chat.completions.create(
model="qwen3.8-flash",
messages=[{"role": "user", "content": "Where is order A-10492?"}],
tools=tools,
tool_choice="auto",
)

print(response.choices[0].message.tool_calls)

Ne laissez jamais un appel d’outil généré par LLM contourner les permissions appliquées à un utilisateur normal. Les opérations à fort impact telles que les remboursements, suppressions ou modifications de compte doivent être validées en dehors du modèle.

## Pourquoi la conservation de la réflexion est importante pour les agents

Qwen documente `preserve_thinking` pour le raisonnement multi-tours, et [Qwen3.8-Flash figure parmi les modèles pris en charge](https://docs.qwencloud.com/developer-guides/text-generation/thinking). Conserver l’état de raisonnement peut réduire la reconstruction répétée sur de longues boucles d’outils telles que inspecter le dépôt -> modifier un fichier -> exécuter les tests -> inspecter l’échec -> réviser le correctif.

Le compromis est la croissance du contexte. Conservez suffisamment d’état pour maintenir la cohérence, mais résumez ou élaguez le matériel périmé lorsqu’il n’aide plus l’agent à choisir la prochaine action.

## Comment utiliser la mise en cache du contexte

Les modèles à grand contexte deviennent coûteux lorsqu’une application renvoie à répétition le même long préfixe. Qwen3.8-Flash [prend en charge la mise en cache du contexte](https://docs.qwencloud.com/developer-guides/getting-started/latest-model), y compris des schémas implicites, explicites et orientés session dans le service officiel.

| Type de cache   | Comportement                                             | Bon usage                               |
| --------------- | --------------------------------------------------------- | --------------------------------------- |
| Cache implicite | Le fournisseur détecte automatiquement des préfixes réutilisables | Instructions répétées et préfixes stables |
| Cache explicite | L’application crée délibérément un contexte mis en cache réutilisable | Gros documents fixes ou instantanés de code |
| Cache de session| Cache orienté session dans les workflows Responses pris en charge | Agents longue durée avec état persistant |

De bons candidats de cache sont volumineux, fréquemment réutilisés, majoritairement identiques et placés près du début du contexte. Exemples : instructions système, documentation produit, instantanés de dépôt, ou état d’arrière-plan stable d’agent.

## Faut-il mettre 1 million de tokens dans chaque prompt ?

Non. La fenêtre de 1 million de tokens résout un problème de capacité ; elle ne supprime pas le besoin d’ingénierie de contexte. Envoyer « tout » peut augmenter la latence de pré-remplissage, le coût, les éléments hors sujet et la complexité du débogage.

Text

retrieve -> rank -> construct context -> cache reusable prefix -> call model

Utilisez toute la fenêtre lorsque des relations inter-documents ou à l’échelle du dépôt font réellement partie de la tâche. Sinon, la récupération, le classement, la synthèse et la mise en cache produisent généralement une requête plus propre.

## Connecter Qwen3.8-Flash aux outils développeur

### Configuration Claude Code

Le service de production de Qwen prend en charge un protocole compatible Anthropic pour l’outillage des agents. La version officielle donne une configuration Claude Code utilisant `qwen3.8-flash`.

Bash - QwenCloud natif

npm install -g @anthropic-ai/claude-code

export ANTHROPIC_MODEL="qwen3.8-flash"
export ANTHROPIC_SMALL_FAST_MODEL="qwen3.8-flash"
export ANTHROPIC_BASE_URL="https://dashscope-intl.aliyuncs.com/apps/anthropic"
export ANTHROPIC_AUTH_TOKEN="<YOUR_QWEN_API_KEY>"

claude

Cet exemple utilise directement QwenCloud parce que le chemin compatible Anthropic et les variables sont spécifiques au fournisseur. Pour CometAPI, n’utilisez que les protocoles et routes actuellement documentés pour le compte et l’endpoint que vous appelez.

### Configuration Codex

Qwen documente également une configuration Codex compatible Responses. Une configuration QwenCloud native peut ressembler à ceci :

TOML - QwenCloud natif

model_provider = "QwenCloud"
model = "qwen3.8-flash"

[model_providers.QwenCloud]
name = "QwenCloud"
base_url = "https://dashscope-intl.aliyuncs.com/compatible-mode/v1"
env_key = "OPENAI_API_KEY"
wire_api = "responses"

C’est l’une des raisons pour lesquelles Qwen3.8-Flash est plus intéressant qu’un modèle de chat à bas coût conventionnel : il est explicitement positionné pour des boucles de codage et d’agent de longue durée, pas seulement pour des complétions ponctuelles.

## Meilleurs cas d’usage de l’API Qwen3.8-Flash

### Agents de codage

Les benchmarks en codage et ingénierie logicielle du modèle, le long contexte et le support des outils rendent naturels les workloads d’analyse de dépôt, de débogage, de refactorisation multi-fichiers, de génération de tests, de revue de code et de remédiation CI.

### Agents IA à fort volume

Un faible coût par token compte davantage lorsqu’une tâche visible par l’utilisateur déclenche de nombreux appels modèle. Un agent en 20 étapes peut multiplier même un petit écart de coût à travers les cycles de raisonnement et d’outils.

### Analyse de longs documents

La fenêtre de contexte 1M est utile pour des contrats, manuels techniques, collections de recherche, connaissances d’entreprise et grands ensembles de documentation. La récupération et la mise en cache restent importantes lorsque seule une fraction du contenu est pertinente.

### Agents visuels et UI

De bons résultats visuels et orientés GUI tels qu’AndroidWorld et MathVision rendent le modèle pertinent lorsque des captures d’écran, schémas ou états d’UI influencent la prochaine action d’outil.

### Automatisation de production sensible au coût

Si une charge ne nécessite pas Qwen3.8-Max à chaque tour, router le travail routinier vers Qwen3.8-Flash peut réduire les dépenses tout en préservant l’accès à un recours plus puissant pour les cas difficiles.

## Comment optimiser le coût de l’API Qwen3.8-Flash

* Limitez la longueur de sortie à ce que l’application consomme réellement.
* Utilisez un raisonnement plus faible pour l’extraction simple, l’étiquetage et les tâches de transformation routinières.
* Mettez en cache les grands préfixes répétés au lieu de les retraiter depuis zéro.
* Émondez l’historique de conversation obsolète et les sorties d’outils redondantes.
* Routez les tâches incertaines ou échouées vers un raisonnement plus élevé ou un modèle de secours plus puissant.
* Mesurez le coût par tâche réussie, pas seulement le coût par token ou par requête.

Text

simple extraction / classification
|
v
Qwen3.8-Flash + low reasoning
|
v
complex / uncertain / failed task?
|
v
higher reasoning / stronger fallback model

Une requête moins chère qui échoue deux fois peut coûter plus cher qu’une requête légèrement plus chère qui réussit du premier coup. Pour les agents, incluez les retries, les appels d’outils et le retravail en aval dans votre modèle de coûts.

## Bonnes pratiques de production avec Qwen3.8-Flash

* Gardez le nom du modèle configurable afin de pouvoir faire de l’A/B testing et rollback sans toucher au code applicatif.
* Utilisez un backoff exponentiel pour les erreurs transitoires 429 et 5xx.
* Journalisez la latence de requête, le temps jusqu’au premier token, l’usage de tokens, le nombre de tentatives et la classe d’erreur.
* Validez les sorties structurées avec des schémas côté application.
* Gardez l’autorisation et les règles métier à fort impact en dehors du LLM.
* Évaluez le modèle avec vos prompts, outils, langues et longueurs de contexte réels.
* N’utilisez un modèle de secours que pour les cas qui nécessitent réellement plus de capacité.

Bash

AI_MODEL=qwen3.8-flash

## Erreurs fréquentes de l’API Qwen3.8-Flash

### 401 Unauthorized

Indique généralement que la clé d’API est manquante, invalide, ou envoyée au mauvais endpoint fournisseur. Confirmez la variable d’environnement et l’en-tête `Authorization: Bearer ...`.

Bash

echo $COMETAPI_KEY

### 404 ou Model Not Found

Confirmez que l’identifiant du modèle est exactement `qwen3.8-flash`. Ne remplacez pas par `Qwen3.8-Flash-Next` ; la version d’architecture à poids ouverts et le modèle de production hébergé ne sont pas des noms de déploiement interchangeables.

### 429 Rate Limit

Utilisez un backoff exponentiel, réduisez la concurrence et inspectez les limites de taux de la route réellement utilisée. Les limites du fournisseur et de l’agrégateur peuvent différer.

### Réponses très lentes

* Vérifiez l’effort de raisonnement.
* Mesurez la longueur du prompt et le plafond de sortie.
* Inspectez le nombre d’itérations de la boucle outil.
* Réduisez les entrées image/vidéo inutilement volumineuses.
* Activez le streaming pour les interfaces utilisateur.

### Usage de tokens anormalement élevé

* Inspectez l’historique de conversation conservé.
* Vérifiez si de grands documents sont renvoyés à répétition.
* Recherchez des sorties d’outils verbeuses et des boucles de retry.
* Réduisez le raisonnement inutile sur les tâches routinières.
* Utilisez les métriques de cache et les journaux de tokens par route.

## L’API Qwen3.8-Flash vaut-elle la peine d’être utilisée ?

Pour un chatbot basique de courte forme, Qwen3.8-Flash peut être surdimensionné. Sa valeur est plus claire lorsqu’une application a besoin à la fois d’un long contexte et de multimodalité, avec raisonnement et appel de fonctions, surtout lorsque le coût compte sur un volume de requêtes élevé.

Via l’endpoint Qwen3.8-Flash de CometAPI, les développeurs peuvent conserver un style d’intégration compatible OpenAI tout en testant Qwen aux côtés d’autres modèles. Une architecture de production sensée n’impose donc pas un modèle unique à chaque charge, mais utilise Flash comme défaut efficace et n’escalade que lorsque le gain de qualité le justifie.

## Conclusion

Qwen3.8-Flash est un modèle d’API pratique car ses priorités d’ingénierie correspondent étroitement aux contraintes de production : long contexte, entrée multimodale, raisonnement, usage d’outils et inférence à paramètres actifs faibles. Les détails d’architecture officiels sont un contexte utile, mais l’avantage en production vient de la manière dont vous l’intégrez et l’opérez.

Commencez avec [la page modèle Qwen3.8-Flash sur CometAPI](https://www.cometapi.com/models/aliyun/qwen3-8-flash/) et un client compatible OpenAI, puis ajoutez le streaming, la validation de schémas, des outils sécurisés, la mise en cache du contexte, l’observabilité et le routage des charges au fur et à mesure de la maturité de votre application.

Python

client = OpenAI(
api_key=os.environ["COMETAPI_KEY"],
base_url="https://api.cometapi.com/v1",
)

response = client.chat.completions.create(
model="qwen3.8-flash",
messages=[{"role": "user", "content": "Your request here"}],
)