Introduction
In this tutorial, we'll explore how to build and deploy an AI agent similar to Meta's Muse using Python and the OpenAI API. While Muse has gained significant traction as the No. 2 app in the US, understanding the underlying technology will help you create your own intelligent agents. We'll focus on building a conversational AI agent that can handle multi-turn conversations, understand context, and provide helpful responses.
Prerequisites
- Python 3.8 or higher installed
- Basic understanding of Python programming
- OpenAI API key (free to get at platform.openai.com)
- Basic knowledge of REST APIs and HTTP requests
- Installed packages: openai, python-dotenv, flask
Step-by-step instructions
Step 1: Set up your development environment
Install required packages
First, we need to install the necessary Python packages for our AI agent. The openai package provides the interface to OpenAI's API, while python-dotenv helps manage our API keys securely.
pip install openai python-dotenv flaskCreate project structure
Let's create a basic project structure for our AI agent:
ai-agent-project/
├── app.py
├── .env
├── requirements.txt
└── README.mdStep 2: Configure your API credentials
Create environment file
Create a .env file in your project root to securely store your OpenAI API key:
OPENAI_API_KEY=your_api_key_hereImportant: Never commit your API keys to version control. The .env file should be added to your .gitignore.
Load environment variables
Update your app.py to load the environment variables:
import os
from openai import OpenAI
from dotenv import load_dotenv
# Load environment variables
load_dotenv()
# Initialize OpenAI client
client = OpenAI(api_key=os.getenv('OPENAI_API_KEY'))Step 3: Build the core AI agent functionality
Create conversation history management
For an intelligent agent like Muse, we need to maintain conversation context. Let's create a class to manage conversation history:
class AIConversation:
def __init__(self, model="gpt-4o"):
self.model = model
self.messages = []
def add_message(self, role, content):
self.messages.append({"role": role, "content": content})
def get_messages(self):
return self.messages
def clear_history(self):
self.messages = []Implement the response generation function
Now we'll create the core function that sends messages to OpenAI and returns responses:
def generate_response(conversation, user_input):
# Add user message to conversation
conversation.add_message("user", user_input)
try:
# Send conversation to OpenAI API
response = client.chat.completions.create(
model=conversation.model,
messages=conversation.get_messages(),
max_tokens=150,
temperature=0.7
)
# Extract and return the AI's response
ai_response = response.choices[0].message.content
# Add AI response to conversation history
conversation.add_message("assistant", ai_response)
return ai_response
except Exception as e:
return f"Sorry, I encountered an error: {str(e)}"Step 4: Create a web interface for your agent
Set up Flask web server
Let's create a simple web interface to interact with our AI agent:
from flask import Flask, render_template, request, jsonify
app = Flask(__name__)
conversation = AIConversation()
@app.route('/')
def index():
return render_template('index.html')
@app.route('/chat', methods=['POST'])
def chat():
user_message = request.json.get('message')
response = generate_response(conversation, user_message)
return jsonify({'response': response})
if __name__ == '__main__':
app.run(debug=True)Create HTML template
Create a simple HTML interface in a templates folder:
<!DOCTYPE html>
<html>
<head>
<title>AI Agent</title>
</head>
<body>
<div id="chat-container">
<div id="messages"></div>
<input type="text" id="user-input" placeholder="Type your message...">
<button onclick="sendMessage()">Send</button>
</div>
<script>
function sendMessage() {
const input = document.getElementById('user-input');
const message = input.value;
if (message.trim() === '') return;
// Display user message
displayMessage(message, 'user');
input.value = '';
// Send to backend
fetch('/chat', {
method: 'POST',
headers: {'Content-Type': 'application/json'},
body: JSON.stringify({message: message})
})
.then(response => response.json())
.then(data => {
displayMessage(data.response, 'assistant');
});
}
function displayMessage(text, sender) {
const messagesDiv = document.getElementById('messages');
const messageDiv = document.createElement('div');
messageDiv.textContent = text;
messageDiv.className = sender;
messagesDiv.appendChild(messageDiv);
messagesDiv.scrollTop = messagesDiv.scrollHeight;
}
</script>
</body>
</html>Step 5: Enhance agent capabilities
Add context awareness
To make our agent more sophisticated like Muse, we'll add context awareness:
def generate_response_with_context(conversation, user_input):
# Add system prompt for better context awareness
if not conversation.messages:
conversation.add_message("system", "You are a helpful AI assistant. Keep responses concise and helpful. Remember the conversation context.")
# Add user message
conversation.add_message("user", user_input)
try:
response = client.chat.completions.create(
model=conversation.model,
messages=conversation.get_messages(),
max_tokens=200,
temperature=0.7,
top_p=0.9
)
ai_response = response.choices[0].message.content
conversation.add_message("assistant", ai_response)
return ai_response
except Exception as e:
return f"Sorry, I encountered an error: {str(e)}"Implement conversation length management
To prevent token overflow, let's limit conversation history:
class AIConversation:
def __init__(self, model="gpt-4o", max_history=10):
self.model = model
self.messages = []
self.max_history = max_history
def add_message(self, role, content):
self.messages.append({"role": role, "content": content})
# Keep conversation history within limits
if len(self.messages) > self.max_history:
# Keep system message if present, remove oldest user/assistant messages
if self.messages[0]["role"] == "system":
self.messages = [self.messages[0]] + self.messages[-self.max_history+1:]
else:
self.messages = self.messages[-self.max_history:]
def get_messages(self):
return self.messagesStep 6: Deploy and test your agent
Run the application
With everything set up, run your Flask application:
python app.pyVisit http://localhost:5000 in your browser to interact with your AI agent.
Test with various inputs
Try asking questions like:
- "What is the capital of France?"
- "Can you tell me more about that?"
- "How about Germany?"
Notice how your agent maintains context and provides relevant responses.
Summary
In this tutorial, we've built a foundational AI agent similar to Meta's Muse using Python and OpenAI's API. We created a conversational interface that maintains context, manages conversation history, and provides helpful responses. The key concepts covered include:
- Setting up API credentials securely with environment variables
- Managing conversation history for context awareness
- Implementing error handling for robust operation
- Building a web interface for user interaction
- Optimizing token usage and conversation length
This foundation can be extended with features like function calling, tool usage, and integration with other services to create more sophisticated agents. As demonstrated by Muse's success, the key to effective AI agents lies in understanding context, maintaining coherent conversations, and providing value to users.
