Building the Tutor Service Layer in Go

In the previous lesson, we explored the SessionManager struct, which plays a crucial role in managing tutoring session data within our application. Now, we will take the next step by building the Tutor Service Layer in Go. This layer is essential for integrating the DeepSeek language model with tutoring sessions, allowing us to process student queries and generate tailored explanations. By the end of this lesson, you will understand how to set up the TutorService struct, create tutoring sessions, and process academic questions using DeepSeek models via the OpenAI Go SDK. The service layer acts as a bridge between the model layer, where data is managed, and the AI model, which generates educational responses. It is responsible for orchestrating the flow of data and ensuring that student interactions are handled effectively. Let's dive into the details of setting up this important component.

Setting Up the TutorService Struct

The TutorService struct is the heart of our service layer. It is responsible for managing tutoring sessions and interacting with the DeepSeek model to generate educational responses. In Go, we use structs and associated methods instead of classes. To begin, we need to define the struct and its components. First, we import the necessary packages, including the SessionManager from our previous lesson (now located at app/session/session_manager.go), the OpenAI Go SDK, and the UUID package for generating unique session IDs. Here is how the struct is defined and initialized: Gopackage services import ( "context" "fmt" "log" "os" "main/app/session" "github.com/google/uuid" "github.com/openai/openai-go" "github.com/openai/openai-go/option" ) type TutorService struct { sessionManager *session.SessionManager deepseekClient *openai.Client systemPrompt string } // NewTutorService initializes a new TutorService with required dependencies. func NewTutorService(apiKey, baseURL, promptPath string) *TutorService { client := openai.NewClient( option.WithAPIKey(apiKey), option.WithBaseURL(baseURL), ) sm := session.NewSessionManager() prompt := loadSystemPrompt(promptPath) return &TutorService{ sessionManager: sm, deepseekClient: &client, systemPrompt: prompt, } } In this setup, we instantiate SessionManager to manage tutoring data, initialize the OpenAI client for DeepSeek model access, and load the systemPrompt using the loadSystemPrompt function, which we'll discuss next.

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

func loadSystemPrompt(filePath string) string {
    data, err := os.ReadFile(filePath)
    if err != nil {
        log.Printf("Error loading system prompt: %v", err)
        return "You are a helpful tutor."
    }
    return string(data)
}

func loadSystemPrompt(filePath string) string {
    data, err := os.ReadFile(filePath)
    if err != nil {
        log.Printf("Error loading system prompt: %v", err)
        return "You are a helpful tutor."
    }
    return string(data)
}

func (ts *TutorService) CreateSession(studentID string) string {
    sessionID := uuid.NewString()
    ts.sessionManager.CreateSession(studentID, sessionID, ts.systemPrompt)
    return sessionID
}

func (ts *TutorService) CreateSession(studentID string) string {
    sessionID := uuid.NewString()
    ts.sessionManager.CreateSession(studentID, sessionID, ts.systemPrompt)
    return sessionID
}

func (ts *TutorService) ProcessQuery(studentID, sessionID, query string) (string, error) {
    // Step 1: Retrieve the session
    session := ts.sessionManager.GetSession(studentID, sessionID)
    if session == nil {
        return "", fmt.Errorf("session not found")
    }

    // Step 2: Add student's query to session
    ts.sessionManager.AddMessage(studentID, sessionID, "user", query)

    // Step 3: Get the conversation history
    conversation := ts.sessionManager.GetConversation(studentID, sessionID)
    
    // Step 4: Convert conversation to OpenAI message format
    var messages []openai.ChatCompletionMessageParamUnion
    for _, m := range conversation {
        switch m.Role {
        case "user":
            messages = append(messages, openai.UserMessage(m.Content))
        case "assistant":
            messages = append(messages, openai.AssistantMessage(m.Content))
        case "system":
            messages = append(messages, openai.SystemMessage(m.Content))
        }
    }
    
    // Step 5: Use the DeepSeek client to generate a response
    chatCompletion, err := ts.deepseekClient.Chat.Completions.New(
        context.Background(),
        openai.ChatCompletionNewParams{
            Messages:    messages,
            Model:       "deepseek-ai/DeepSeek-V3",
            Temperature: openai.Float(0.7),
            MaxTokens:   openai.Int(500),
        },
    )
    if err != nil {
        return "", fmt.Errorf("error getting AI response: %w", err)
    }
    
    // Step 6: Extract the AI's response
    if len(chatCompletion.Choices) == 0 {
        return "", fmt.Errorf("no response from AI model")
    }
    aiResponse := chatCompletion.Choices[0].Message.Content
    
    // Step 7: Add the AI's response to the session history
    ts.sessionManager.AddMessage(studentID, sessionID, "assistant", aiResponse)
    
    return aiResponse, nil
}

func (ts *TutorService) ProcessQuery(studentID, sessionID, query string) (string, error) {
    // Step 1: Retrieve the session
    session := ts.sessionManager.GetSession(studentID, sessionID)
    if session == nil {
        return "", fmt.Errorf("session not found")
    }

    // Step 2: Add student's query to session
    ts.sessionManager.AddMessage(studentID, sessionID, "user", query)

    // Step 3: Get the conversation history
    conversation := ts.sessionManager.GetConversation(studentID, sessionID)
    
    // Step 4: Convert conversation to OpenAI message format
    var messages []openai.ChatCompletionMessageParamUnion
    for _, m := range conversation {
        switch m.Role {
        case "user":
            messages = append(messages, openai.UserMessage(m.Content))
        case "assistant":
            messages = append(messages, openai.AssistantMessage(m.Content))
        case "system":
            messages = append(messages, openai.SystemMessage(m.Content))
        }
    }
    
    // Step 5: Use the DeepSeek client to generate a response
    chatCompletion, err := ts.deepseekClient.Chat.Completions.New(
        context.Background(),
        openai.ChatCompletionNewParams{
            Messages:    messages,
            Model:       "deepseek-ai/DeepSeek-V3",
            Temperature: openai.Float(0.7),
            MaxTokens:   openai.Int(500),
        },
    )
    if err != nil {
        return "", fmt.Errorf("error getting AI response: %w", err)
    }
    
    // Step 6: Extract the AI's response
    if len(chatCompletion.Choices) == 0 {
        return "", fmt.Errorf("no response from AI model")
    }
    aiResponse := chatCompletion.Choices[0].Message.Content
    
    // Step 7: Add the AI's response to the session history
    ts.sessionManager.AddMessage(studentID, sessionID, "assistant", aiResponse)
    
    return aiResponse, nil
}

package main

import (
    "fmt"
    "log"
    "os"
    "main/app/services"
)

func main() {
    apiKey := os.Getenv("OPENAI_API_KEY")
    baseURL := os.Getenv("OPENAI_BASE_URL")
    if apiKey == "" {
        log.Fatal("Please set the OPENAI_API_KEY environment variable.")
    }
    if baseURL == "" {
        baseURL = "https://api.openai.com/v1"
    }

    // Path to the system prompt file
    promptPath := "data/system_prompt.txt"

    // Initialize the tutor service
    tutorService := services.NewTutorService(apiKey, baseURL, promptPath)

    // Simulate a student ID
    studentID := "student123"

    // Create a new tutoring session
    sessionID := tutorService.CreateSession(studentID)
    fmt.Printf("Tutoring session created with ID: %s\n", sessionID)

    // Simulate sending a tutoring query
    studentQuery := "Can you explain the principles of supply and demand in economics?"

    tutorResponse, err := tutorService.ProcessQuery(studentID, sessionID, studentQuery)
    if err != nil {
        fmt.Printf("Error: %v\n", err)
        return
    }
    fmt.Printf("Tutor Response: %s\n", tutorResponse)
}

package main

import (
    "fmt"
    "log"
    "os"
    "main/app/services"
)

func main() {
    apiKey := os.Getenv("OPENAI_API_KEY")
    baseURL := os.Getenv("OPENAI_BASE_URL")
    if apiKey == "" {
        log.Fatal("Please set the OPENAI_API_KEY environment variable.")
    }
    if baseURL == "" {
        baseURL = "https://api.openai.com/v1"
    }

    // Path to the system prompt file
    promptPath := "data/system_prompt.txt"

    // Initialize the tutor service
    tutorService := services.NewTutorService(apiKey, baseURL, promptPath)

    // Simulate a student ID
    studentID := "student123"

    // Create a new tutoring session
    sessionID := tutorService.CreateSession(studentID)
    fmt.Printf("Tutoring session created with ID: %s\n", sessionID)

    // Simulate sending a tutoring query
    studentQuery := "Can you explain the principles of supply and demand in economics?"

    tutorResponse, err := tutorService.ProcessQuery(studentID, sessionID, studentQuery)
    if err != nil {
        fmt.Printf("Error: %v\n", err)
        return
    }
    fmt.Printf("Tutor Response: %s\n", tutorResponse)
}

text

Tutoring session created with ID: 01a17870-8a4f-4b6f-a3ce-f04e1136d597
Tutor Response: Supply and demand are fundamental principles in economics that describe how prices are determined in a market economy. Let me explain each concept and how they interact:

1. Supply: This refers to the quantity of a good or service that producers are willing and able to offer for sale at various price points. 
   - The law of supply states that as the price of a good increases, the quantity supplied also increases (and vice versa).
   - This creates an upward-sloping supply curve when plotted on a graph with price on the vertical axis and quantity on the horizontal axis.

2. Demand: This refers to the quantity of a good or service that consumers are willing and able to purchase at various price points.
   - The law of demand states that as the price of a good increases, the quantity demanded decreases (and vice versa).
   - This creates a downward-sloping demand curve on the same type of graph.

3. Market Equilibrium: This occurs at the intersection of the supply and demand curves.
   - At this point, the quantity that producers want to supply exactly equals the quantity that consumers want to buy.
   - The price at this intersection is called the equilibrium price, and the quantity is called the equilibrium quantity.

4. Price Mechanism: When markets are not in equilibrium, the price acts as a signal:
   - If price is above equilibrium, there's a surplus (excess supply), which puts downward pressure on prices.
   - If price is below equilibrium, there's a shortage (excess demand), which puts upward pressure on prices.

5. Shifts in Supply and Demand: Various factors can cause entire curves to shift:
   - Supply shifters include technology, input costs, number of sellers, and expectations.
   - Demand shifters include income, preferences, number of buyers, and expectations.

These principles help explain how markets allocate resources efficiently and how changes in market conditions affect prices and quantities.

Does this explanation help? Would you like me to elaborate on any specific aspect of supply and demand?

Tutoring session created with ID: 01a17870-8a4f-4b6f-a3ce-f04e1136d597
Tutor Response: Supply and demand are fundamental principles in economics that describe how prices are determined in a market economy. Let me explain each concept and how they interact:

1. Supply: This refers to the quantity of a good or service that producers are willing and able to offer for sale at various price points. 
   - The law of supply states that as the price of a good increases, the quantity supplied also increases (and vice versa).
   - This creates an upward-sloping supply curve when plotted on a graph with price on the vertical axis and quantity on the horizontal axis.

2. Demand: This refers to the quantity of a good or service that consumers are willing and able to purchase at various price points.
   - The law of demand states that as the price of a good increases, the quantity demanded decreases (and vice versa).
   - This creates a downward-sloping demand curve on the same type of graph.

3. Market Equilibrium: This occurs at the intersection of the supply and demand curves.
   - At this point, the quantity that producers want to supply exactly equals the quantity that consumers want to buy.
   - The price at this intersection is called the equilibrium price, and the quantity is called the equilibrium quantity.

4. Price Mechanism: When markets are not in equilibrium, the price acts as a signal:
   - If price is above equilibrium, there's a surplus (excess supply), which puts downward pressure on prices.
   - If price is below equilibrium, there's a shortage (excess demand), which puts upward pressure on prices.

5. Shifts in Supply and Demand: Various factors can cause entire curves to shift:
   - Supply shifters include technology, input costs, number of sellers, and expectations.
   - Demand shifters include income, preferences, number of buyers, and expectations.

These principles help explain how markets allocate resources efficiently and how changes in market conditions affect prices and quantities.

Does this explanation help? Would you like me to elaborate on any specific aspect of supply and demand?

func loadSystemPrompt(filePath string) string {
    data, err := os.ReadFile(filePath)
    if err != nil {
        log.Printf("Error loading system prompt: %v", err)
        return "You are a helpful tutor."
    }
    return string(data)
}

func (ts *TutorService) CreateSession(studentID string) string {
    sessionID := uuid.NewString()
    ts.sessionManager.CreateSession(studentID, sessionID, ts.systemPrompt)
    return sessionID
}

func (ts *TutorService) ProcessQuery(studentID, sessionID, query string) (string, error) {
    // Step 1: Retrieve the session
    session := ts.sessionManager.GetSession(studentID, sessionID)
    if session == nil {
        return "", fmt.Errorf("session not found")
    }

    // Step 2: Add student's query to session
    ts.sessionManager.AddMessage(studentID, sessionID, "user", query)

    // Step 3: Get the conversation history
    conversation := ts.sessionManager.GetConversation(studentID, sessionID)
    
    // Step 4: Convert conversation to OpenAI message format
    var messages []openai.ChatCompletionMessageParamUnion
    for _, m := range conversation {
        switch m.Role {
        case "user":
            messages = append(messages, openai.UserMessage(m.Content))
        case "assistant":
            messages = append(messages, openai.AssistantMessage(m.Content))
        case "system":
            messages = append(messages, openai.SystemMessage(m.Content))
        }
    }
    
    // Step 5: Use the DeepSeek client to generate a response
    chatCompletion, err := ts.deepseekClient.Chat.Completions.New(
        context.Background(),
        openai.ChatCompletionNewParams{
            Messages:    messages,
            Model:       "deepseek-ai/DeepSeek-V3",
            Temperature: openai.Float(0.7),
            MaxTokens:   openai.Int(500),
        },
    )
    if err != nil {
        return "", fmt.Errorf("error getting AI response: %w", err)
    }
    
    // Step 6: Extract the AI's response
    if len(chatCompletion.Choices) == 0 {
        return "", fmt.Errorf("no response from AI model")
    }
    aiResponse := chatCompletion.Choices[0].Message.Content
    
    // Step 7: Add the AI's response to the session history
    ts.sessionManager.AddMessage(studentID, sessionID, "assistant", aiResponse)
    
    return aiResponse, nil
}

package main

import (
    "fmt"
    "log"
    "os"
    "main/app/services"
)

func main() {
    apiKey := os.Getenv("OPENAI_API_KEY")
    baseURL := os.Getenv("OPENAI_BASE_URL")
    if apiKey == "" {
        log.Fatal("Please set the OPENAI_API_KEY environment variable.")
    }
    if baseURL == "" {
        baseURL = "https://api.openai.com/v1"
    }

    // Path to the system prompt file
    promptPath := "data/system_prompt.txt"

    // Initialize the tutor service
    tutorService := services.NewTutorService(apiKey, baseURL, promptPath)

    // Simulate a student ID
    studentID := "student123"

    // Create a new tutoring session
    sessionID := tutorService.CreateSession(studentID)
    fmt.Printf("Tutoring session created with ID: %s\n", sessionID)

    // Simulate sending a tutoring query
    studentQuery := "Can you explain the principles of supply and demand in economics?"

    tutorResponse, err := tutorService.ProcessQuery(studentID, sessionID, studentQuery)
    if err != nil {
        fmt.Printf("Error: %v\n", err)
        return
    }
    fmt.Printf("Tutor Response: %s\n", tutorResponse)
}

text

Tutoring session created with ID: 01a17870-8a4f-4b6f-a3ce-f04e1136d597
Tutor Response: Supply and demand are fundamental principles in economics that describe how prices are determined in a market economy. Let me explain each concept and how they interact:

1. Supply: This refers to the quantity of a good or service that producers are willing and able to offer for sale at various price points. 
   - The law of supply states that as the price of a good increases, the quantity supplied also increases (and vice versa).
   - This creates an upward-sloping supply curve when plotted on a graph with price on the vertical axis and quantity on the horizontal axis.

2. Demand: This refers to the quantity of a good or service that consumers are willing and able to purchase at various price points.
   - The law of demand states that as the price of a good increases, the quantity demanded decreases (and vice versa).
   - This creates a downward-sloping demand curve on the same type of graph.

3. Market Equilibrium: This occurs at the intersection of the supply and demand curves.
   - At this point, the quantity that producers want to supply exactly equals the quantity that consumers want to buy.
   - The price at this intersection is called the equilibrium price, and the quantity is called the equilibrium quantity.

4. Price Mechanism: When markets are not in equilibrium, the price acts as a signal:
   - If price is above equilibrium, there's a surplus (excess supply), which puts downward pressure on prices.
   - If price is below equilibrium, there's a shortage (excess demand), which puts upward pressure on prices.

5. Shifts in Supply and Demand: Various factors can cause entire curves to shift:
   - Supply shifters include technology, input costs, number of sellers, and expectations.
   - Demand shifters include income, preferences, number of buyers, and expectations.

These principles help explain how markets allocate resources efficiently and how changes in market conditions affect prices and quantities.

Does this explanation help? Would you like me to elaborate on any specific aspect of supply and demand?

Building the Tutor Service Layer in Go

Setting Up the TutorService Struct

Join the 1M+ learners on CodeSignal

Loading the System Prompt

Creating a New Tutoring Session

Processing Student Queries

Example: Simulating a Tutoring Session

Summary and Next Steps