Construire un chatbot IA génératif simple : un guide pratique

Dans ce didacticiel, nous expliquerons la création d'un chatbot IA génératif à l'aide de Python et de l'API OpenAI. Nous créerons un chatbot capable d'engager des conversations naturelles tout en maintenant le contexte et en fournissant des réponses utiles.

Conditions préalables

• Python 3.8
• Compréhension de base de la programmation Python
• Clé API OpenAI
• Connaissance de base des API RESTful

Configuration de l'environnement

Tout d'abord, configurons notre environnement de développement. Créez un nouveau projet Python et installez les dépendances requises :

pip install openai python-dotenv streamlit

Structure du projet

Notre chatbot aura une structure propre et modulaire :

chatbot/
├── .env
├── app.py
├── chat_handler.py
└── requirements.txt

Mise en œuvre

Commençons par notre logique de chatbot de base dans chat_handler.py :

import openai
from typing import List, Dict
import os
from dotenv import load_dotenv

load_dotenv()

class ChatBot:
    def __init__(self):
        openai.api_key = os.getenv("OPENAI_API_KEY")
        self.conversation_history: List[Dict[str, str]] = []
        self.system_prompt = """You are a helpful AI assistant. Provide clear, 
        accurate, and engaging responses while maintaining a friendly tone."""

    def add_message(self, role: str, content: str):
        self.conversation_history.append({"role": role, "content": content})

    def get_response(self, user_input: str) -> str:
        # Add user input to conversation history
        self.add_message("user", user_input)

        # Prepare messages for API call
        messages = [{"role": "system", "content": self.system_prompt}] + \
                  self.conversation_history

        try:
            # Make API call to OpenAI
            response = openai.ChatCompletion.create(
                model="gpt-3.5-turbo",
                messages=messages,
                max_tokens=1000,
                temperature=0.7
            )

            # Extract and store assistant's response
            assistant_response = response.choices[0].message.content
            self.add_message("assistant", assistant_response)

            return assistant_response

        except Exception as e:
            return f"An error occurred: {str(e)}"

Maintenant, créons une interface Web simple en utilisant Streamlit dans app.py :

import streamlit as st
from chat_handler import ChatBot

def main():
    st.title("? AI Chatbot")

    # Initialize session state
    if "chatbot" not in st.session_state:
        st.session_state.chatbot = ChatBot()

    # Chat interface
    if "messages" not in st.session_state:
        st.session_state.messages = []

    # Display chat history
    for message in st.session_state.messages:
        with st.chat_message(message["role"]):
            st.write(message["content"])

    # Chat input
    if prompt := st.chat_input("What's on your mind?"):
        # Add user message to chat history
        st.session_state.messages.append({"role": "user", "content": prompt})
        with st.chat_message("user"):
            st.write(prompt)

        # Get bot response
        response = st.session_state.chatbot.get_response(prompt)

        # Add assistant response to chat history
        st.session_state.messages.append({"role": "assistant", "content": response})
        with st.chat_message("assistant"):
            st.write(response)

if __name__ == "__main__":
    main()

Principales fonctionnalités

1. Mémoire de conversation : Le chatbot maintient le contexte en stockant l'historique des conversations.
2. Invite système : Nous définissons le comportement et la personnalité du chatbot via une invite système.
3. Gestion des erreurs : l'implémentation inclut la gestion des erreurs de base pour les appels d'API.
4. Interface utilisateur : une interface Web claire et intuitive utilisant Streamlit.

Exécuter le chatbot

1. Créez un fichier .env avec votre clé API OpenAI :

OPENAI_API_KEY=your_api_key_here

1. Exécutez l'application :

streamlit run app.py

Améliorations potentielles

1. Persistance des conversations : ajoutez l'intégration d'une base de données pour stocker les historiques de discussion.
2. Personnalités personnalisées : permet aux utilisateurs de sélectionner différentes personnalités de chatbot.
3. Validation des entrées : ajoutez une validation et une désinfection des entrées plus robustes.
4. Limitation du débit API : implémentez une limitation du débit pour gérer l'utilisation de l'API.
5. Response Streaming : ajoutez des réponses en streaming pour une meilleure expérience utilisateur.

Conclusion

Cette implémentation démontre un chatbot IA génératif basique mais fonctionnel. La conception modulaire facilite l'extension et la personnalisation en fonction des besoins spécifiques. Bien que cet exemple utilise l'API d'OpenAI, les mêmes principes peuvent être appliqués avec d'autres modèles de langage ou API.

N'oubliez pas que lors du déploiement d'un chatbot, vous devez considérer :

• Coûts de l'API et limites d'utilisation
• Confidentialité et sécurité des données utilisateur
• Latence de réponse et optimisation
• Validation des entrées et modération du contenu

Ressources

• Documentation de l'API OpenAI
• Documentation diffusée
• Gestion de l'environnement Python

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!