Utiliser l’API GPT-6 Astra : premier appel, niveaux d’effort et migration depuis GPT-5.6

Fiche de référence rapide

Installation et première requête

Étape 1 : obtenir une clé API EvoLink

Étape 2 : installer le SDK OpenAI

pip install openai        # Python
npm install openai        # Node.js

Étape 3 : envoyer la première requête

Commencez par une requête Responses simple. OpenAI impose Responses pour les appels d’outils ; les fonctions avancées de Responses nécessitent une vérification séparée sur la route EvoLink.

curl https://api.evolink.ai/v1/responses \
  -H "Authorization: Bearer $EVOLINK_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-6-astra",
    "input": "Explique en un paragraphe la différence entre lectures et écritures de cache.",
    "reasoning": {"effort": "medium"}
  }'

from openai import OpenAI

client = OpenAI(
    api_key="your-evolink-api-key",
    base_url="https://api.evolink.ai/v1",
)

response = client.responses.create(
    model="gpt-6-astra",
    input="Explique en un paragraphe la différence entre lectures et écritures de cache.",
    reasoning={"effort": "medium"},
)

print(response.output_text)
print(response.model, response.usage)

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: "your-evolink-api-key",
  baseURL: "https://api.evolink.ai/v1",
});

const response = await client.responses.create({
  model: "gpt-6-astra",
  input: "Explique en un paragraphe la différence entre lectures et écritures de cache.",
  reasoning: { effort: "medium" },
});

console.log(response.output_text);
console.log(response.model, response.usage);

Requêtes texte seul sur Chat Completions

response = client.chat.completions.create(
    model="gpt-6-astra",
    messages=[{"role": "user", "content": "Résume ce changelog en trois points : ..."}],
    reasoning_effort="low",
)
print(response.choices[0].message.content)

Chat Completions vs API Responses

Si votre boucle d’agent vit aujourd’hui sur Chat Completions, déplacez-la vers Responses ou gardez-la sur GPT-5.6, qui y prend toujours en charge l’appel d’outils.

Choisir un effort de raisonnement

OpenAI documente deux commandes supplémentaires. Leur prise en charge sur EvoLink n’est pas encore vérifiée ; les éléments suivants servent de référence pour l’API du fournisseur :

• configuration_update permet à une conversation Responses de changer d’effort entre les tours sans invalider le cache de prompt. Commencez à medium, n’escaladez que les tours qui échouent.
• reasoning.mode: "pro" est un mode qualité distinct sur l’API Responses ; traitez-le comme un candidat d’évaluation à part, pas comme un sixième niveau d’effort.

Définir l’effort par requête dans Responses :

response = client.responses.create(
    model="gpt-6-astra",
    input=[{"role": "user", "content": "Refactorise ce module et explique chaque changement."}],
    reasoning={"effort": "high"},
    max_output_tokens=8000,
)

Appel d’outils sur l’API Responses

tools = [{
    "type": "function",
    "name": "get_build_status",
    "description": "Renvoie l’état du dernier build CI pour une branche.",
    "parameters": {
        "type": "object",
        "properties": {"branch": {"type": "string"}},
        "required": ["branch"],
    },
}]

first = client.responses.create(
    model="gpt-6-astra",
    input=[{"role": "user", "content": "La branche main est-elle verte ? Sinon, résume l’échec."}],
    tools=tools,
    reasoning={"effort": "medium"},
)

calls = [item for item in first.output if item.type == "function_call"]
outputs = []
for call in calls:
    # exécutez votre outil ici
    outputs.append({
        "type": "function_call_output",
        "call_id": call.call_id,
        "output": '{"status": "failed", "step": "unit-tests", "log_url": "https://ci.example/123"}',
    })

second = client.responses.create(
    model="gpt-6-astra",
    input=[{"role": "user", "content": "La branche main est-elle verte ? Sinon, résume l’échec."}]
          + list(first.output) + outputs,
    tools=tools,
    reasoning={"effort": "medium"},
)
print(second.output_text)

Sorties structurées et streaming

response = client.responses.create(
    model="gpt-6-astra",
    input="Extrais le model ID, la fenêtre de contexte et la limite de sortie de ce texte : ...",
    text={
        "format": {
            "type": "json_schema",
            "name": "model_spec",
            "schema": {
                "type": "object",
                "properties": {
                    "model_id": {"type": "string"},
                    "context_tokens": {"type": "integer"},
                    "max_output_tokens": {"type": "integer"},
                },
                "required": ["model_id", "context_tokens", "max_output_tokens"],
                "additionalProperties": False,
            },
            "strict": True,
        }
    },
    reasoning={"effort": "low"},
)
print(response.output_text)

Migrer depuis GPT-5.6

Le tableau suivant présente les exigences de migration OpenAI. Sur EvoLink, vérifiez chaque champ de requête et chaque fonction optionnelle avant de déplacer le trafic ; changer le model ID ne suffit pas à prouver la compatibilité.

Le diff pour un appel Chat Completions typique :

 response = client.chat.completions.create(
-    model="gpt-5.6-sol",
+    model="gpt-6-astra",
     messages=messages,
-    temperature=0.2,
-    reasoning_effort="none",
+    reasoning_effort="low",
 )

Règles de coût : 272K, cache, Batch et Flex

Règle 1 : au-delà de 272K tokens d’entrée, la requête entière est retarifée

Les tarifs d’entrée et de cache doublent et le tarif de sortie passe à 1,5× pour la requête entière, pas seulement pour les tokens au-delà du seuil.

Huit mille tokens de plus doublent presque la facture. Comptez les tokens avant d’envoyer, compactez le contexte à l’approche de la tranche, ou routez la requête vers GPT-5.6 Sol, dont le tarif de contexte long est de 8 $ / 30 $.

Règle 2 : le cache est rentable dès la première réutilisation

• sans cache : 10 × (k + 1) dollars par million de tokens de préfixe
• avec cache : 12,50 + 1 × k

Règle 3 : Batch et Flex coûtent la moitié

Chez OpenAI, Batch et Flex coûtent 50 % du tarif Standard. Ils peuvent convenir aux évaluations hors ligne, aux traitements nocturnes et aux reprises de données. Fast coûte 2×, sans SLA de latence pour Astra, et n’est pas disponible avec la résidence des données dans l’UE. La disponibilité et la facturation de ces modes sur EvoLink restent à vérifier ; n’appliquez pas les remises du fournisseur à une estimation EvoLink sans confirmation propre à la route.

Combiner les règles

Rate limits et repli

OpenAI publie les rate limits d’Astra par niveau d’usage. Ces chiffres comptent parce qu’une seule requête à contexte plein peut dépasser un budget de tokens par minute.

Sur EvoLink, les limites sont fixées par compte ; consultez votre dashboard avant un test de charge. Trois modes d’échec méritent un traitement explicite :

1. 400 sur la forme de la requête. temperature, top_p, effort none ou outils sur Chat Completions. Corrigez la requête ; ne réessayez pas.
2. 429 ou 5xx. Réessayez avec backoff, puis basculez vers gpt-5.6-sol sur la même clé. Le guide timeout, retry et repli décrit le schéma.
3. Tâche arrêtée par le moniteur de sécurité d’OpenAI. Astra tourne sous une surveillance de désalignement asynchrone ; quand elle se déclenche, la tâche API s’arrête. Journalisez-le, remontez-le à l’opérateur et routez la tâche vers un modèle de repli plutôt que de boucler.

def call_with_fallback(**kwargs):
    for model in ("gpt-6-astra", "gpt-5.6-sol"):
        try:
            return client.responses.create(model=model, **kwargs)
        except Exception as err:  # à restreindre aux 429/5xx en production
            last = err
    raise last

FAQ

Quel model ID utiliser pour GPT-6 ?

Puis-je utiliser des outils avec GPT-6 Astra sur Chat Completions ?

Non. OpenAI documente les appels d’outils pour ce modèle uniquement sur Responses, tandis que Chat Completions accepte le texte et les images. L’entrée image via EvoLink nécessite encore une vérification de la route.

Par quel effort de raisonnement commencer ?

GPT-6 Astra accepte-t-il temperature ?

Comment est facturée une requête au-delà de 272K tokens d’entrée ?

La requête entière passe dans la tranche de contexte long : 2× les tarifs d’entrée et de cache, 1,5× la sortie. Comptez d’abord les tokens et compactez ou découpez à l’approche du seuil.

Qu’est-ce qui change en migrant depuis GPT-5.6 ?

GPT-6 Astra est-il sur Amazon Bedrock ?

Où trouver le prix EvoLink de GPT-6 Astra ?

Sources

• OpenAI : documentation du modèle GPT-6 Astra
• OpenAI : guide du modèle GPT-6 Astra (migration, paramètres non pris en charge, outils réservés à Responses)
• OpenAI : guide du raisonnement
• OpenAI : guide du cache de prompt
• OpenAI : guide du mode Fast
• OpenAI : guide des rate limits
• Tarifs de l’API OpenAI
• OpenAI : annonce de GPT-6 Astra
• AWS : fiches modèles OpenAI dans Amazon Bedrock
• Shinsuke Kagawa : passer de GPT-5.6 Sol à GPT-6 Astra, commencer par l’effort medium