Passer au contenu principal

Catalogue des fournisseurs

Guide API : OpenAI GPT

Utilisez le point de terminaison partagé de complétion de chat client avec les identifiants de modèles OpenAI GPT et la disponibilité du service actuellement publiés.

Parcours
  1. Choisir le produit APIDistinguez les requêtes d’inférence des parcours d’entraînement de modèles.
  2. Lire son contratConsultez la documentation API et la référence OpenAPI correspondantes.
  3. Créer une clé aux droits limitésGénérez et stockez une clé API client en toute sécurité.
  4. Intégrer et vérifierEnvoyez une requête documentée et examinez la réponse.
  5. Surveiller et renouvelerConsultez l’utilisation et révoquez ou renouvelez les clés au besoin.

Modèles OpenAI GPT publiés

Les noms, identifiants de routage exacts, versions et états d’inférence proviennent du registre de modèles activé, lorsqu’il est disponible. Un identifiant vide signifie que le catalogue n’a publié aucune valeur de routage ; ne la déduisez pas du nom du modèle.

Développeur
OpenAI
Accès pour les nouveaux clients
Disponible
Nom du modèleIdentifiant exact du modèleVersionÉtat de l’inférence
Astra 6 Aucun identifiant de routage publié — Sans identifiant public de routage, la disponibilité pour un appel direct ne peut pas être confirmée.
GPT-6.1 Sol gpt-6.1-sol — Actif · Disponible pour l’inférence
GPT-6.1 Terra gpt-6.1-terra — Actif · Disponible pour l’inférence
GPT-6 Luna gpt-6-luna — Actif · Disponible pour l’inférence
GPT-5.6 Sol Aucun identifiant de routage publié — Sans identifiant public de routage, la disponibilité pour un appel direct ne peut pas être confirmée.
GPT-5.6 Terra Aucun identifiant de routage publié — Sans identifiant public de routage, la disponibilité pour un appel direct ne peut pas être confirmée.
GPT-5.6 Luna Aucun identifiant de routage publié — Sans identifiant public de routage, la disponibilité pour un appel direct ne peut pas être confirmée.
GPT-5.5 Aucun identifiant de routage publié — Sans identifiant public de routage, la disponibilité pour un appel direct ne peut pas être confirmée.
GPT-5.4 Aucun identifiant de routage publié — Sans identifiant public de routage, la disponibilité pour un appel direct ne peut pas être confirmée.
GPT-5.4 mini Aucun identifiant de routage publié — Sans identifiant public de routage, la disponibilité pour un appel direct ne peut pas être confirmée.
GPT-5.4 nano Aucun identifiant de routage publié — Sans identifiant public de routage, la disponibilité pour un appel direct ne peut pas être confirmée.

Utiliser ce fournisseur

  • Choisissez un modèle à partir de son identifiant exact et vérifiez son état avant de configurer une application. Le libellé est destiné aux personnes ; seul l’identifiant convient au champ model.
  • Chaque page fournisseur propose des exemples OpenAI-compatible et Claude Messages. Choisissez le protocole utilisé par votre client ; le modèle sélectionné doit également prendre en charge les fonctionnalités demandées.
  • Pour un service réservé aux clients existants, conservez l’accès actuel au compte et ne considérez pas la liste des modèles publiés comme une invitation à souscrire un nouvel abonnement.

Exemples d’API pour les modèles

Choisissez un identifiant de modèle publié, un protocole d’API et un langage pour afficher un exemple de requête. Conservez les clés API client sur un serveur de confiance.

Exigences du protocole

Les requêtes compatibles avec OpenAI utilisent POST /chat/completions à partir de l’URL de base configurée pour l’API client (par défaut : https://fusionpointai.com/api/v1). Authentifiez-vous avec un jeton client dans l’en-tête Authorization: Bearer ; la clé doit autoriser l’inférence. L’URL complète par défaut est https://fusionpointai.com/api/v1/chat/completions.

Fonctionnalités prises en charge

Le point de terminaison de chat compatible avec OpenAI traite actuellement des messages textuels de manière synchrone. Il ne prend en charge ni le streaming ni les appels d’outils.

Installer un client

Installez les clients Python et Node.js sous forme de paquets distincts :

Python: pip install openai anthropic

Node.js: npm install openai @anthropic-ai/sdk

cURL
curl 'https://fusionpointai.com/api/v1/chat/completions' \
  -H "Authorization: Bearer $FUSIONPOINTAI_API_KEY" \
  -H "Content-Type: application/json" \
  --data '{
    "model": "gpt-6.1-sol",
    "messages": [
        {
            "role": "user",
            "content": "Summarize this in one sentence."
        }
    ],
    "temperature": 0.7,
    "max_tokens": 300
}'

Modèles de requête

Protéger les clés API

Créez une clé API client autorisant l’inférence, puis transmettez-la à un processus serveur via son gestionnaire de secrets ou son environnement.

  1. Définissez FUSIONPOINTAI_API_KEY dans l’environnement du serveur ; n’intégrez pas la clé au code du navigateur et ne la versionnez pas.
  2. Utilisez HTTPS et limitez la clé au compte et aux autorisations d’inférence nécessaires à l’application.
  3. Masquez les en-têtes authorization et x-api-key dans les journaux, traces et demandes d’assistance ; révoquez toute clé susceptible d’avoir été exposée.
Bash
export FUSIONPOINTAI_API_KEY="YOUR_CUSTOMER_API_KEY"

Choisir un identifiant de modèle exact

Le champ model sert au routage ; ce n’est pas un libellé d’affichage. Choisissez un identifiant publié dans le catalogue de modèles actuel.

  1. Sélectionnez un modèle actif ou ancien indiqué comme disponible pour l’inférence.
  2. Reprenez son identifiant à l’identique, ponctuation et suffixes de version compris ; ne le déduisez jamais du nom du modèle.
  3. Si aucun identifiant n’est publié, attendez que le catalogue en fournisse un au lieu d’en inventer un.
Python
model_id = "gpt-6.1-sol"
# Use this exact identifier with either protocol.

Envoyer des messages système et un historique multi-tour

Conservez l’ordre des échanges et n’utilisez que les rôles et formats de contenu pris en charge par le protocole et le modèle choisis.

  1. Pour les requêtes compatibles avec OpenAI, envoyez les messages system, user et assistant dans l’ordre, avec un contenu textuel.
  2. Pour Claude Messages, transmettez les instructions système prises en charge et les tours user/assistant ordonnés dans les champs propres au protocole.
  3. Ne conservez que le contexte nécessaire à l’application et respectez la fenêtre de contexte du modèle sélectionné.
Python
response = client.messages.create(
    model="gpt-6.1-sol",
    max_tokens=512,
    system="Answer in clear, concise German.",
    messages=[
        {"role": "user", "content": "What is an API?"},
        {"role": "assistant", "content": "An API lets software exchange requests and responses."},
        {"role": "user", "content": "Give a practical example."},
    ],
)
for block in response.content:
    if block.type == "text":
        print(block.text)

Demander des réponses JSON

Si l’application attend une sortie structurée, validez-la selon son propre schéma avant de l’utiliser.

  1. Utilisez les options de sortie structurée prises en charge par le protocole choisi et le modèle amont sélectionné.
  2. Considérez le JSON généré comme une donnée non fiable : analysez-le, validez les champs et types requis, puis gérez les sorties invalides.
  3. Ne présumez pas qu’un mode JSON est disponible pour une combinaison modèle-protocole sans confirmation dans la documentation du modèle.
Python
import json

# JSON is generated content, not trusted application input.
response = client.messages.create(
    model="gpt-6.1-sol", max_tokens=256,
    messages=[{"role": "user", "content": 'Return only JSON with a string field named "summary". Explain an API in one sentence.'}],
)
text = "".join(block.text for block in response.content if block.type == "text")
try:
    result = json.loads(text)
    if not isinstance(result, dict) or not isinstance(result.get("summary"), str):
        raise ValueError("Unexpected response schema")
    print(result["summary"])
except (json.JSONDecodeError, ValueError) as error:
    print("Handle invalid model output:", error)

Recevoir un flux SSE en temps réel

Le streaming dépend du protocole et du modèle amont sélectionnés ; une réponse JSON classique n’est pas un flux.

  1. Le chat compatible avec OpenAI renvoie actuellement du texte de façon synchrone et ne propose pas de streaming.
  2. Pour Claude Messages, utilisez le mode stream si le modèle amont le prend en charge ; le proxy relaie les événements natifs server-sent events.
  3. Traitez les événements au fil de leur arrivée, arrêtez proprement à la fin ou en cas d’erreur, et ne considérez pas une sortie partielle comme une réponse terminée.
Python
# client is the Anthropic client configured above.
with client.messages.stream(
    model="gpt-6.1-sol", max_tokens=512,
    messages=[{"role": "user", "content": "Explain API authentication."}],
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)
    final_message = stream.get_final_message()
print("\nStop reason:", final_message.stop_reason)

Gérer les outils, blocs de contenu et erreurs

Préservez les structures propres au protocole et définissez explicitement le comportement de l’application pour les appels d’outils, contenus multimodaux et échecs.

  1. Le chat compatible avec OpenAI ne prend actuellement en charge ni les appels d’outils ni les blocs de contenu non textuels.
  2. Claude préserve les blocs de contenu natifs ainsi que les données d’utilisation et de résultat des outils lorsque le modèle amont les prend en charge ; validez les noms et arguments des outils avant exécution.
  3. Vérifiez le statut HTTP et le corps de la réponse, distinguez les erreurs d’authentification, d’autorisation, de validation et de limitation de débit, puis réessayez les erreurs transitoires avec temporisation exponentielle.
Python
import json
from datetime import datetime, timezone
from anthropic import APIError

messages = [{"role": "user", "content": "What time is it in UTC?"}]
tools = [{
    "name": "current_utc_time", "description": "Read the current UTC time.",
    "input_schema": {"type": "object", "properties": {}, "additionalProperties": False},
}]
try:
    reply = client.messages.create(model="gpt-6.1-sol", max_tokens=256, messages=messages, tools=tools)
    results = []
    for block in reply.content:
        if block.type == "tool_use":
            if block.name != "current_utc_time" or block.input != {}:
                raise ValueError("Unapproved tool request")
            results.append({"type": "tool_result", "tool_use_id": block.id,
                            "content": json.dumps({"utc": datetime.now(timezone.utc).isoformat()})})
    if results:
        messages.append({"role": "assistant", "content": reply.content})
        messages.append({"role": "user", "content": results})
        reply = client.messages.create(model="gpt-6.1-sol", max_tokens=256, messages=messages, tools=tools)
    print("".join(block.text for block in reply.content if block.type == "text"))
except APIError as error:
    # Log status only; never log keys or private prompts.
    print("API request failed:", getattr(error, "status_code", None))

Questions fréquentes

Puis-je utiliser le nom affiché du modèle dans une requête ?

Utilisez uniquement l’identifiant exact publié pour l’inférence. Le nom affiché n’est pas une valeur de routage ; ne devinez jamais un identifiant non publié.

Quelle variable d’environnement contient la clé client ?

Utilisez FUSIONPOINTAI_API_KEY pour les deux protocoles. Conservez sa valeur dans l’environnement d’un serveur de confiance, jamais dans du code client ou des journaux.

Quelle URL utiliser avec le client OpenAI ?

Utilisez l’URL de base configurée pour l’API client, qui est https://fusionpointai.com/api/v1 par défaut. Le point de terminaison de chat complète l’URL avec /chat/completions.

Pourquoi l’URL de base du SDK Claude diffère-t-elle de celle de cURL ?

Le SDK Anthropic ajoute /v1/messages ; définissez donc son URL de base sur https://fusionpointai.com/api. Une requête HTTP directe utilise l’URL complète /api/v1/messages.

Le chat compatible avec OpenAI prend-il en charge le streaming ou les outils ?

Non. Le point de terminaison actuel ne traite que des messages textuels de manière synchrone ; il ne propose ni streaming ni appels d’outils.

Tous les modèles Claude prennent-ils en charge les blocs, outils ou flux ?

Non. Ces fonctionnalités natives sont préservées uniquement si le modèle amont sélectionné les prend en charge. Vérifiez les capacités du modèle et gérez les requêtes non prises en charge.

Claude Messages · POST /messages

Les requêtes Claude Messages utilisent POST /api/v1/messages. Envoyez la clé client dans x-api-key et définissez anthropic-version sur 2023-06-01. L’URL de base du SDK Anthropic est https://fusionpointai.com/api, car le SDK ajoute /v1/messages ; l’authentification Bearer est également acceptée.

Le proxy Claude Messages préserve les blocs de contenu natifs, les données des outils et le véritable streaming SSE lorsque le modèle amont sélectionné les prend en charge.

ChampTypeObligatoireContraintes
model string Oui {"minLength":1,"maxLength":160}
max_tokens integer Oui {"minimum":1,"maximum":100000}
messages array Oui {"minItems":1,"maxItems":100,"items":{"type":"object","required":["role","content"],"properties":{"role":{"type":"string","enum":["user","assistant"]},"content":{"oneOf":[{"type":"string"},{"type":"array","items":{"type":"object","required":["type"],"properties":{"type":{"type":"string","maxLength":80}},"additionalProperties":true}}]}}}}
system string | array Non {"oneOf":[{"type":"string"},{"type":"array","items":{"type":"object","required":["type","text"],"properties":{"type":{"const":"text"},"text":{"type":"string"}},"additionalProperties":true}}]}
stream boolean Non {"default":false}
temperature number Non {"minimum":0,"maximum":1}
top_p number Non {"minimum":0,"maximum":1}
top_k integer Non {"minimum":0,"maximum":100000}
stop_sequences array Non {"items":{"type":"string"}}
tools array Non {"items":{"type":"object","additionalProperties":true}}
tool_choice object Non {"additionalProperties":true}
thinking object Non {"additionalProperties":true}
metadata object Non {"additionalProperties":true}
output_config object Non {"additionalProperties":true}
service_tier string Non []
Claude Messages · Exemple
{
    "id": "msg_example",
    "type": "message",
    "role": "assistant",
    "model": "gpt-6.1-sol",
    "content": [
        {
            "type": "text",
            "text": "A concise answer to the supplied question."
        }
    ],
    "stop_reason": "end_turn",
    "stop_sequence": null,
    "usage": {
        "input_tokens": 12,
        "output_tokens": 10
    }
}
{"type":"error","error":{"type":"authentication_error","message":"Invalid or missing API key."}}

Envoyer votre première requête

Envoyez des requêtes HTTPS à l’URL de base ci-dessous. Utilisez POST /chat/completions pour le chat textuel compatible avec OpenAI ou POST /messages pour Claude Messages. Choisissez le protocole dans l’atelier de modèles et reprenez son URL exacte ainsi que son format JSON.

URL de base de l’API: https://fusionpointai.com/api/v1

Créez ou gérez une clé API client dans les paramètres de clés API de votre compte. Envoyez-la comme jeton bearer et conservez-la sur un serveur de confiance ; ne l’intégrez ni au code du navigateur, ni au contrôle de version, ni à un journal public.

La clé doit avoir la portée ai:inference et l’accès à l’abonnement client concerné. La clé API publique n’est pas le mot de passe du compte et ne doit pas être partagée.

Ces exemples utilisent le point de terminaison enregistré de complétion de chat JSON et les clients Python et Node.js compatibles avec OpenAI. Stockez la clé dans la variable d’environnement FUSIONPOINTAI_API_KEY. Remplacez la valeur du modèle uniquement par un identifiant exact répertorié ci-dessus.

Shell
# Install the client for your application language.
# Python:
python -m pip install openai
# Node.js:
npm install openai

# Bash: enter the key without storing it in shell history.
read -rs -p 'FusionPointAI API key: ' FUSIONPOINTAI_API_KEY
export FUSIONPOINTAI_API_KEY
printf '\n'
# After finishing:
# unset FUSIONPOINTAI_API_KEY
cURL — Exemple
curl 'https://fusionpointai.com/api/v1/chat/completions' \
  -H "Authorization: Bearer $FUSIONPOINTAI_API_KEY" \
  -H "Content-Type: application/json" \
  --data '{
    "model": "gpt-6.1-sol",
    "messages": [
        {
            "role": "user",
            "content": "Summarize this in one sentence."
        }
    ],
    "temperature": 0.7,
    "max_tokens": 300
}'
Python — Exemple
import os
from openai import OpenAI

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

response = client.chat.completions.create(
    model="gpt-6.1-sol",
    messages=[{"role": "user", "content": "Summarize this in one sentence."}],
    temperature=0.7,
    max_tokens=300,
)
print(response.choices[0].message.content)
Node.js — Exemple
import OpenAI from "openai";

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

const response = await client.chat.completions.create({
  model: "gpt-6.1-sol",
  messages: [{ role: "user", content: "Summarize this in one sentence." }],
  temperature: 0.7,
  max_tokens: 300,
});
console.log(response.choices[0].message.content);

OpenAI · Contrat de requête et de réponse

Le point de terminaison accepte le format JSON. Les messages sont envoyés dans l’ordre ; chacun comporte un rôle pris en charge et un contenu de type chaîne. Les paramètres de génération facultatifs doivent respecter les limites de validation ci-dessous. La réponse est un objet JSON chat.completion contenant des choix et, si le fournisseur les renvoie, des données d’utilisation des jetons.

ChampTypeObligatoireContraintes
modelstringOuiChaîne de 160 caractères maximum ; utilisez un identifiant publié.
messagesarrayOuiTableau de 1 à 100 messages.
messages[].rolestringOuiChaque rôle est system, user ou assistant.
messages[].contentstringOuiLe contenu de chaque message est une chaîne de 100 000 caractères maximum.
temperaturenumberNonNombre facultatif compris entre 0 et 2.
max_tokensintegerNonEntier facultatif de 1 à 100 000 ; le modèle choisi peut imposer une limite de sortie inférieure.

Structure de la réponse

Une réponse réussie contient id, object (chat.completion), created, model et choices. Un choix contient son index, un message assistant et finish_reason. Le nombre de jetons peut figurer dans usage. Des limites propres au fournisseur peuvent s’appliquer même si la requête passe la validation de la passerelle.

Exemple · JSON
{
    "id": "chatcmpl_example",
    "object": "chat.completion",
    "created": 1700000000,
    "model": "gpt-6.1-sol",
    "choices": [
        {
            "index": 0,
            "message": {
                "role": "assistant",
                "content": "A concise summary of the supplied text."
            },
            "finish_reason": "stop"
        }
    ],
    "usage": {
        "prompt_tokens": 12,
        "completion_tokens": 10,
        "total_tokens": 22
    }
}

Accès, limites et bonnes pratiques d’utilisation

Les abonnements client actifs ne décomptent pas les requêtes ni les jetons d’un quota ; les clés sandbox sont limitées au volume mensuel publié. Cette règle relative à l’abonnement est indépendante des limites techniques du modèle et des systèmes amont.

  • La taille de la fenêtre de contexte, la sortie maximale, les fonctionnalités de requête prises en charge et les contrôles temporaires du trafic amont varient. Consultez les informations sur le fournisseur et le modèle avant d’envoyer du trafic de production.
  • Le point de terminaison applique une limite applicative de 60 requêtes par minute pour chaque identité de limitation concernée. Une réponse HTTP 429 peut aussi signaler des contrôles temporaires du trafic amont ; réessayez avec un délai progressif plutôt qu’en boucle serrée.
  • Utilisez HTTPS, conservez les clés côté serveur, n’accordez que la portée d’inférence requise et révoquez rapidement toute clé susceptible d’avoir été exposée.
  • Chat Completions traite du texte de façon synchrone. Claude Messages prend séparément en charge les blocs de contenu natifs, les outils et le flux SSE lorsque le modèle sélectionné le permet. Les autres points de terminaison des fournisseurs ne font pas partie de ces contrats.

Accès au fournisseur et conditions liées au compte

Authentifiez-vous avec une clé API client dotée de la portée ai:inference et rattachée à un compte ayant accès à ce service. Le catalogue indique si de nouveaux clients sont actuellement acceptés. Il n’accorde aucun accès, ne crée pas d’abonnement et ne remplace pas les autorisations du compte ou de la clé.

Erreurs et dépannage

Les erreurs de validation et les résultats inutilisables du fournisseur renvoyés par le point de terminaison sont présentés dans un objet JSON error comprenant message, type et code ; les erreurs de validation peuvent aussi préciser les champs concernés. N’incluez pas de clés API ni le contenu privé d’invites dans vos tickets d’assistance.

Les erreurs de validation de requête et les échecs du fournisseur renvoyés par l’opération de chat utilisent un objet error. Le middleware d’authentification, de portée et de limitation peut à la place renvoyer un champ message à la racine. Examinez ensemble le statut et le corps de la réponse.

Code HTTPSignification et prochaine étape
400Corps de requête invalide. Vérifiez les champs obligatoires, le nombre et le contenu des messages, les valeurs de rôle, temperature et max_tokens.
401Clé bearer absente ou invalide. Vérifiez que la clé est active et transmise dans l’en-tête Authorization.
403La clé ne dispose peut-être pas de la portée d’inférence requise ou de l’accès au compte. Vérifiez les autorisations de la clé et l’accès à l’abonnement.
429Une limite de requêtes ou un contrôle du trafic amont s’est appliqué. Réduisez le rythme et réessayez avec un délai exponentiel.
500Le fournisseur n’a pas renvoyé de complétion exploitable ou le service a échoué. Réessayez avec prudence ; contactez l’assistance en indiquant l’heure et un identifiant de requête expurgé.

Questions fréquentes

Puis-je utiliser le nom affiché comme valeur de model ?

Uniquement si cette chaîne exacte est également publiée comme identifiant de routage. Utilisez la colonne des identifiants ; si elle est vide, aucune valeur de routage n’est publiée ici.

Puis-je utiliser le SDK Claude ?

Oui. Choisissez Claude dans l’atelier de modèles et utilisez le SDK Anthropic avec l’URL de base indiquée. Il envoie des requêtes natives Messages, et non Chat Completions. Les fonctionnalités disponibles dépendent toujours du modèle.

Pourquoi un modèle répertorié peut-il échouer ?

Le modèle peut être indisponible, l’accès peut ne pas être activé pour votre compte ou votre clé, ou une limite technique amont peut s’appliquer. Vérifiez l’état, l’identifiant, la portée de la clé et la réponse d’erreur.

Que faut-il inclure dans une demande d’assistance ?

Indiquez le fournisseur, l’identifiant exact du modèle, l’heure de la requête, le statut HTTP et un identifiant de requête expurgé. Retirez les clés API et les données sensibles des invites.