OpenAPI 3.1

Référence de l’API client

Cette page décrit les requêtes et réponses d’inférence client prises en charge. Téléchargez le document OpenAPI lisible par machine pour vos outils.

Télécharger le JSON OpenAPI

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.

Modèle

Langage

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 'https://fusionpointai.com/api/v1/chat/completions' \
  -H "Authorization: Bearer $FUSIONPOINTAI_API_KEY" \
  -H "Content-Type: application/json" \
  --data '{
    "model": "Astra 6",
    "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.

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.
Utilisez HTTPS et limitez la clé au compte et aux autorisations d’inférence nécessaires à l’application.
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.

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.

Sélectionnez un modèle actif ou ancien indiqué comme disponible pour l’inférence.
Reprenez son identifiant à l’identique, ponctuation et suffixes de version compris ; ne le déduisez jamais du nom du modèle.
Si aucun identifiant n’est publié, attendez que le catalogue en fournisse un au lieu d’en inventer un.

model_id = "Astra 6"
# 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.

Pour les requêtes compatibles avec OpenAI, envoyez les messages system, user et assistant dans l’ordre, avec un contenu textuel.
Pour Claude Messages, transmettez les instructions système prises en charge et les tours user/assistant ordonnés dans les champs propres au protocole.
Ne conservez que le contexte nécessaire à l’application et respectez la fenêtre de contexte du modèle sélectionné.

response = client.messages.create(
    model="Astra 6",
    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.

Utilisez les options de sortie structurée prises en charge par le protocole choisi et le modèle amont sélectionné.
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.
Ne présumez pas qu’un mode JSON est disponible pour une combinaison modèle-protocole sans confirmation dans la documentation du modèle.

import json

# JSON is generated content, not trusted application input.
response = client.messages.create(
    model="Astra 6", 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.

Le chat compatible avec OpenAI renvoie actuellement du texte de façon synchrone et ne propose pas de streaming.
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.
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.

# client is the Anthropic client configured above.
with client.messages.stream(
    model="Astra 6", 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.

Le chat compatible avec OpenAI ne prend actuellement en charge ni les appels d’outils ni les blocs de contenu non textuels.
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.
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.

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="Astra 6", 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="Astra 6", 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.

Champ	Type	Obligatoire	Contraintes
`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	`[]`

{
    "id": "msg_example",
    "type": "message",
    "role": "assistant",
    "model": "Astra 6",
    "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."}}

Démarrage rapide avec les SDK

Utilisez l’URL de base de production avec un client Python ou Node.js compatible, ou envoyez la même requête JSON avec cURL.

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

Envoyez la clé API client dans l’en-tête Authorization: Bearer. La clé doit avoir la portée ai:inference et l’accès au compte pour ce service. Conservez-la sur un serveur de confiance.

# 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 'https://fusionpointai.com/api/v1/chat/completions' \
  -H "Authorization: Bearer $FUSIONPOINTAI_API_KEY" \
  -H "Content-Type: application/json" \
  --data '{
    "model": "Jurassic-2",
    "messages": [
        {
            "role": "user",
            "content": "Summarize this in one sentence."
        }
    ],
    "temperature": 0.7,
    "max_tokens": 300
}'

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="Jurassic-2",
    messages=[{"role": "user", "content": "Summarize this in one sentence."}],
    temperature=0.7,
    max_tokens=300,
)
print(response.choices[0].message.content)

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: "Jurassic-2",
  messages: [{ role: "user", content: "Summarize this in one sentence." }],
  temperature: 0.7,
  max_tokens: 300,
});
console.log(response.choices[0].message.content);

OpenAI · Champs de la requête

Les valeurs model sont les identifiants exacts, enregistrés et actuellement publiés pour l’inférence. Si aucun n’est publié, consultez le catalogue des fournisseurs avant d’envoyer une requête.

Champ	Type	Obligatoire	Contraintes
`model`	`string`	Oui	160 caractères maximum ; utilisez un identifiant exact publié.
`messages`	`array`	Oui	De 1 à 100 messages, envoyés dans l’ordre.
`messages[].role`	`string`	Oui	system, user ou assistant.
`messages[].content`	`string`	Oui	100 000 caractères maximum par message.
`temperature`	`number`	Non	De 0 à 2.
`max_tokens`	`integer`	Non	De 1 à 100 000 ; le modèle peut imposer une limite inférieure.

Réponse en cas de succès

Une réponse JSON réussie contient id, object (chat.completion), created, model et choices. Un choix comprend index, un message assistant et finish_reason. Des données d’utilisation des jetons peuvent également être renvoyées.

{
    "id": "chatcmpl_example",
    "object": "chat.completion",
    "created": 1700000000,
    "model": "Jurassic-2",
    "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
    }
}

Champ	Type	Signification
`id`	`string`	Identifiant unique de complétion.
`object`	`string`	Type de réponse : chat.completion.
`created`	`integer`	Heure de création au format horodatage Unix.
`model`	`string`	Identifiant du modèle utilisé pour la complétion.
`choices`	`array`	Variantes de complétion avec un message assistant et une raison de fin.
`usage`	`object`	Nombre de jetons, lorsqu’il est renvoyé.

Limites de débit et erreurs

Les abonnements client actifs ne décomptent pas les requêtes ni les jetons d’un quota ; les clés sandbox utilisent le volume mensuel publié. Les fenêtres de contexte des modèles, les limites de sortie et les contrôles temporaires du trafic restent applicables. Chat Completions traite du texte de façon synchrone ; Claude Messages préserve les blocs de contenu natifs, les outils et le flux SSE pris en charge. Consultez les schémas des opérations distinctes avant d’envoyer des requêtes.

L’opération de chat renvoie les erreurs de validation et les échecs du fournisseur dans un objet error. Le middleware d’authentification et de portée peut renvoyer à la place un champ message à la racine ; le statut et l’enveloppe dépendent de la couche qui a rejeté la requête.

Code HTTP	Signification
`200`	Complétion créée avec succès.
`400`	Corps de requête ou paramètre invalide.
`401`	Clé API bearer absente ou invalide.
`403`	Portée de clé requise ou accès au compte manquant.
`429`	Limite applicative ou contrôle temporaire du trafic amont ; réessayez avec un délai progressif.
`500`	Le service n’a pas pu renvoyer de complétion exploitable.