Message Types and Session History

Welcome back! In the previous lessons, you learned how to send a simple query to DeepSeek's language model and explored various model parameters to customize the AI's responses. Now, we will delve into the concept of message types and the importance of maintaining session history. These elements are crucial for creating dynamic and context-aware interactions with the AI, allowing your personal tutor to engage in more meaningful educational conversations.

Before we dive into building and managing session history, it's important to understand the concept of message types and how a tutoring session history is structured. In a tutor-student interaction, messages are typically categorized by roles: system, user, and assistant. While we'll explore system prompts more thoroughly in a later lesson, remember that these primary roles help define the flow of dialogue and ensure the AI understands who is speaking at any given time.

DeepSeek expects the session history to be formatted as an array of hashes, where each hash represents a message with two key-value pairs: role and content. Here's an example of what a simple tutoring session might look like:

[
  {"role": "user", "content": "Can you explain the theory of relativity?"},
  {"role": "assistant", "content": "Einstein's theory of relativity consists of two parts: special relativity and general relativity..."},
  {"role": "user", "content": "What practical applications does it have?"},
  {"role": "assistant", "content": "The theory of relativity has several practical applications including GPS systems, particle accelerators, and understanding astronomical phenomena."}
]

In this example, the session history consists of alternating messages between the user (the student) and the assistant (the AI tutor). Each message is stored with its respective role, providing context for the AI to generate appropriate educational responses. Understanding this structure is key to effectively managing tutoring sessions and ensuring that the AI can provide coherent and contextually relevant explanations.

To manage tutoring sessions effectively, we will create a method called send_query. This method will send queries to the AI and receive explanations, allowing us to handle multiple interactions seamlessly. Here's how the method is structured in Ruby:

require "openai"

# Initialize the DeepSeek client
client = OpenAI::Client.new(
  access_token: "deepseek_api_key",
  uri_base: "https://api.deepseek.com"
)

# Method to send a tutoring query and receive an explanation
def send_query(client, messages)
  response = client.chat(
    parameters: {
      model: "deepseek-ai/DeepSeek-V3",
      messages: messages
    }
  )
  response.dig("choices", 0, "message", "content").strip
end

In this method, we use the chat method of the client to send an array of messages to the AI. The messages parameter contains the session history, which provides context for the AI's response. The method returns the AI's explanation, which is extracted from the API result and stripped of any leading or trailing whitespace.