Implementing the Service Layer

pub struct TutorService {
    session_manager: SessionManager,
    client: Client<OpenAIConfig>,
    system_prompt: String,
}

impl TutorService {
    pub fn new() -> Self {
        dotenv::dotenv().ok();
        let api_key = env::var("OPENAI_API_KEY").expect("OPENAI_API_KEY not set");
        let base_url = env::var("OPENAI_BASE_URL").expect("OPENAI_BASE_URL not set");

        let config = OpenAIConfig::new()
            .with_api_key(api_key)
            .with_api_base(base_url);
        let client = Client::with_config(config);

        let system_prompt = fs::read_to_string("data/system_prompt.txt")
            .unwrap_or_else(|e| {
                eprintln!("Error loading system prompt: {}", e);
                "You are a helpful tutor.".to_string()
            });

        Self {
            session_manager: SessionManager::new(),
            client,
            system_prompt,
        }
    }
}

impl TutorService {
    // ... (other methods)

    pub fn create_session(&mut self, student_id: &str) -> String {
        let session_id = Uuid::new_v4().to_string();
        self.session_manager
            .create_session(student_id, &session_id, &self.system_prompt);
        session_id
    }
}

impl TutorService {
    // ... (other methods)

    pub async fn process_query(
        &mut self,
        student_id: &str,
        session_id: &str,
        query: &str,
    ) -> Result<String> {
        self.session_manager
            .get_session(student_id, session_id)
            .ok_or_else(|| anyhow!("Session not found"))?;
        self.session_manager
            .add_message(student_id, session_id, "user", query)?;

        let conversation = self.session_manager.get_conversation(student_id, session_id);

        let request = CreateChatCompletionRequestArgs::default()
            .model("deepseek-ai/DeepSeek-V3")
            .messages(conversation)
            .temperature(0.6)
            .max_tokens(500_u32)
            .build()?;
        let response = self.client.chat().create(request).await?;

        let tutor_response = response.choices[0]
            .message.content.as_deref().unwrap_or_default().trim().to_string();

        self.session_manager
            .add_message(student_id, session_id, "assistant", &tutor_response)?;

        Ok(tutor_response)
    }
}

#[tokio::main]
async fn main() -> Result<()> {
    // Initialize the tutor service
    let mut tutor_service = TutorService::new();

    // Simulate a student ID
    let student_id = "student123";

    // Create a new tutoring session
    let session_id = tutor_service.create_session(student_id);
    println!("Tutoring session created with ID: {}", session_id);

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

    // Call process_query and handle any errors
    match tutor_service
        .process_query(student_id, &session_id, student_query)
        .await
    {
        Ok(tutor_response) => {
            println!("Tutor Response: {}", tutor_response);
        }
        Err(e) => {
            eprintln!("Error: {}", e);
        }
    }

    Ok(())
}

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?