In this tutorial, we'll walk through creating a generative AI chatbot using Python and the OpenAI API. We'll build a chatbot that can engage in natural conversations while maintaining context and providing helpful responses.
Prerequisites
- Python 3.8+
- Basic understanding of Python programming
- OpenAI API key
- Basic knowledge of RESTful APIs
Setting Up the Environment
First, let's set up our development environment. Create a new Python project and install the required dependencies:
pip install openai python-dotenv streamlit
Project Structure
Our chatbot will have a clean, modular structure:
chatbot/
├── .env
├── app.py
├── chat_handler.py
└── requirements.txt
Implementation
Let's start with our core chatbot logic in 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)}"
Now, let's create a simple web interface using Streamlit in 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()
Key Features
- Conversation Memory: The chatbot maintains context by storing the conversation history.
- System Prompt: We define the chatbot's behavior and personality through a system prompt.
- Error Handling: The implementation includes basic error handling for API calls.
- User Interface: A clean, intuitive web interface using Streamlit.
Running the Chatbot
- Create a
.envfile with your OpenAI API key:
OPENAI_API_KEY=your_api_key_here
- Run the application:
streamlit run app.py
Potential Enhancements
- Conversation Persistence: Add database integration to store chat histories.
- Custom Personalities: Allow users to select different chatbot personalities.
- Input Validation: Add more robust input validation and sanitization.
- API Rate Limiting: Implement rate limiting to manage API usage.
- Response Streaming: Add streaming responses for better user experience.
Conclusion
This implementation demonstrates a basic but functional generative AI chatbot. The modular design makes it easy to extend and customize based on specific needs. While this example uses OpenAI's API, the same principles can be applied with other language models or APIs.
Remember that when deploying a chatbot, you should consider:
- API costs and usage limits
- User data privacy and security
- Response latency and optimization
- Input validation and content moderation
Top comments (1)
Nice!