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

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

Par / / LLM, API / 7 minutes de lecture
SDK OpenAI pour Python : 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. Utiliser Novita AI avec le même SDK
  10. Quand utiliser Novita Agent Sandbox
  11. Modèles open-source via Novita AI
  12. FAQ
  13. Articles recommandés

Le SDK OpenAI pour Python (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 nouvelles tentatives. Ce guide couvre l’installation, la classe principale OpenAI, les complétions de chat, le streaming, l’appel de fonctions, l’utilisation asynchrone, l’équivalent en SDK JavaScript, l’intégration Azure OpenAI et la compatibilité Novita AI.

Installer le package Python OpenAI

Python 3.10 ou une version ultérieure est requis :

pip install openai

Si vous migrez depuis l’ancienne API 0.x, remplacez openai.ChatCompletion.create() par client.chat.completions.create().

Définissez votre clé API comme variable d’environnement. Ne la placez 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 nouvelles tentatives et les délais d’expiration. Vous devez créer une seule instance et la réutiliser dans toute votre application, plutôt que de l’instancier à chaque 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 Remplacement pour proxy ou API compatible
timeout 600 s Délai d’expiration par requête
max_retries 2 Nouvelles tentatives automatiques en cas d’erreurs de limite de débit
http_client None Client httpx personnalisé pour proxy ou configuration de certificats

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": "You are a helpful coding assistant."},
        {"role": "user", "content": "What is the difference between a list and a tuple in 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

En 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": "Explain Python generators in plain language."},
    ],
) 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 bloc.

Si vous avez besoin du streaming sans gestionnaire de contexte :

stream = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "List 5 Python best practices."}],
    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 JSON d’arguments. 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": "Returns current weather for a city.",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {
                        "type": "string",
                        "description": "City name, e.g. 'San Francisco'",
                    }
                },
                "required": ["city"],
            },
        },
    }
]

messages = [{"role": "user", "content": "What's the weather in 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)
    # Execute your actual function here
    result = {"city": args["city"], "temperature": "18°C", "condition": "cloudy"}

    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, puis 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("What is asyncio in Python?")
    print(result)

asyncio.run(main())

AsyncOpenAI est un équivalent asynchrone direct ; 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 dans 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: "You are a helpful assistant." },
    { role: "user", content: "Explain promises vs async/await in 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: "Summarize the fetch API in 3 sentences." }],
});

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, mais exposer votre clé API dans le navigateur est dangereux. Utilisez plutôt un proxy côté serveur. L’option base_url pour les API compatibles fonctionne de la même manière qu’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",  # Your deployment name in Azure
    messages=[
        {"role": "user", "content": "How do I use Azure OpenAI with Python?"},
    ],
)

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

Variables d’environnement requises pour Azure :

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

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

Pour une authentification via Microsoft Entra ID (anciennement Azure AD) plutôt qu’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",
)

Utiliser Novita AI avec le même SDK

Novita AI expose un point de terminaison compatible OpenAI à l’adresse https://api.novita.ai/openai. Vous pouvez utiliser le même SDK Python ou JavaScript openai et ne modifier que base_url et api_key :

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-v3.1",
    messages=[
        {"role": "system", "content": "You are a helpful coding assistant."},
        {"role": "user", "content": "Explain how Python's GIL affects multithreading."},
    ],
    temperature=0.3,
    max_tokens=512,
)

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

Obtenez une clé API Novita AI sur novita.ai/settings/key-management. La même clé fonctionne pour 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-480b-a35b-instruct",
  messages: [{ role: "user", content: "Write a Python type annotation cheatsheet." }],
  max_tokens: 600,
});

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

Tout ce qui suit — streaming, appels de fonctions, utilisation asynchrone, response_format, temperature et max_tokens — fonctionne de la même manière.

Quand utiliser Novita Agent Sandbox

Utilisez le SDK OpenAI pour les appels de modèles, puis utilisez Novita Agent Sandbox lorsque votre flux de travail nécessite l’exécution de code, des actions navigateur ou des opérations sur fichiers de manière isolée. Cela maintient la couche SDK concentrée sur l’inférence tandis que Sandbox gère les parties risquées d’une boucle d’agent.

Modèles open-source via Novita AI

Changer base_url vous donne accès à des modèles à poids ouverts sur Novita AI sans modifier votre code client. C’est utile lorsque vous voulez un modèle pour le codage, l’utilisation d’outils ou les longs contextes, tout en conservant le même flux de travail SDK.

Le format d’ID de modèle sur Novita AI est provider/nom-du-modèle, et vous le passez directement au paramètre model.

Un modèle de routage simple pour les équipes qui souhaitent mélanger des 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"])

# Use open-weight for cost-sensitive, high-volume coding tasks
coding_client = get_client(use_novita=True)

# Use OpenAI for tasks where the closed model is genuinely better
openai_client = get_client(use_novita=False)

Cela vous permet de tester A/B la qualité des sorties, de router le travail vers Novita AI lorsque cela convient, et de conserver un seul chemin SDK pour tous les fournisseurs.

FAQ

Quel est le nom du package Python OpenAI ?

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

Comment s’appelle la classe du 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 blocs.

Quel est le nom du package du SDK JavaScript OpenAI ?

Le package npm est openai. Installez-le avec npm install openai. Les signatures de classes et de méthodes 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 d’API Chat Completions d’OpenAI peut être utilisé en définissant base_url sur le client. Le point de terminaison de Novita AI à https://api.novita.ai/openai en est un exemple ; l’ensemble des fonctionnalités du SDK — streaming, appels 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 build ou le JavaScript côté client.

Articles recommandés

Articles associés