Welcome back! In the previous lesson, we explored the importance of a robust system prompt and how it guides the behavior of our chatbot. Now, we will delve into the next step of our journey: building the Chat Manager. This lesson will focus on the model layer of the MVC (Model-View-Controller) architecture, which is crucial for organizing and managing data in a structured way. The ChatManager class will be the core component of our model layer, responsible for managing chat data effectively. By the end of this lesson, you will understand how to create, manage, and retrieve chat data using the ChatManager class.

The ChatManager class is designed to handle the storage and management of chat data. It serves as the backbone of our chatbot's data management system.. We'll start by setting up the class and then gradually add methods to handle chat creation, message addition, and conversation retrieval.

Let's begin by defining the ChatManager class and its constructor. The constructor initializes an empty dictionary, self.chats, which will store all chat data.

Python
Copy to clipboard
1class ChatManager:
2    def __init__(self):
3        self.chats = {}  # user_id -> chat_id -> chat_data

In this setup, self.chats is a nested dictionary where the first key is the user_id, and the second key is the chat_id. This structure allows us to efficiently manage multiple chats for different users.

Next, we'll add the create_chat method. This method is responsible for creating a new chat entry for a user. It takes three parameters: user_id, chat_id, and system_prompt.

Python
Copy to clipboard
1class ChatManager:
2    def __init__(self):
3        self.chats = {}
4
5    def create_chat(self, user_id, chat_id, system_prompt):
6        """Create a new chat for a user."""
7        if user_id not in self.chats:
8            self.chats[user_id] = {}
9        
10        self.chats[user_id][chat_id] = {
11            'system_prompt': system_prompt,
12            'messages': []
13        }

The create_chat method checks if the user_id exists in self.chats. If not, it creates a new entry. Then, it initializes the chat with the provided system_prompt and an empty list for messages.

To access a specific chat, we need the get_chat method. This method retrieves a chat based on the user_id and chat_id.

Python
Copy to clipboard
1def get_chat(self, user_id, chat_id):
2    """Get a chat by user_id and chat_id."""
3    return self.chats.get(user_id, {}).get(chat_id)

The get_chat method uses the get function to safely access the nested dictionary, returning the chat data if it exists.

Now, let's add the add_message method. This method allows us to append messages to a chat. It requires the user_id, chat_id, role, and content of the message.

Python
Copy to clipboard
1def add_message(self, user_id, chat_id, role, content):
2    """Add a message to a chat."""
3    if chat := self.get_chat(user_id, chat_id):
4        chat['messages'].append({"role": role, "content": content})

The add_message method first retrieves the chat using get_chat. If the chat exists, it appends the message to the chat's message list.

Finally, we'll implement the get_conversation method. This method returns the entire conversation, including the system prompt and all messages.

Python
Copy to clipboard
1def get_conversation(self, user_id, chat_id):
2    """Get the full conversation including system message."""
3    if chat := self.get_chat(user_id, chat_id):
4        system_message = {"role": "system", "content": chat['system_prompt']}
5        return [system_message] + chat['messages']
6    return []

The get_conversation method retrieves the chat and constructs a list starting with the system prompt, followed by the chat messages. If the chat does not exist, it returns an empty list.

By following these steps, we've built a fully functional ChatManager class that can create and manage chats, add messages, and retrieve chat histories.

To create a new chat, we use the create_chat method. This method takes three parameters: user_id, chat_id, and system_prompt. It initializes a new chat entry in the self.chats dictionary. If the user_id does not already exist in the dictionary, a new entry is created. The chat entry includes the system prompt and an empty list for messages.

Here's an example of how to create a new chat:

Python
Copy to clipboard
1def load_system_prompt() -> str:
2    """Load the system prompt from file."""
3    try:
4        with open('data/system_prompt.txt', 'r') as f:
5            return f.read()
6    except Exception as e:
7        print(f"Error loading system prompt: {e}")
8        return "You are a helpful assistant."
9
10# Load the system prompt
11system_prompt = load_system_prompt()
12
13# Initialize manager
14manager = ChatManager()
15
16# Create a new chat
17user_id = "user123"
18chat_id = "chat123"
19manager.create_chat(user_id, chat_id, system_prompt)

In this example, we initialize a ChatManager instance and create a new chat for a user with the ID "user123". The chat is identified by "chat123" and is initialized with a system prompt. This setup allows us to manage chat data efficiently.

Once a chat is created, we can add messages to it using the add_message method. This method requires the user_id, chat_id, role, and content of the message. The role indicates whether the message is from the user or the assistant. The message is then appended to the chat's message list.

Here's how you can add messages to a chat:

Python
Copy to clipboard
1# Add some messages
2manager.add_message(user_id, chat_id, "user", "Hello!")
3manager.add_message(user_id, chat_id, "assistant", "Hi there!")

In this example, we add a user message, "Hello!", and an assistant response, "Hi there!", to the chat. The add_message method ensures that messages are stored in the correct chat entry.

To retrieve the entire conversation, including the system prompt, we use the get_conversation method. This method returns a list of messages, starting with the system prompt followed by the chat messages.

Python
Copy to clipboard
1# Get chat history
2conversation = manager.get_conversation(user_id, chat_id)

The get_conversation method compiles the chat history, allowing us to access the full context of the conversation.

In this lesson, we explored the ChatManager class and its role in managing chat data within the model layer of our application. We learned how to create and manage chats, add messages, and retrieve chat histories. The ChatManager is a crucial component for organizing chat data, ensuring that our chatbot can handle multiple conversations efficiently.

As you move on to the practice exercises, take the opportunity to experiment with modifying and extending the ChatManager functionality. This hands-on practice will reinforce the concepts covered in this lesson and prepare you for the next steps in our course. Keep up the great work, and I look forward to seeing your progress!