process_incoming.py

import pandas as pd
import requests
import numpy as np 
from sklearn.metrics.pairwise import cosine_similarity
import joblib
import threading
import time
import sys
from openai import OpenAI
import os
from dotenv import load_dotenv

load_dotenv(".env.local")
OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
if not OPENAI_API_KEY:
    raise RuntimeError("OPENAI_API_KEY not found")

client = OpenAI(api_key=OPENAI_API_KEY)

def show_loading():
    """Display animated loading message"""
    loading_chars = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏']
    i = 0
    while loading_active:
        sys.stdout.write(f'\r{loading_chars[i % len(loading_chars)]} Thinking...')
        sys.stdout.flush()
        time.sleep(0.1)
        i += 1
    # Clear the loading message
    sys.stdout.write('\r' + ' ' * 15 + '\r')
    sys.stdout.flush()

def create_embedding(text_list):
    r = requests.post("http://localhost:11434/api/embed", json={
        "model": "bge-m3",
        "input": text_list
    })
    embedding = r.json()["embeddings"]
    return embedding

# def inference(prompt):
#     r = requests.post("http://localhost:11434/api/generate", json={
#         "model": "llama3.2:latest",
#         "prompt": prompt,
#         "stream": False,
#         # "max_new_tokens": 512,
#         # "temperature": 0.1,
#         # "top_p": 0.75,
#         # "stop": ["###"]
#     })

    # response = r.json()
    # return response


def response_openai(prompt):
    response_openai = client.responses.create(
    model="gpt-5",
    input=prompt
   )
    return response_openai.output_text






# Load the embeddings dataframe
df = joblib.load("embeddings_df.joblib")    

# Get user input
incoming_query = input("Enter your query: ")

# Global flag to control loading animation
loading_active = True

# Start loading animation in a separate thread
loading_thread = threading.Thread(target=show_loading, daemon=True)
loading_thread.start()

try:
    # Process the query
    question_embedding = create_embedding([incoming_query])[0]
    
    # Find similarities
    similarities = cosine_similarity(np.vstack(df["embedding"].values), [question_embedding]).flatten()
    
    # Get top results
    top_result = 5
    max_indx = similarities.argsort()[::-1][0:top_result]
    
    new_df = df.loc[max_indx]
    
    # Create the prompt
    prompt = f"""
You are a course assistant helping students learn from the Sigma Web Development Course.

You'll receive subtitle chunks from the course videos. Each chunk contains:
- Video title
- Video number
- Chunk ID
- Start time in seconds
- End time in seconds
- Transcript text

Your job:
1. Response as a human should when asked about that query
2. After that sentence, **show the relevant information in a clean structured format**:
   - Mention **Video Number + Title** at the top.
   - List each relevant segment with timestamps converted from **seconds to minutes:seconds format** (for example:  
     - 111 seconds → 1:51  
     - 356 seconds → 5:56  
     - 654 seconds → 10:54).
   - Give a short one-line description of what is explained in that segment.

3. dont response too short and dont response too big also, it should be perfect and good enough response like a human.
4. End with a **Tip** line summarizing where to start watching.
5. **Do NOT ask the student any questions at the end.** Only give the response.
6. Use bullet points or a time-coded guide (like the example below):

Example output style:
ID and Class attributes in HTML are taught in Video 9 called "Id & Classes in HTML".
Video 9: "Id & Classes in HTML"

• 0:48 - 0:50 → Definition of ID attribute
• 0:49 - 0:51 → Definition of class attribute
• 1:18 - 1:21 → Usage of ID and classes in CSS

Tip: Watch from around 0:49 onwards for a clear explanation of both attributes.

7. **No small talk** - be factual and focused.
8. If the question is unrelated to the course, reply with: "I can only answer questions related to this course."
9. If not enough info is available, reply: "I'm not sure about that."

Here are the subtitle chunks you can use:
{new_df[["title", "number", "id", "start", "end", "text"]].to_json(orient="records", lines=False)}

--------------------------------------------------------------------------------------------------------
Student's Question: "{incoming_query}"
"""

    # Save prompt to file
    with open("prompt.txt", "w", encoding="utf-8") as f:
        f.write(prompt)
    
    # Get response from the model
    # response = inference(prompt)
    
    # Stop loading animation
    loading_active = False
    loading_thread.join(timeout=0.1)  # Wait briefly for thread to finish
    
    # Extract and display the response
    # response_text = response.get("response", "")
    # print(response_text)

    response_text = response_openai(prompt)
    print(response_text)
    
    # Save response to file
    with open("response.txt", "w", encoding="utf-8") as f:
        f.write(response_text)

except Exception as e:
    # Stop loading animation in case of error
    loading_active = False
    loading_thread.join(timeout=0.1)
    print(f"\nError occurred: {str(e)}")

# Commented out debug section
# for index, item in new_df.iterrows():
#     print(index)
#     print(f"Title: {item['title']}")
#     print(f"Video Number: {item['number']}")
#     print(f"Chunk ID: {item['id']}")
#     print(f"Text: {item['text']}")
#     print(f"start: {item['start']/60}")
#     print(f"end: {item['end']/60}")
#     print("\n---\n")