FR ▾
Obtenir une clé API

Workflow de l'API LLM en Python : configuration étape par étape

Pointez le SDK OpenAI vers une nouvelle URL de base, utilisez l'ID du modèle uncensored et ajoutez les tentatives, les exécutions parallèles et les appels d'outils couche par couche.

Mis à jour le

Pipeline de blocs lumineux avec des cubes de données se divisant en voies parallèles, représentant un workflow LLM Python

Points clés

  • Installez openai, définissez base_url sur https://api.veo3apis.com/v1 et utilisez le modèle uncensored.
  • Gérez le 429 en attendant Retry-After ; les requêtes échouées ne sont pas facturées.
  • Dimensionnez votre pool de threads selon la clé : 8 workers pour une clé complète, 2 pour la clé d'essai.
  • Lisez X-Balance-USD dans les en-têtes de réponse pour suivre les dépenses par exécution.

Le résumé

Pour créer un script de workflow d'API LLM en Python, installez le SDK OpenAI officiel, définissez l'URL de base sur https://api.veo3apis.com/v1, utilisez votre clé comme clé API et appelez le modèle uncensored. Rien d'autre ne change. Le service est compatible OpenAI, donc chaque schéma que vous connaissez déjà du SDK fonctionne : appels de chat simples, streaming, mode JSON et appel d'outils.

Cet article construit un petit workflow par couches. Vous commencez par un appel unique, puis ajoutez la configuration depuis des variables d'environnement, un wrapper de tentative, un exécuteur parallèle, un appel d'outil et le suivi du solde. Chaque couche est courte et vous pouvez vous arrêter à n'importe laquelle qui couvre vos besoins.

Le modèle est un modèle à poids ouverts exécuté par un fournisseur indépendant. Ce n'est pas l'API officielle d'aucun grand fournisseur et ce n'est pas un routeur, donc il n'y a qu'un seul ID de modèle à retenir. Il gère uniquement du texte. Pas de génération d'images, d'audio ou de vidéo, pas d'embeddings ni de fine-tuning.

Installer le SDK et faire le premier appel

Vous avez besoin de Python 3.9 ou plus récent. Installez le SDK :

pip install openai

Créez une clé depuis la page clé API après vous être inscrit avec Google ou avec un e-mail et un mot de passe. La page propose également une réclamation en un clic pour 0,50 $ de crédit d'essai, valable 7 jours, une fois par personne, sans carte requise. Puis lancez l'appel le plus petit possible :

from openai import OpenAI

client = OpenAI(
    base_url="https://api.veo3apis.com/v1",
    api_key="YOUR_API_KEY",
)

resp = client.chat.completions.create(
    model="uncensored",
    messages=[
        {"role": "system", "content": "You are a concise assistant."},
        {"role": "user", "content": "List three uses for a hosted text API."},
    ],
)

print(resp.choices[0].message.content)
print(resp.usage)

Si cela affiche du texte et un objet d'utilisation, l'authentification, le routage et l'ID du modèle sont corrects. Le SDK envoie votre clé en tant que Authorization: Bearer, et la requête va à POST /v1/chat/completions. Vous pouvez vérifier quels ID de modèle votre clé voit avec client.models.list(), qui appelle GET /v1/models.

Une version brute curl est utile lorsque vous déboguez depuis un serveur sans Python :

curl https://api.veo3apis.com/v1/chat/completions \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model": "uncensored", "messages": [{"role": "user", "content": "Say hello."}]}'

Gardez la configuration dans un seul client

Saisir une clé en dur dans un script est le moyen le plus rapide de la faire fuir dans un dépôt. Lisez les deux valeurs depuis l'environnement, et créez le client à un seul endroit afin que chaque étape du flux de travail le partage.

import os
from openai import OpenAI

client = OpenAI(
    base_url=os.environ.get("LLM_BASE_URL", "https://api.veo3apis.com/v1"),
    api_key=os.environ["LLM_API_KEY"],
    max_retries=0,
    timeout=120,
)

MODEL = "uncensored"


def ask(system: str, user: str, **kwargs) -> str:
    resp = client.chat.completions.create(
        model=MODEL,
        messages=[
            {"role": "system", "content": system},
            {"role": "user", "content": user},
        ],
        **kwargs,
    )
    return resp.choices[0].message.content

Deux choix sont délibérés. max_retries=0 désactive les réessais intégrés du SDK pour que la logique de réessai de la section suivante soit la seule, ce qui facilite la compréhension du comportement. Le délai d'expiration de 120 secondes laisse de la marge pour les longues générations ; la fenêtre de contexte est de 100 000 tokens pour le prompt plus la complétion, et une grande réponse prend du temps à diffuser. Les paramètres d'échantillonnage tels que temperature, top_p, stop, seed et les pénalités passent via **kwargs comme d'habitude.

Relancez les bonnes erreurs

Tout workflow réel atteint des limites de débit tôt ou tard. Une clé complète permet 300 requêtes par minute et 8 en même temps. Une clé d'essai permet 60 par minute et 2 en même temps. Si vous dépassez l'une ou l'autre, l'API renvoie un HTTP 429. Le code d'erreur vous indique quelle limite vous avez atteinte : rate_limited pour les requêtes par minute, concurrency pour trop de requêtes en même temps. En cas de surcharge temporaire, l'API envoie également un 429 avec un en-tête Retry-After: 5.

Les trois cas ont la même solution : attendre, puis réessayer. Ce wrapper respecte l'en-tête et réduit la fréquence des appels en cas d'absence.

from openai import OpenAI

client = OpenAI(
    base_url="https://api.veo3apis.com/v1",
    api_key="YOUR_API_KEY",
)
import time
from openai import RateLimitError, APIConnectionError, APIStatusError


def call_with_retry(messages, tries=5, **kwargs):
    delay = 2
    for attempt in range(tries):
        try:
            return client.chat.completions.create(
                model="uncensored", messages=messages, **kwargs
            )
        except RateLimitError as err:
            wait = err.response.headers.get("Retry-After")
            time.sleep(int(wait) if wait else delay)
            delay = min(delay * 2, 30)
        except APIConnectionError:
            time.sleep(delay)
            delay = min(delay * 2, 30)
        except APIStatusError as err:
            if err.status_code < 500:
                raise
            time.sleep(delay)
            delay = min(delay * 2, 30)
    raise RuntimeError("request failed after retries")

Ne relancez que les erreurs qui peuvent changer. Une erreur 400 indique que votre requête est malformée ; la renvoyer échouera de la même manière, c'est pourquoi le wrapper relance toute erreur client autre qu'une 429. Les requêtes échouées ou refusées ne sont pas facturées, donc relancer ne coûte rien de plus.

Exécutez de nombreuses entrées en parallèle

Pour une boucle sur de nombreuses entrées, un pool de threads suffit. Le client SDK est sûr à partager entre les threads. Dimensionnez le pool selon votre clé : 8 threads pour une clé complète, 2 pour la clé d'essai.

from openai import OpenAI

client = OpenAI(
    base_url="https://api.veo3apis.com/v1",
    api_key="YOUR_API_KEY",
)
import time
from concurrent.futures import ThreadPoolExecutor
from openai import RateLimitError


def summarize(text: str) -> str:
    for _ in range(5):
        try:
            resp = client.chat.completions.create(
                model="uncensored",
                messages=[
                    {"role": "system", "content": "Summarize the text in two sentences."},
                    {"role": "user", "content": text},
                ],
                max_tokens=150,
            )
            return resp.choices[0].message.content.strip()
        except RateLimitError as err:
            time.sleep(int(err.response.headers.get("Retry-After", "5")))
    return ""


documents = ["First long text...", "Second long text...", "Third long text..."]

with ThreadPoolExecutor(max_workers=8) as pool:
    summaries = list(pool.map(summarize, documents))

for s in summaries:
    print(s)

La taille du pool n'est pas la même que le taux de requête. Huit workers terminant chacun un appel en demi-seconde feraient 960 requêtes par minute, bien au-delà de 300. Si vos appels sont rapides, ajoutez une petite pause ou un limiteur de seau de tokens pour rester sous le plafond par minute. Si vos appels sont lents, la concurrence est la limite que vous atteindrez en premier. Les requêtes streamées gardent leur emplacement jusqu'à la fin du stream.

Sortie structurée et appels d'outils

Deux fonctionnalités transforment un appel de chat en étape de workflow sur laquelle d'autres parties de code peuvent s'appuyer. Le mode JSON garantit une sortie analysable. L'appel de fonctions permet au modèle de demander à votre code de faire quelque chose, puis d'utiliser la réponse.

Mode JSON

Définissez response_format sur un objet JSON et décrivez les clés dans le prompt.

from openai import OpenAI

client = OpenAI(
    base_url="https://api.veo3apis.com/v1",
    api_key="YOUR_API_KEY",
)
import json

resp = client.chat.completions.create(
    model="uncensored",
    response_format={"type": "json_object"},
    messages=[
        {"role": "system", "content": "Reply with JSON: {\"title\": string, \"tags\": [string]}"},
        {"role": "user", "content": "A short post about nightly backups."},
    ],
)
post = json.loads(resp.choices[0].message.content)
print(post["title"], post["tags"])

Appel de fonctions

Déclarez les outils avec tools, forcez éventuellement un choix avec tool_choice, exécutez la fonction vous-même et renvoyez le résultat en tant que message avec role: "tool".

from openai import OpenAI

client = OpenAI(
    base_url="https://api.veo3apis.com/v1",
    api_key="YOUR_API_KEY",
)
import json

tools = [{
    "type": "function",
    "function": {
        "name": "word_count",
        "description": "Count the words in a piece of text.",
        "parameters": {
            "type": "object",
            "properties": {"text": {"type": "string"}},
            "required": ["text"],
        },
    },
}]

messages = [{"role": "user", "content": "How many words are in 'the quick brown fox'?"}]
first = client.chat.completions.create(model="uncensored", messages=messages, tools=tools)
msg = first.choices[0].message

if msg.tool_calls:
    messages.append(msg)
    for call in msg.tool_calls:
        args = json.loads(call.function.arguments)
        result = {"words": len(args["text"].split())}
        messages.append({
            "role": "tool",
            "tool_call_id": call.id,
            "content": json.dumps(result),
        })
    final = client.chat.completions.create(model="uncensored", messages=messages, tools=tools)
    print(final.choices[0].message.content)
else:
    print(msg.content)

Vérifiez toujours que tool_calls est présent avant de le lire. Le modèle peut répondre directement, et votre code doit gérer les deux résultats.

Enchaînez les étapes dans un pipeline

Les workflows réels s'arrêtent rarement à un seul appel. Une forme courante est : brouillon, révision, réécriture : le premier appel produit quelque chose, le deuxième le critique selon une liste de contrôle, et le troisième applique la critique. Chaque étape est une requête séparée avec son propre message système, ce qui garde les instructions courtes et les erreurs faciles à localiser.

from openai import OpenAI

client = OpenAI(
    base_url="https://api.veo3apis.com/v1",
    api_key="YOUR_API_KEY",
)

def step(system: str, user: str, temperature: float = 0.7) -> str:
    resp = client.chat.completions.create(
        model="uncensored",
        messages=[
            {"role": "system", "content": system},
            {"role": "user", "content": user},
        ],
        temperature=temperature,
        max_tokens=800,
    )
    return resp.choices[0].message.content.strip()


topic = "a changelog entry for a new export feature"

draft = step("Write the requested text in under 120 words.", topic)
review = step(
    "List at most three concrete problems with this text: vague wording, missing detail, wrong tone.",
    draft,
    temperature=0.2,
)
final = step(
    "Rewrite the text so it fixes every listed problem. Reply with the text only.",
    "TEXT:\n" + draft + "\n\nPROBLEMS:\n" + review,
)
print(final)

Notez la température plus basse sur l'étape de revue. La critique doit être cohérente d'une exécution à l'autre, tandis que la rédaction bénéficie d'une certaine variété. Si vous exécutez le pipeline sur de nombreuses entrées, placez toute la fonction à trois étapes dans le worker de pool de threads de la section précédente, afin que chaque worker possède un élément du début à la fin et que le plafond de 8 requêtes soit respecté.

Gardez les résultats intermédiaires. Lorsque le texte final est incorrect, le brouillon et la révision vous indiquent quelle étape a échoué, et vous pouvez corriger un message système au lieu de réécrire tout le pipeline. Écrire chaque étape dans un fichier JSON-lines avec l'entrée, les trois sorties et les IDs de requête rend cela facile, et cela vous donne un point de reprise si le processus s'arrête en cours de route.

Suivez le solde et les IDs de requête

Chaque réponse contient des en-têtes qui méritent d'être enregistrés : X-Request-Id identifie l'appel si vous contactez le support, X-Balance-USD indique ce qu'il reste de votre crédit, et les deux en-têtes X-RateLimit-Limit rapportent les limites de requête et de concurrence pour votre clé. Le SDK masque les en-têtes par défaut ; utilisez le wrapper de réponse brute pour les lire.

from openai import OpenAI

client = OpenAI(
    base_url="https://api.veo3apis.com/v1",
    api_key="YOUR_API_KEY",
)

raw = client.chat.completions.with_raw_response.create(
    model="uncensored",
    messages=[{"role": "user", "content": "Reply with the single word ready."}],
    max_tokens=10,
)

print("request id:", raw.headers.get("X-Request-Id"))
print("balance usd:", raw.headers.get("X-Balance-USD"))
print("req limit:", raw.headers.get("X-RateLimit-Limit-Requests"))
print("concurrency limit:", raw.headers.get("X-RateLimit-Limit-Concurrency"))

resp = raw.parse()
print(resp.choices[0].message.content)

La tarification est de 0,15 $ par million de tokens d'entrée et de 0,50 $ par million de tokens de sortie, donc un appel avec 1 000 tokens d'entrée et 500 tokens de sortie coûte 0,00015 $ + 0,00025 $ = 0,0004 $. Un workflow exécutant 5 000 de ces appels dépense 2,00 $. Affichez le solde au début et à la fin d'un run, et vous saurez ce que coûte chaque lot sans outil supplémentaire. Pour les tarifs et les bonus de rechargement, consultez la page de tarification ; pour chaque paramètre pris en charge, lisez la documentation de l'API.

Une autre habitude à adopter : gardez les prompts hors de vos logs à moins que vous ne les en ayez besoin. Les prompts envoyés à cette API ne sont pas utilisés pour l'entraînement, mais vos propres fichiers de logs sont votre responsabilité.

Dépannage d'une nouvelle configuration

La plupart des problèmes de première exécution proviennent d'une courte liste de causes.

  • L'appel se bloque ou génère une erreur de connexion. Vérifiez l'URL de base. Elle doit se terminer par /v1, et le SDK ajoute lui-même /chat/completions. Un chemin doublé est l'erreur habituelle.
  • Une erreur d'authentification. La clé est manquante, tronquée ou contient un espace ou une nouvelle ligne parasite d'un copier-coller. Imprimez sa longueur, pas la clé elle-même, et comparez-la avec ce que montre la page clé.
  • Modèle introuvable. L'ID du modèle est uncensored, en minuscules. Appelez l'endpoint models pour voir exactement ce que votre clé peut utiliser.
  • Erreurs 429 constantes sur un petit script. Vous êtes peut-être sur la clé d'essai, qui permet 2 requêtes simultanées et 60 par minute. Réduisez le pool à 2 workers, ou rechargez pour obtenir une clé complète.
  • Réponses coupées. Un max_tokens bas termine la réponse prématurément. Augmentez-le, ou supprimez-le et laissez la complétion utiliser le reste de la fenêtre.
  • Requête trop volumineuse. La limite du corps est de 8 MB, et la fenêtre de tokens est de 100 000 tokens pour le prompt et la complétion ensemble. Divisez les grandes entrées en morceaux et traitez-les comme des appels séparés.

Lorsque quelque chose semble incorrect côté service, envoyez la valeur de X-Request-Id au contact du site. Un ID de requête permet à l'opérateur de retrouver votre appel exact, ce qui est bien plus utile qu'une description de ce que vous avez observé.

01

Questions et réponses

Ai-je besoin d'un SDK spécial ?

Non. Le SDK Python officiel d'OpenAI fonctionne dès que vous définissez l'URL de base et votre clé.

Quel ID de modèle dois-je utiliser ?

Utilisez uncensored. Vous pouvez lister les ID disponibles avec GET /v1/models.

Combien de requêtes peuvent s'exécuter en parallèle ?

Une clé complète permet 8 requêtes simultanées et 300 par minute. Une clé d'essai permet 2 et 60.

Le streaming fonctionne-t-il dans le SDK Python ?

Oui. Passez stream=True et itérez sur les blocs. L'utilisation est rapportée à la fin du flux.

Il ne vous reste qu'un formulaire à remplir

Créez un compte, copiez la clé, modifiez l'URL de base. C'est toute la configuration.

Obtenir une clé APILire la documentation