LLM API

Le LLM API expose des endpoints d'appel direct de modèles via Felo API Platform. Utilisez-le lorsque vous voulez appeler des modèles de langage généralistes, réutiliser des clients compatibles OpenAI ou Anthropic, ou connecter des frameworks d'agents à Felo API Platform.

Le LLM API inclut actuellement trois surfaces d'appel de modèles compatibles chat :

• POST /api/v1/responses : compatible OpenAI Responses
• POST /api/v1/chat/completions : compatible OpenAI Chat Completions
• POST /api/v1/messages : compatible Anthropic Messages

API Decisions

POST https://openapi.felo.ai/api/v1/decisions

Envoyez un état et des questions typées et étroites à jev-1.13 (également accepté : typesafe/jev-1.13). Utilisez /api/v1/decisions, et non les endpoints Chat Completions, Messages ou Responses. Le streaming n'est pas pris en charge.

Champs de requête

• model : jev-1.13
• state : contexte à évaluer ; une chaîne ou une valeur JSON.
• questions : questions nommées utilisant type, instructions et criteria.

import os
import requests

response = requests.post(
    "https://openapi.felo.ai/api/v1/decisions",
    headers={"Authorization": f"Bearer {os.environ['FELO_API_KEY']}"},
    json={
        "model": "jev-1.13",
        "state": "Help! My payouts have been failing for 3 days.",
        "questions": {
            "is_urgent": {
                "type": "noul",
                "instructions": "Does this message convey urgency?",
                "criteria": {"true": "Time-sensitive", "false": "No urgency"},
            },
            "department": {
                "type": "choice",
                "instructions": "Which team should handle this?",
                "criteria": {
                    "billing": "Payments, invoicing, refunds",
                    "technical": "Bugs, outages, integrations",
                    "sales": "Pricing, upgrades, new accounts",
                },
            },
            "frustration": {
                "type": "score",
                "instructions": "How frustrated is the customer?",
                "criteria": ["Calm", "Frustrated", "Very angry"],
            },
        },
    },
    timeout=60,
)
response.raise_for_status()
answers = response.json()["answers"]
print(answers["is_urgent"]["noul"])
print(answers["department"]["choice"], answers["department"]["probabilities"])
print(answers["frustration"]["score"])

Types de réponse

noul : une probabilité de 0 à 1. choice : l'option sélectionnée et sa distribution de probabilité. score : un score numérique pour des critères ordonnés, avec sa distribution.

Les erreurs utilisent error.code (statut HTTP numérique) et error.message. Traitez les réponses non-2xx avant de lire answers.

Utilisation et tarification

La réponse inclut usage.input_tokens, usage.output_tokens et peut inclure usage.cost. Tarifs de référence vérifiés le 2026-10-12 : entrée 0,042 USD par million de jetons ; sortie 0 USD. Un tarif de sortie nul ne rend pas l'usage d'entrée gratuit. Les tarifs peuvent changer ; utilisez le prix publié du modèle et les remises de compte applicables pour vos estimations.

Authentification

Les requêtes au LLM API nécessitent une clé Felo API Platform. Utilisez Authorization: Bearer ... ou X-API-Key.

Authorization: Bearer YOUR_API_KEY

X-API-Key: YOUR_API_KEY

Consultez le guide d'authentification pour les détails sur la création et la gestion des clés API.

URL de base

Utilisez l'hôte public de Felo API Platform :

https://openapi.felo.ai

Pour les clients SDK, configurez l'URL de base propre au protocole indiquée dans Utilisation de base.

En-têtes communs

Découverte des modèles

Le catalogue général inclut toutes les catégories de modèles. Utilisez les listes dédiées pour découvrir les modèles vidéo ou de décision :

Les trois endpoints acceptent le paramètre de requête facultatif provider (par exemple openrouter) et renvoient {"object":"list","data":[...]}. Chaque élément contient id, object, created, owned_by et model_kind. Les listes dédiées utilisent la catégorie effective après application des surcharges de mapping des fournisseurs activés.

Seuls les modèles activés, listés, non supprimés et dont la tarification actuelle correspond aux conditions du fournisseur sont renvoyés ; un prix nul est valide. Les modèles nouvellement synchronisés restent masqués jusqu'à ce qu'un administrateur les liste. Toutes les listes partagent l'ordre configuré, avec le nom et l'ID du modèle comme critères de départage. Aucune correspondance renvoie HTTP 200 avec un tableau data vide. La découverte lit le catalogue local et n'invoque ni ne facture d'appel de modèle.

Seul GET /api/v1/models accepte exclude_video_and_decisions (booléen, false par défaut). Définissez-le sur true pour exclure les types effectifs video_generation et decisions ; les modèles d'image restent éligibles. Il peut être combiné avec provider. L'omettre ou le définir sur false conserve le catalogue complet. Les valeurs booléennes invalides renvoient HTTP 422.

curl "https://openapi.felo.ai/api/v1/models?exclude_video_and_decisions=true&provider=openrouter" \
  -H "Authorization: Bearer ${FELO_API_KEY}"
curl "https://openapi.felo.ai/api/v1/videos/models?provider=openrouter" \
  -H "Authorization: Bearer ${FELO_API_KEY}"
curl "https://openapi.felo.ai/api/v1/decisions/models?provider=openrouter" \
  -H "Authorization: Bearer ${FELO_API_KEY}"

Choisissez un endpoint d'appel selon model_kind : chat pour Responses, Chat Completions ou Messages selon ce que le modèle prend en charge ; video_generation pour POST /api/v1/videos/generations ; decisions pour POST /api/v1/decisions ; image_generation pour POST /api/v1/images/generations. Les détails restent disponibles à GET /api/v1/models/{model_id}. Un modèle listé n'est pas nécessairement compatible avec chaque endpoint d'appel.

Les modèles d'image n'ont pas d'endpoint de liste dédié. Filtrez GET /api/v1/models sur model_kind: "image_generation". Consultez Génération d'images pour les champs de requête d'image.

Modèles et tarifs

Les requêtes utilisent le canal par défaut du modèle, sauf si vous en épinglez un avec X-Felo-Channel. Passez une liste ordonnée, séparée par des virgules, de codes de canal publics issus du catalogue de modèles ; omettez l'en-tête pour utiliser celui par défaut. N'utilisez default que seul. Seul le groupe de fournisseurs du premier canal est soumis ; il n'y a pas de repli automatique. Consultez Canaux et routage fournisseur.

Les prix sont indiqués en USD. Les tarifs par jeton sont affichés pour 1 million de jetons par souci de lisibilité ; la facturation utilise la précision par jeton de l'instantané tarifaire en vigueur. Les tarifs de cache ne s'appliquent que lorsque la réponse du protocole inclut l'usage du cache. Un tiret signifie qu'aucun tarif distinct ni aucune limite publiée n'existe. L'usage de la recherche web, lorsqu'il est rapporté par le service de modèle, est facturé $0.01 par recherche.

Claude Haiku 5.5 utilise une tarification par paliers : les prompts jusqu'à 100K de jetons sont facturés aux tarifs standard ci-dessus, et les requêtes dont le prompt dépasse 100K de jetons sont facturées $0.50 en entrée, $2.50 en sortie, $0.05 en lecture de cache et $0.0625 en écriture de cache par 1M de jetons pour toute la requête.

GPT-5.6 est disponible en trois paliers : Luna pour les charges rapides et économiques ; Terra pour le codage, le raisonnement et les tâches agentiques équilibrés ; et Sol pour le raisonnement complexe et le codage haut de gamme. Chaque palier expose aussi un ID de modèle -pro (gpt-5.6-luna-pro, gpt-5.6-terra-pro et gpt-5.6-sol-pro) qui utilise le même modèle sous-jacent avec le mode de raisonnement pro. La tarification, la longueur de contexte et la sortie maximale sont inchangées pour les ID -pro.

DeepSeek V4 Flash prend en charge les modes raisonnement et non-raisonnement, la sortie JSON, les appels d'outils, l'API Responses et la compatibilité avec l'API Anthropic. Il est disponible via les surfaces Responses, Chat Completions et Messages de Felo. La tarification de l'écriture de cache n'est pas encore publiée.

Utilisation de base

Ces exemples utilisent les SDK officiels OpenAI et Anthropic. Définissez FELO_API_KEY sur votre clé Felo API Platform avant d'exécuter les exemples.

export FELO_API_KEY="YOUR_API_KEY"

Installer les SDK

SDK OpenAI

Utilisez le SDK OpenAI pour l'API Responses et l'API Chat Completions.

##### JavaScript

npm install openai

##### Python

pip install openai

SDK Anthropic

Utilisez le SDK Anthropic pour l'API Messages.

##### JavaScript

npm install @anthropic-ai/sdk

##### Python

pip install anthropic

Configurer les clients

Les endpoints compatibles OpenAI utilisent l'URL de base du SDK OpenAI avec /api/v1, car le SDK ajoute des chemins de ressources tels que /responses et /chat/completions.

JavaScript

import OpenAI from "openai";

const openai = new OpenAI({
  apiKey: process.env.FELO_API_KEY,
  baseURL: "https://openapi.felo.ai/api/v1",
});

Python

import os
from openai import OpenAI

openai = OpenAI(
    api_key=os.environ.get("FELO_API_KEY"),
    base_url="https://openapi.felo.ai/api/v1",
)

Les endpoints compatibles Anthropic utilisent l'URL de base du SDK Anthropic sans /v1, car le SDK ajoute /v1/messages.

JavaScript

import Anthropic from "@anthropic-ai/sdk";

const anthropic = new Anthropic({
  apiKey: process.env.FELO_API_KEY,
  baseURL: "https://openapi.felo.ai/api",
});

Python

import os
from anthropic import Anthropic

anthropic = Anthropic(
    api_key=os.environ.get("FELO_API_KEY"),
    base_url="https://openapi.felo.ai/api",
)

Utiliser l'API Responses

Utilisez l'API Responses pour les nouvelles intégrations compatibles OpenAI et les objets de réponse de style agent.

JavaScript

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.FELO_API_KEY,
  baseURL: "https://openapi.felo.ai/api/v1",
});

const response = await client.responses.create({
  model: "gpt-5.6-sol",
  input: "Write a one-sentence bedtime story about a unicorn.",
});

console.log(response.output_text);

Python

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ.get("FELO_API_KEY"),
    base_url="https://openapi.felo.ai/api/v1",
)

response = client.responses.create(
    model="gpt-5.6-sol",
    input="Write a one-sentence bedtime story about a unicorn.",
)

print(response.output_text)

Utiliser Chat Completions

Utilisez Chat Completions lorsque votre application envoie déjà des messages au format OpenAI.

JavaScript

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.FELO_API_KEY,
  baseURL: "https://openapi.felo.ai/api/v1",
});

const completion = await client.chat.completions.create({
  model: "gpt-5.6-sol",
  messages: [
    {
      role: "user",
      content: "Give me one sentence about why API compatibility matters.",
    },
  ],
});

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

Python

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ.get("FELO_API_KEY"),
    base_url="https://openapi.felo.ai/api/v1",
)

completion = client.chat.completions.create(
    model="gpt-5.6-sol",
    messages=[
        {
            "role": "user",
            "content": "Give me one sentence about why API compatibility matters.",
        }
    ],
)

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

Utiliser Messages

Utilisez Messages lorsque votre client ou framework d'agent attend des formes de requête et de réponse compatibles Anthropic.

JavaScript

import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic({
  apiKey: process.env.FELO_API_KEY,
  baseURL: "https://openapi.felo.ai/api",
});

const message = await client.messages.create({
  model: "claude-sonnet-4-6",
  max_tokens: 128,
  messages: [
    {
      role: "user",
      content: "Summarize the value of direct model APIs in one sentence.",
    },
  ],
});

const text = message.content
  .filter((block) => block.type === "text")
  .map((block) => block.text)
  .join("");

console.log(text);

Python

import os
from anthropic import Anthropic

client = Anthropic(
    api_key=os.environ.get("FELO_API_KEY"),
    base_url="https://openapi.felo.ai/api",
)

message = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=128,
    messages=[
        {
            "role": "user",
            "content": "Summarize the value of direct model APIs in one sentence.",
        }
    ],
)

text = "".join(block.text for block in message.content if block.type == "text")
print(text)

Documentation officielle

• Démarrage rapide de l'API OpenAI
• OpenAI Create response
• OpenAI Create chat completion
• API Claude Messages
• SDK TypeScript Anthropic
• SDK Python Anthropic

Pour la configuration des clients d'agents, consultez Configuration de Claude Code et Codex.

Référence des protocoles

Responses

Utilisez cet endpoint pour les clients et intégrations compatibles avec l'API OpenAI Responses.

Endpoint

POST https://openapi.felo.ai/api/v1/responses

Corps de requête

Requête SDK

const response = await client.responses.create({
  model: "gpt-5.6-sol",
  input: "Reply with exactly: responses ok",
});

console.log(response.output_text);

Chemin du texte de réponse

output_text

Chat Completions

Utilisez cet endpoint pour les clients et SDK compatibles avec OpenAI Chat Completions.

Endpoint

POST https://openapi.felo.ai/api/v1/chat/completions

Corps de requête

Requête SDK

const completion = await client.chat.completions.create({
  model: "gpt-5.6-sol",
  messages: [
    {
      role: "user",
      content: "Reply with exactly: chat completions ok",
    },
  ],
});

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

Chemin du texte de réponse

choices[0].message.content

Messages

Utilisez cet endpoint pour les clients et SDK compatibles avec Anthropic Messages.

Endpoint

POST https://openapi.felo.ai/api/v1/messages

Corps de requête

Requête SDK

const message = await client.messages.create({
  model: "claude-sonnet-4-6",
  max_tokens: 64,
  messages: [
    {
      role: "user",
      content: "Reply with exactly: messages ok",
    },
  ],
});

const text = message.content
  .filter((block) => block.type === "text")
  .map((block) => block.text)
  .join("");

console.log(text);

Requête avec blocs de contenu

const message = await client.messages.create({
  model: "claude-sonnet-4-6",
  max_tokens: 64,
  messages: [
    {
      role: "user",
      content: [
        {
          type: "text",
          text: "Reply with exactly: messages ok",
        },
      ],
    },
  ],
});

Chemin du texte de réponse

content[].text

Streaming

Définissez stream sur true pour recevoir des Server-Sent Events. Le format de charge utile des événements suit le protocole sélectionné :

• Les flux Responses renvoient des événements de réponse compatibles Responses.
• Les flux Chat Completions renvoient des chunks de complétion de chat compatibles OpenAI.
• Les flux Messages renvoient des événements de message compatibles Anthropic.

const stream = await client.responses.create({
  model: "gpt-5.6-sol",
  input: "Write one sentence.",
  stream: true,
});

Les clients doivent analyser le flux selon le protocole qu'ils utilisent, plutôt que d'attendre un schéma d'événement commun aux trois endpoints.

Erreurs

Le LLM API renvoie la forme d'erreur du protocole sélectionné dans la mesure du possible. Causes courantes :