English Arabic 简体中文 繁體中文 Français Deutsch 日本語 한국어 Português Русский Español

SDK Python OpenAI : installation, configuration et intégration pratique

Par / / LLM, API / 8 minutes de lecture
SDK Python OpenAI : installation, configuration et intégration pratique
Table des matières
  1. Installer le package Python OpenAI
  2. La classe client OpenAI
  3. Complétions de chat : requête de base
  4. Réponses en streaming
  5. Appel de fonctions
  6. Utilisation asynchrone avec AsyncOpenAI
  7. SDK JavaScript OpenAI
  8. Intégration Python Azure OpenAI
  9. Passer à l'API compatible OpenAI de Novita AI
  10. Modèles open-source via Novita AI
  11. FAQ
  12. Articles recommandés

Le SDK Python OpenAI (openai sur PyPI) est le client Python officiel pour l’API OpenAI. Il gère l’authentification, le formatage des requêtes, l’analyse des réponses, le streaming et les tentatives — vous n’avez donc pas à les implémenter vous-même. Ce guide couvre l’installation, la classe centrale OpenAI, les complétions de chat, le streaming, l’appel de fonctions, l’utilisation asynchrone, l’équivalent du SDK JavaScript, l’intégration Azure OpenAI, et comment pointer le même SDK vers le point de terminaison compatible OpenAI de Novita AI pour utiliser des modèles open-weight sans réécrire votre code.

Installer le package Python OpenAI

Python 3.8 ou ultérieur est requis :

pip install openai

Pour le développement, ajoutez-le à votre requirements.txt ou pyproject.toml :

pip install openai>=1.0.0

La version 1.x (publiée fin 2023) a considérablement modifié l’interface par rapport à l’API 0.x. Si vous migrez un code plus ancien, notez que openai.ChatCompletion.create() n’existe plus ; utilisez plutôt client.chat.completions.create().

Définissez votre clé API en tant que variable d’environnement. Ne la mettez pas dans le code source :

export OPENAI_API_KEY="sk-..."

La classe client OpenAI

La classe OpenAI est le point d’entrée principal. Elle lit la clé API depuis la variable d’environnement OPENAI_API_KEY par défaut, ou vous pouvez la passer explicitement :

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["OPENAI_API_KEY"],
)

Le client gère le pooling de connexions, les tentatives et les délais d’attente. Vous devez créer une seule instance et la réutiliser dans toute votre application, ne l’instanciez pas par requête.

Options configurables à l’initialisation :

Paramètre Défaut Description
api_key Variable d’env. OPENAI_API_KEY Identifiant d’authentification
base_url https://api.openai.com/v1 Surcharge pour proxy ou API compatible
timeout 600s Délai d’attente par requête
max_retries 2 Tentatives automatiques en cas d’erreur de limite de débit
http_client None Client httpx personnalisé pour proxy ou configuration de certificat

Complétions de chat : requête de base

Les complétions de chat sont le cas d’utilisation le plus courant. La liste messages suit le même format que l’API : une liste de dictionnaires rôle/contenu représentant la conversation :

import os
from openai import OpenAI

client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[
        {"role": "system", "content": "Vous êtes un assistant de codage utile."},
        {"role": "user", "content": "Quelle est la différence entre une liste et un tuple en Python ?"},
    ],
    temperature=0.3,
    max_tokens=512,
)

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

La réponse est un objet ChatCompletion. Champs clés :

  • response.choices[0].message.content — la réponse textuelle
  • response.usage.prompt_tokens — jetons consommés par l’entrée
  • response.usage.completion_tokens — jetons consommés par la sortie
  • response.model — la version du modèle qui a servi la requête

Pour la production, passez max_tokens pour éviter des coûts de génération incontrôlés et temperature=0 ou des valeurs faibles lorsque vous avez besoin de sorties déterministes.

Réponses en streaming

Pour les interfaces interactives où les utilisateurs voient les jetons arriver, utilisez stream=True :

import os
from openai import OpenAI

client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])

with client.chat.completions.stream(
    model="gpt-4o",
    messages=[
        {"role": "user", "content": "Expliquez les générateurs Python en langage simple."},
    ],
) as stream:
    for text in stream.text_stream:
        print(text, end="", flush=True)

L’utilisation du gestionnaire de contexte (instruction with) garantit que la connexion est correctement fermée après l’itération. L’attribut .text_stream produit des chaînes simples ; .stream produit des objets d’événements bruts si vous avez besoin de métadonnées comme les statistiques d’utilisation par morceau.

Si vous avez besoin de streaming sans gestionnaire de contexte :

stream = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Listez 5 bonnes pratiques Python."}],
    stream=True,
)
for chunk in stream:
    delta = chunk.choices[0].delta
    if delta.content:
        print(delta.content, end="", flush=True)

Appel de fonctions

L’appel de fonctions permet au modèle de décider quand appeler une fonction et de renvoyer un objet d’arguments JSON. Votre application exécute la fonction, puis renvoie le résultat au modèle pour qu’il l’intègre dans sa réponse :

import os
import json
from openai import OpenAI

client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Renvoie la météo actuelle pour une ville.",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {
                        "type": "string",
                        "description": "Nom de la ville, ex. 'Paris'",
                    }
                },
                "required": ["city"],
            },
        },
    }
]

messages = [{"role": "user", "content": "Quel temps fait-il à Tokyo ?"}]

response = client.chat.completions.create(
    model="gpt-4o",
    messages=messages,
    tools=tools,
    tool_choice="auto",
)

choice = response.choices[0]
if choice.finish_reason == "tool_calls":
    tool_call = choice.message.tool_calls[0]
    args = json.loads(tool_call.function.arguments)
    # Exécutez votre fonction réelle ici
    result = {"city": args["city"], "temperature": "18°C", "condition": "nuageux"}

    messages.append(choice.message)
    messages.append({
        "role": "tool",
        "tool_call_id": tool_call.id,
        "content": json.dumps(result),
    })

    final = client.chat.completions.create(
        model="gpt-4o",
        messages=messages,
    )
    print(final.choices[0].message.content)

Le modèle renvoie finish_reason="tool_calls" lorsqu’il souhaite invoquer une fonction. Vous exécutez la fonction, ajoutez le résultat à la liste des messages et effectuez une deuxième requête. Cette boucle en deux étapes est le modèle standard.

Utilisation asynchrone avec AsyncOpenAI

Pour FastAPI, les services basés sur asyncio, ou tout code bénéficiant d’E/S non bloquantes, utilisez AsyncOpenAI :

import os
import asyncio
from openai import AsyncOpenAI

client = AsyncOpenAI(api_key=os.environ["OPENAI_API_KEY"])

async def get_response(prompt: str) -> str:
    response = await client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[{"role": "user", "content": prompt}],
        max_tokens=256,
    )
    return response.choices[0].message.content

async def main():
    result = await get_response("Qu'est-ce que asyncio en Python ?")
    print(result)

asyncio.run(main())

AsyncOpenAI est un équivalent asynchrone interchangeable ; toutes les méthodes sont awaitables. C’est préférable à l’utilisation de asyncio.to_thread pour envelopper le client synchrone.

SDK JavaScript OpenAI

Le SDK JavaScript OpenAI (openai sur npm) reflète étroitement l’interface Python. Installez-le :

npm install openai

Complétion de chat de base en Node.js :

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.OPENAI_API_KEY,
});

const response = await client.chat.completions.create({
  model: "gpt-4o",
  messages: [
    { role: "system", content: "Vous êtes un assistant utile." },
    { role: "user", content: "Expliquez les promesses vs async/await en JavaScript." },
  ],
  max_tokens: 512,
});

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

Streaming en JavaScript :

import OpenAI from "openai";

const client = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });

const stream = await client.chat.completions.stream({
  model: "gpt-4o",
  messages: [{ role: "user", content: "Résumez l'API fetch en 3 phrases." }],
});

for await (const chunk of stream) {
  const text = chunk.choices[0]?.delta?.content ?? "";
  process.stdout.write(text);
}

Le SDK JavaScript prend en charge Node.js 18+, Deno et les environnements navigateur (bien qu’exposer votre clé API dans le navigateur soit dangereux — utilisez plutôt un proxy côté serveur). L’option base_url pour pointer vers des API compatibles fonctionne exactement comme en Python.

Intégration Python Azure OpenAI

Si vous utilisez le service Azure OpenAI plutôt que l’API OpenAI directe, utilisez le client AzureOpenAI du même package :

import os
from openai import AzureOpenAI

client = AzureOpenAI(
    api_key=os.environ["AZURE_OPENAI_API_KEY"],
    azure_endpoint=os.environ["AZURE_OPENAI_ENDPOINT"],
    api_version="2024-02-01",
)

response = client.chat.completions.create(
    model="gpt-4o",  # Votre nom de déploiement dans Azure
    messages=[
        {"role": "user", "content": "Comment utiliser Azure OpenAI avec Python ?"},
    ],
)

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

Variables d’environnement requises pour Azure :

  • AZURE_OPENAI_API_KEY : Votre clé API de ressource Azure
  • AZURE_OPENAI_ENDPOINT : Votre URL de point de terminaison, ex. https://votre-ressource.openai.azure.com/

Le paramètre model dans Azure OpenAI fait référence à votre nom de déploiement, pas au nom du modèle sous-jacent. Définissez api_version pour correspondre à la version de l’API Azure utilisée par votre déploiement (consultez la documentation Azure OpenAI pour les versions actuellement prises en charge).

Pour l’authentification via Microsoft Entra ID (anciennement Azure AD) au lieu d’une clé API :

from azure.identity import DefaultAzureCredential, get_bearer_token_provider
from openai import AzureOpenAI

token_provider = get_bearer_token_provider(
    DefaultAzureCredential(),
    "https://cognitiveservices.azure.com/.default",
)

client = AzureOpenAI(
    azure_ad_token_provider=token_provider,
    azure_endpoint=os.environ["AZURE_OPENAI_ENDPOINT"],
    api_version="2024-02-01",
)

Passer à l’API compatible OpenAI de Novita AI

Novita AI expose un point de terminaison compatible OpenAI à l’adresse https://api.novita.ai/openai. Vous pouvez utiliser le même SDK openai Python ou JavaScript, en changeant uniquement base_url et api_key. Aucune autre modification de code n’est requise :

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["NOVITA_API_KEY"],
    base_url="https://api.novita.ai/openai",
)

response = client.chat.completions.create(
    model="deepseek/deepseek-v4-pro",
    messages=[
        {"role": "system", "content": "Vous êtes un assistant de codage utile."},
        {"role": "user", "content": "Expliquez comment le GIL de Python affecte le multithreading."},
    ],
    temperature=0.3,
    max_tokens=512,
)

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

Obtenez une clé API Novita AI depuis novita.ai/settings/key-management. La même clé fonctionne sur toutes les API Novita AI, y compris le point de terminaison compatible OpenAI.

JavaScript avec Novita AI :

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.NOVITA_API_KEY,
  baseURL: "https://api.novita.ai/openai",
});

const response = await client.chat.completions.create({
  model: "qwen/qwen3-coder-30b-a3b-instruct",
  messages: [{ role: "user", content: "Écrivez une antisèche de typage Python." }],
  max_tokens: 600,
});

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

Tout ce qui suit — streaming, appel de fonctions, utilisation asynchrone, response_format, temperature, max_tokens — fonctionne de manière identique. Le point de terminaison Novita AI suit la spécification de l’API Chat Completions OpenAI.

Modèles open-source via Novita AI

Changer base_url vous donne accès à un catalogue de modèles open-weight qui sont désormais compétitifs avec les modèles fermés de pointe sur des tâches spécifiques. Pour les workflows de codage, l’appel de fonctions et le raisonnement à long contexte, l’écart pratique s’est considérablement réduit.

Modèles disponibles via le point de terminaison compatible OpenAI de Novita AI qui méritent d’être évalués :

DeepSeek V4 Pro (deepseek/deepseek-v4-pro) : Un grand modèle MoE (licence proche de MIT) qui se classe près du sommet de SWE-Bench et des benchmarks d’appel de fonctions. Performant pour les agents de codage, la revue de code et les tâches d’utilisation d’outils en plusieurs étapes où vous utiliseriez sinon GPT-4o ou Claude Opus.

Qwen3 Coder 30B A3B Instruct (qwen/qwen3-coder-30b-a3b-instruct) : Un modèle MoE sparse de 30B de la famille Qwen Coder, optimisé pour la génération de code, le triage de bogues et la revue de demandes de tirage. À 0,07 $ pour 1 million de jetons d’entrée et 0,27 $ pour 1 million de jetons de sortie sur Novita AI, il est nettement moins cher que la plupart des API fermées pour l’assistance de codage courante.

Qwen3 235B A22B Instruct (qwen/qwen3-235b-a22b-instruct-2507) : Un grand modèle MoE (Apache 2.0) avec de solides performances de raisonnement et de codage multilingue. Bon pour les tâches où vous utilisez actuellement GPT-4o pour des réponses créatives ou complexes mais souhaitez réduire le coût par jeton à volume.

Le format de l’ID de modèle sur Novita AI est fournisseur/nom-du-modèle. Vous le passez directement au paramètre model dans le SDK.

Un modèle de routage simple pour les équipes qui souhaitent mélanger modèles ouverts et fermés :

def get_client(use_novita: bool = False) -> OpenAI:
    if use_novita:
        return OpenAI(
            api_key=os.environ["NOVITA_API_KEY"],
            base_url="https://api.novita.ai/openai",
        )
    return OpenAI(api_key=os.environ["OPENAI_API_KEY"])

# Utilisez open-weight pour les tâches de codage sensibles aux coûts et à volume élevé
coding_client = get_client(use_novita=True)

# Utilisez OpenAI pour les tâches où le modèle fermé est vraiment meilleur
openai_client = get_client(use_novita=False)

Cela vous permet de tester A/B la qualité des sorties, de comparer les performances par tâche et de déplacer le volume vers des modèles moins chers sans toucher à la logique des requêtes.

FAQ

Quel est le nom du package Python OpenAI ?

Le nom du package sur PyPI est openai. Installez avec pip install openai.

Comment s’appelle la classe client OpenAI en Python ?

La classe principale est OpenAI pour une utilisation synchrone et AsyncOpenAI pour une utilisation asynchrone. Les deux se trouvent dans le module openai : from openai import OpenAI, AsyncOpenAI.

Le SDK Python OpenAI prend-il en charge le streaming ?

Oui. Utilisez client.chat.completions.stream() comme gestionnaire de contexte, ou passez stream=True à client.chat.completions.create() et itérez sur les morceaux.

Quel est le nom du package du SDK JavaScript OpenAI ?

Le package npm est openai. Installez avec npm install openai. Les signatures de classe et de méthode sont presque identiques à celles du SDK Python.

Comment utiliser Azure OpenAI avec Python ?

Utilisez la classe AzureOpenAI du package openai. Passez azure_endpoint, api_key et api_version. Le paramètre model fait référence à votre nom de déploiement Azure, pas au modèle sous-jacent.

Puis-je utiliser le SDK Python OpenAI avec d’autres fournisseurs ?

Oui. Tout fournisseur qui implémente le format de l’API Chat Completions OpenAI peut être utilisé en définissant base_url sur le client. Le point de terminaison de Novita AI à l’adresse https://api.novita.ai/openai en est un exemple ; l’ensemble complet des fonctionnalités du SDK — streaming, appel de fonctions, asynchrone — fonctionne sans modification.

Comment sécuriser ma clé API OpenAI ?

Stockez la clé dans une variable d’environnement (OPENAI_API_KEY) et lisez-la avec os.environ["OPENAI_API_KEY"]. Ne la mettez jamais dans le code source, les dépôts publics, les journaux de construction ou le JavaScript côté client.

Articles recommandés

Articles associés