processing_query.py

import pandas as pd
from sklearn.metrics.pairwise import cosine_similarity
import numpy as np
# from read_chunks import create_embedding
import joblib
import requests
from google import genai  # <--- New library import
from dotenv import load_dotenv
import os
# import time

# 1. Setup Gemini Client
load_dotenv()
# The client automatically handles the configuration
client = genai.Client(api_key=os.getenv("GEMINI_API_KEY"))

def create_embedding(text_list):
    # https://github.com/ollama/ollama/blob//main/docs/api.md#generate-embeddings
    r = requests.post("http://localhost:11434/api/embed", json={
        "model": "bge-m3",
        "input": text_list
    })

    embedding = r.json()['embeddings']
    return embedding

def inference(prompt):
    try:
        # Using the new 2026 'gemini-3-flash' model
        print("Thinking...")
        response = client.models.generate_content(
            model='gemini-3-flash-preview', 
            contents=prompt
        )
        return response.text
    except Exception as e:
        return f"Error connecting to Gemini: {e}"

# LIVE STREAMING OF THE TEXT!
# def gemini_inference_stream(prompt):
#     """
#     Streams the response live to the console and returns the complete text.
#     Designed for the google-genai SDK using the free Flash model.
#     """
#     full_response = ""
    
#     try:
#         # Call the streaming method
#         response_stream = client.models.generate_content_stream(
#             model='gemini-3-flash-preview', 
#             contents=prompt
#         )
        
#         # Process the stream chunk by chunk
#         for chunk in response_stream:
#             # 1. Print the chunk to the screen immediately
#             print(chunk.text, end='', flush=True)
            
#             # 2. Add the chunk to our complete string
#             full_response += chunk.text
            
#         print() # Add a final newline when the stream finishes
#         return full_response
        
#     except Exception as e:
#         # Simple error handling and rate limit retry
#         if "429" in str(e) or "RESOURCE_EXHAUSTED" in str(e):
#             print("\n[Rate limit hit. Waiting 15 seconds...]")
#             time.sleep(15)
#             try:
#                 retry_stream = client.models.generate_content_stream(
#                     model='gemini-3-flash-preview', 
#                     contents=prompt
#                 )
#                 for chunk in retry_stream:
#                     print(chunk.text, end='', flush=True)
#                     full_response += chunk.text
#                 print()
#                 return full_response
#             except Exception as retry_e:
#                 return f"\nError on retry: {retry_e}"
                
#         return f"\nError connecting to Gemini: {e}"

# def inference(prompt):
#     r = requests.post("http://localhost:11434/api/generate", json={
#         "model": "llama3.2",
#         "prompt": prompt,
#         "stream": False
#     })
#     response = r.json()
#     print(response)
#     return response

df = joblib.load('embeddings.joblib')

user_query = input("Type your thoughts! -> ")
query_embedding = create_embedding([user_query])[0]
# print(query_embedding)

# print(np.vstack(df['embedding'].values))
# print(np.vstack(df['embedding']).shape)

similarity = cosine_similarity(np.vstack(df['embedding']), [query_embedding]).flatten()
# print(similarity)
top_result = 5
max_index = similarity.argsort()[::-1][0:top_result]
# print(max_index)

new_df = df.loc[max_index]
# print(new_df[['title', 'number', 'text']])

prompt = f"""
You are an AI assistant helping a teacher explain content from the Sigma Web Development course.

You are given video chunks in JSON format. Each chunk contains:
- title (video title)
- number (video number)
- start (start time in seconds)
- end (end time in seconds)
- text (spoken content)

VIDEO CHUNKS:
{new_df[['title', 'number', 'start', 'end', 'text']].to_json(orient="records")}

-----------------------------------------

USER QUESTION:
{user_query}

-----------------------------------------

INSTRUCTIONS:

1. Answer ONLY using the provided video chunks.
2. Identify:
   - Which video(s) contain the answer
   - Exact timestamps (start → end)
   - How much of the topic is covered (brief / partial / detailed)

3. Response format:
   - Mention video title and number
   - Provide timestamps in seconds or mm:ss
   - Briefly describe what is explained in that segment
   - Guide the user clearly on where to watch

4. If multiple relevant chunks exist:
   - Combine them into a clear, structured answer

5. If the question is NOT related to the course or no relevant chunks are found:
   - Respond with:
     "I am designed to answer questions only related to the Sigma Web Development course content."

6. Keep the tone natural and human-like.
7. Do NOT mention JSON, chunks, or internal data.

-----------------------------------------

ANSWER:
"""

with open("prompt.txt", "w", encoding="utf-8") as f:
    f.write(prompt)

# # ... [Your existing vector search and prompt construction code] ...

#     print("\n--- Course Assistant Response ---\n")
    
#     # The function prints to the screen live, and saves the full text to 'answer'
#     answer = gemini_inference_stream(prompt)

#     # Now you can still save it to your file just like before!
#     with open("response.txt", "w", encoding="utf-8") as f:
#         f.write(answer)

response = inference(prompt)
print(response)
# response = inference(prompt)["response"]
# print(response)

with open("response.txt", "w", encoding="utf-8") as f:
    f.write(response)

# for index, item in new_df.iterrows():
#     print(index, item['title'], item['number'], item['text'], item['start'], item['end'])