Créez vos propres outils d’IA en Python en utilisant l’API OpenAI

Grâce à OpenAI qui soutient maintenant des modèles jusqu’à GPT-4 Turbo, les développeurs Python ont une opportunité incroyable d’explorer des fonctionnalités AI avancées. Ce tutoriel offre un aperçu approfondi sur la façon d’intégrer l’API ChatGPT dans vos scripts Python, vous guidant à travers les étapes de configuration initiale jusqu’à une utilisation efficace de l’API.

L’API ChatGPT fait référence à l’interface de programmation qui permet aux développeurs d’interagir avec et d’utiliser les modèles GPT pour générer des réponses conversationnelles. Mais en réalité, il s’agit juste de l’API universelle d’OpenAI qui fonctionne pour tous leurs modèles.

Étant donné que GPT-4 Turbo est plus avancé et trois fois moins cher que GPT-4, il n’y a jamais eu de meilleur moment pour tirer parti de cette puissante API en Python, alors commençons!

Configuration de votre environnement

Pour commencer, nous vous guiderons dans la configuration de votre environnement pour travailler avec l’API OpenAI en Python. Les premières étapes incluent l’installation des bibliothèques nécessaires, la configuration de l’accès à l’API, et la gestion des clés API et de l’authentification.

Installation des bibliothèques Python nécessaires

Avant de commencer, assurez-vous d’avoir Python installé sur votre système. Nous recommandons d’utiliser un environnement virtuel pour tout organiser. Vous pouvez créer un environnement virtuel avec la commande suivante:

python -m venv chatgpt_env

Activez l’environnement virtuel en exécutant:

• chatgpt_env\Scripts\activate (Windows)
• source chatgpt_env/bin/activate (macOS ou Linux)

Ensuite, vous devrez installer les bibliothèques Python requises qui incluent le client Python OpenAI pour interagir avec l’API OpenAI, et le package python-dotenv pour gérer la configuration. Pour installer les deux packages, exécutez la commande suivante:

pip install openai python-dotenv

Configuration de l’accès à l’API OpenAI

Pour effectuer une requête à l’API OpenAI, vous devez d’abord vous inscrire sur la plateforme OpenAI et générer votre clé API unique. Suivez ces étapes:

1. Visitez la page des clés API d’OpenAI et créez un nouveau compte, ou connectez-vous si vous avez déjà un compte.
2. Une fois connecté, allez dans la section des clés API et cliquez sur Créer une nouvelle clé secrète.
3. Copiez la clé API générée pour une utilisation ultérieure. Sinon, vous devrez générer une nouvelle clé API si vous la perdez. Vous ne pourrez pas consulter les clés API via le site web OpenAI.

page des clés API d’OpenAI

Clé API générée pouvant être utilisée maintenant

Clé API et Authentification

Une fois que vous avez obtenu votre clé API, nous recommandons de la stocker en tant que variable d’environnement pour des raisons de sécurité. Pour gérer les variables d’environnement, utilisez le package python-dotenv. Pour configurer une variable d’environnement contenant votre clé API, suivez ces étapes:

1. Créez un fichier nommé .env dans le répertoire de votre projet.

2. Ajoutez la ligne suivante dans le fichier .env, remplacez your_api_key par la clé API réelle que vous avez copiée précédemment : CHAT_GPT_API_KEY=your_api_key.

3. Dans votre code Python, chargez la clé API à partir du fichier .env en utilisant la fonction load_dotenv du package python-dotenv :

  import openai
  from openai import OpenAI
  import os
  from dotenv import load_dotenv

  # Charger la clé API à partir du fichier .env
  load_dotenv()
  client = OpenAI(api_key=os.environ.get("CHAT_GPT_API_KEY"))

Note : Dans la dernière version de la bibliothèque Python OpenAI, vous devez instancier un client OpenAI pour effectuer des appels API, comme indiqué ci-dessous. Ceci est un changement par rapport aux versions précédentes, où vous utiliseriez directement des méthodes globales.

Maintenant que vous avez ajouté votre clé API et que votre environnement est prêt à utiliser l’API OpenAI en Python. Dans les prochaines sections de cet article, nous explorerons l’interaction avec l’API et la construction d’applications de chat en utilisant cet outil puissant.

N’oubliez pas d’ajouter le code ci-dessus à chaque section de code ci-dessous avant de l’exécuter.

Utilisation de l’API OpenAI en Python

Après avoir chargé l’API à partir du fichier .env, nous pouvons commencer à l’utiliser dans Python. Pour utiliser l’API OpenAI en Python, nous pouvons effectuer des appels API à l’aide de l’objet client. Ensuite, nous pouvons transmettre une série de messages en entrée à l’API et recevoir un message généré par le modèle en sortie.

Création d’une demande simple ChatGPT

1. Assurez-vous d’avoir effectué les étapes précédentes : création d’un environnement virtuel, installation des bibliothèques nécessaires et génération de votre clé secrète OpenAI et du fichier .env dans le répertoire du projet.

2. Utilisez le code suivant pour configurer une demande simple ChatGPT :

  # Créer une complétion de chat
  chat_completion = client.chat.completions.create(
      model="gpt-4",
      messages=[{"role": "user", "content": "query"}]
  )
  print(chat_completion.choices[0].message.content)

Ici, client.chat.completions.create est un appel de méthode sur l’objet client. L’attribut chat accède aux fonctionnalités spécifiques au chat de l’API, et completions.create est une méthode qui demande au modèle IA de générer une réponse ou une complétion basée sur l’entrée fournie.

Remplacez le query par l’invite que vous souhaitez exécuter, et n’hésitez pas à utiliser n’importe quel modèle GPT pris en charge à la place du GPT-4 sélectionné ci-dessus.

Gestion des erreurs

Lors de la réalisation de requêtes, divers problèmes peuvent survenir, y compris des problèmes de connectivité réseau, des dépassements de limite de taux, ou d’autres codes de statut de réponse non standard. Par conséquent, il est essentiel de gérer correctement ces codes de statut. Nous pouvons utiliser les blocs try et except de Python pour maintenir le flux de programme et une meilleure gestion des erreurs :

# Essayer de créer une complétion de chat
try:
    chat_completion = client.chat.completions.create(
        model="gpt-4",
        messages=[{"role": "user", "content": "query"}],
        temperature=1,
        max_tokens=150  # Ajuster le nombre de jetons selon les besoins
    )
    print(chat_completion.choices[0].message.content)

except openai.APIConnectionError as e:
    print("The server could not be reached")
    print(e.__cause__)

except openai.RateLimitError as e:
    print("A 429 status code was received; we should back off a bit.")

except openai.APIStatusError as e:
    print("Another non-200-range status code was received")
    print(e.status_code)
    print(e.response)

Note : vous devez disposer de crédits disponibles pour pouvoir utiliser n’importe quel modèle de l’API OpenAI. Si plus de trois mois se sont écoulés depuis la création de votre compte, vos crédits gratuits ont probablement expiré et vous devrez acheter des crédits supplémentaires (un minimum de 5 $).

Voici maintenant quelques façons de configurer davantage vos requêtes API :

• Max Tokens. Limitez la longueur maximale possible de la sortie en fonction de vos besoins en définissant le paramètre max_tokens. Cela peut être une mesure d’économie de coûts, mais notez que cela coupe simplement le texte généré au-delà de la limite, sans rendre la sortie globale plus courte.
• Température. Ajustez le paramètre de température pour contrôler la randomité. (Des valeurs plus élevées rendent les réponses plus diversifiées, tandis que des valeurs plus basses produisent des réponses plus cohérentes.)

Si un paramètre n’est pas défini manuellement, il utilise la valeur par défaut respective du modèle, comme 0 – 7 et 1 pour GPT-3.5-turbo et GPT-4, respectivement.

En plus des paramètres ci-dessus, il existe de nombreux autres paramètres et configurations que vous pouvez effectuer pour utiliser les capacités de GPT exactement de la manière que vous souhaitez. Il est recommandé d’étudier la documentation de l’API OpenAI pour référence.

Néanmoins, des prompts efficaces et contextuels sont toujours nécessaires, quelle que soit la configuration des paramètres effectuée.

Techniques avancées d’intégration API

Dans cette section, nous allons explorer des techniques avancées pour intégrer l’API OpenAI dans vos projets Python, en mettant l’accent sur l’automatisation des tâches, l’utilisation des requêtes Python pour la récupération des données et la gestion des requêtes d’API à grande échelle.

Automatiser les tâches avec l’API OpenAI

Pour rendre votre projet Python plus efficace, vous pouvez automatiser diverses tâches en utilisant l’API OpenAI. Par exemple, vous pourriez vouloir automatiser la génération de réponses aux e-mails, d’aides aux clients ou de création de contenu.

Voici un exemple de la façon d’automatiser une tâche à l’aide de l’API OpenAI:

def automated_task(prompt):
    try:
        chat_completion = client.chat.completions.create(
            model="gpt-4",
            messages=[{"role": "user", "content": prompt}],
            max_tokens=250
        )
        return chat_completion.choices[0].message.content
    except Exception as e:
        return str(e)

# Exemple d'utilisation
generated_text = automated_task("Write an short note that's less than 50 words to the development team asking for an update on the current status of the software update")
print(generated_text)

Cette fonction prend en entrée un prompt et renvoie le texte généré en sortie.

Utilisation des requêtes Python pour la récupération des données

Vous pouvez utiliser la populaire bibliothèque requests pour interagir directement avec l’API OpenAI sans dépendre de la bibliothèque OpenAI. Cette méthode vous donne plus de contrôle sur la requête GET et une flexibilité accrue sur vos appels API.

L’exemple suivant nécessite la bibliothèque requests (si vous ne l’avez pas, exécutez d’abord pip install requests) :

headers = {
    'Content-Type': 'application/json',
    'Authorization': f'Bearer {api_key}',
}

data = {
    'model': 'gpt-4',  # Mettre à jour pour le modèle désiré
    'messages': [{'role': 'user', 'content': 'Write an interesting fact about Christmas.'}]
}

response = requests.post('https://api.openai.com/v1/chat/completions', headers=headers, json=data)
print(response.json())

Ce code montre comment faire une requête POST à l’API OpenAI, avec les en-têtes et les données en tant qu’arguments. La réponse JSON peut être analysée et utilisée dans votre projet Python.

Gestion des requêtes d’API à grande échelle

Lorsqu’on travaille sur des projets à grande échelle, il est crucial de gérer efficacement les requêtes API. Cela peut être réalisé en intégrant des techniques telles que le batching, le throttling et le caching.

• Batching. Rassemblez plusieurs requêtes en une seule appel API, en utilisant le paramètre n dans la bibliothèque OpenAI : n = number_of_responses_needed.
• Throttling. Mettez en place un système pour limiter le débit auquel les appels API sont effectués, évitant ainsi une utilisation excessive ou un surchargement de l’API.
• Caching. Stockez les résultats des requêtes API terminées pour éviter les appels redondants pour des prompts ou des requêtes similaires.

Pour gérer efficacement les requêtes API, tenez un suivi de votre utilisation et ajustez vos paramètres de configuration en conséquence. Pensez à utiliser la bibliothèque time pour ajouter des délais ou des timeouts entre les requêtes si nécessaire.

L’application de ces techniques avancées dans vos projets Python vous aidera à tirer le meilleur parti de l’API OpenAI tout en assurant une intégration API efficace et évolutive.

Applications Pratiques : API OpenAI dans les projets du monde réel

L’intégration de l’API OpenAI dans vos projets du monde réel peut offrir de nombreux avantages. Dans cette section, nous discuterons de deux applications spécifiques : l’intégration de ChatGPT dans le développement web et la construction de chatbots avec ChatGPT et Python.

Intégration de ChatGPT dans le développement web

L’API OpenAI peut être utilisée pour créer du contenu interactif et dynamique adapté aux requêtes ou aux besoins des utilisateurs. Par exemple, vous pourriez utiliser ChatGPT pour générer des descriptions de produits personnalisées, créer des articles de blog engageants, ou répondre à des questions courantes sur vos services. Avec la puissance de l’API OpenAI et un peu de code Python, les possibilités sont infinies.

Prenons cet exemple simple d’utilisation d’un appel d’API depuis un backend Python:

def generate_content(prompt):
    try:
        response = client.chat.completions.create(
            model="gpt-4",
            messages=[{"role": "user", "content": prompt}]
        )
        return response.choices[0].message.content
    except Exception as e:
        return str(e)

# Utiliser cette fonction pour générer du contenu
description = generate_content("Write a short description of a hiking backpack")

Vous pouvez ensuite écrire du code pour intégrer description avec votre HTML et JavaScript pour afficher le contenu généré sur votre site web.

Création de chatbots avec ChatGPT et Python

Les chatbots alimentés par l’intelligence artificielle commencent à jouer un rôle important dans l’amélioration de l’expérience utilisateur. En combinant les capacités de traitement du langage naturel de ChatGPT avec Python, vous pouvez créer des chatbots qui comprennent le contexte et répondent intelligemment aux entrées des utilisateurs.

Prenons cet exemple pour traiter l’entrée de l’utilisateur et obtenir une réponse:

def get_chatbot_response(prompt):
    try:
        response = client.chat.completions.create(
            model="gpt-4",
            messages=[{"role": "user", "content": prompt}]
        )
        return response.choices[0].message.content
    except Exception as e:
        return str(e)

# Prendre l'entrée de l'utilisateur depuis la ligne de commande
user_input = input("Enter your prompt: ")
response = get_chatbot_response(user_input)
print(response)

Mais comme il n’y a pas de boucle, le script s’arrêtera après une exécution, alors envisagez d’ajouter une logique conditionnelle. Par exemple, nous avons ajouté une logique conditionnelle basique où le script continuera à chercher les prompts de l’utilisateur jusqu’à ce que l’utilisateur dise l’expression de fin « exit » ou « quit ».

En tenant compte de la logique mentionnée, notre code final complet pour exécuter un chatbot sur l’endpoint de l’API OpenAI pourrait ressembler à ceci :

from openai import OpenAI
import os
from dotenv import load_dotenv

# Charger la clé API à partir du fichier .env
load_dotenv()
client = OpenAI(api_key=os.environ.get("CHAT_GPT_API_KEY"))

def get_chatbot_response(prompt):
    try:
        response = client.chat.completions.create(
            model="gpt-4",
            messages=[{"role": "user", "content": prompt}]
        )
        return response.choices[0].message.content
    except Exception as e:
        return str(e)

while True:
    user_input = input("You: ")
    if user_input.lower() in ["exit", "quit"]:
        print("Chat session ended.")
        break
    response = get_chatbot_response(user_input)
    print("ChatGPT:", response)

Voici à quoi cela ressemble lorsqu’il est exécuté dans l’invite de commande Windows.

J’espère que ces exemples vous aideront à commencer à expérimenter avec l’intelligence artificielle ChatGPT. Dans l’ensemble, OpenAI a ouvert d’immenses opportunités pour les développeurs de créer de nouveaux produits excitants à l’aide de leur API, et les possibilités sont infinies.

Limites et tarification de l’API OpenAI

Bien que l’API OpenAI soit puissante, il y a quelques limitations:

• Stockage des données. OpenAI conserve vos données API pendant 30 jours, et l’utilisation de l’API implique le consentement au stockage des données. Soyez vigilant quant aux données que vous envoyez.

• Capacité du modèle. Les modèles de chat ont une limite maximale de jetons. (Par exemple, GPT-3 prend en charge 4096 jetons.) Si une requête API dépasse cette limite, vous devrez tronquer ou omettre du texte.

• Tarification. L’API OpenAI n’est pas disponible gratuitement et suit son propre schéma tarifaire, distinct des frais de souscription du modèle. Pour plus d’informations sur les prix, veuillez consulter les détails de tarification d’OpenAI. (Encore une fois, GPT-4 Turbo coûte trois fois moins cher que GPT-4!)

Conclusion

L’exploration du potentiel de l’API du modèle ChatGPT en Python peut apporter des avancées significatives dans diverses applications telles que le support client, les assistants virtuels et la génération de contenu. En intégrant cette puissante API dans vos projets, vous pouvez exploiter les capacités des modèles GPT de manière transparente dans vos applications Python.

Si vous avez apprécié ce tutoriel, vous pourriez également apprécier ceux-ci:

• Comment effectuer une analyse de données en Python à l’aide de l’API OpenAI

• Créer un chatbot formé sur vos propres données via l’API OpenAI

• Construire votre propre clone de ChatGPT avec React et l’API OpenAI

• Comment créer un correcteur orthographique simple avec ChatGPT