Merge branch 'master' of https://github.com/HarVkr/NovaScholar

chatbot.py

@@ -26,20 +26,26 @@ def insert_chat_message(user_id, session_id, role, content):
         upsert=True
     )
 
-
-def give_chat_response(user_id, session_id, question, context, prompt):
-    st.title("Chat with NOVA")
-    st.write("Ask any question and NOVA will provide an answer.")
-    
-    with st.form("chat_form"):
-        message = st.text_input("Message")
-        submit = st.form_submit_button("Send")
-        
-        if submit:
-            insert_chat_message(user_id, session_id, "user", message)
-            st.write(f"You: {message}")
-            
-            # Get response from NOVA
-            response = get_nova_response(question, context, prompt, message)
-            insert_chat_message(user_id, session_id, "nova", response)
-            st.write(f"NOVA: {response}")
+def give_chat_response(user_id, session_id, question, title, description, context):
+    context_prompt = f"""
+    Based on the following session title, description, and context, answer the user's question in 3-4 lines:
+    
+    Title: {title}
+    Description: {description}
+    Context: {context}
+    
+    Question: {question}
+    
+    Please provide a clear and concise answer based on the information provided.
+    """
+    
+    response = model.generate_content(context_prompt)
+    if not response or not response.text:
+        return "No response received from the model"
+    
+    assistant_response = response.text.strip()
+    
+    # Save the chat message
+    insert_chat_message(user_id, session_id, "assistant", assistant_response)
+    
+    return assistant_response

db.py

@@ -391,18 +391,6 @@ course_schema = {
 # }
 courses_collection2 = db["courses_collection2"]
 
-# courses_collection2.insert_one(sample_course)
-#  print("Sample course inserted successfully!")
-
-
-# sessions_collection.insert_one(session_data)
-# sessions_collection.delete_one({"session_id": "S101"})
-
-# course_id = "C101"
-# sessions = sessions_collection.find({"course_id": course_id})
-# for session in sessions:
-#     print(session)
-
 
 # Define the users schema
 users_schema = {
@@ -429,15 +417,6 @@ users_schema = {
 # db.create_collection("users", validator={"$jsonSchema": users_schema})
 users_collection = db["users"]
 
-# sample_user = {
-#     "user_id": "U103",
-#     "username": "Yash Desai",
-#     "password": generate_password_hash("yash"),
-#     "role": "Faculty",
-#     "created_at": datetime.utcnow()
-# }
-# users_collection.insert_one(sample_user)
-# print("Sample user inserted successfully!")
 
 # Defining the Student Collection
 student_schema = {
@@ -522,32 +501,6 @@ faculty_schema = {
 students_collection = db["students"]
 faculty_collection = db["faculty"]
 
-# Inserting Sample Student Data
-# sample_student = {
-#     "SID": "S102",
-#     "full_name": "Omkar Surve",
-#     "password": generate_password_hash("omkar"),
-#     "enrolled_courses": [
-#         {"course_id": "CS101", "title": "Introduction to Computer Science"}
-#     ],
-#     "created_at": datetime.utcnow()
-# }
-# # students_collection.insert_one(sample_student)
-# print("Sample student inserted successfully!")
-
-# Inserting Sample Faculty Data
-# sample_faculty = {
-#     "TID": "F101",
-#     "full_name": "Dr. John Doe",
-#     "password": generate_password_hash("john"),
-#     "courses_taught": [
-#         {"course_id": "CS101", "title": "Introduction to Computer Science"}
-#     ],
-#     "created_at": datetime.utcnow()
-# }
-# faculty_collection.insert_one(sample_faculty)
-# print("Sample faculty inserted successfully!")
-
 # Defining the Vector Collection Schema
 vector_schema = {
     "bsonType": "object",
@@ -620,10 +573,6 @@ chat_history_schema = {
 # db.create_collection("chat_history", validator={"$jsonSchema": chat_history_schema})
 chat_history_collection = db["chat_history"]
 
-# Create the collection with the schema
-# db.create_collection("chat_history", validator={"$jsonSchema": chat_history_schema})
-# chat_history_collection = db['chat_history']
-
 
 # Database setup for Research Assistant
 # Research Assistant Schema

gen_mcqs.py

@@ -0,0 +1,137 @@
+from pymongo import MongoClient
+from datetime import datetime
+import openai
+import google.generativeai as genai
+from google.generativeai import GenerativeModel
+from dotenv import load_dotenv
+import os
+from file_upload_vectorize import resources_collection, vectors_collection, courses_collection2, faculty_collection
+
+# Load environment variables
+load_dotenv()
+MONGO_URI = os.getenv('MONGO_URI')
+OPENAI_KEY = os.getenv('OPENAI_KEY')
+GEMINI_KEY = os.getenv('GEMINI_KEY')
+
+# Configure APIs
+openai.api_key = OPENAI_KEY
+genai.configure(api_key=GEMINI_KEY)
+model = genai.GenerativeModel('gemini-pro')
+
+# Connect to MongoDB
+client = MongoClient(MONGO_URI)
+db = client['novascholar_db']
+quizzes_collection = db["quizzes"]
+
+# New function to generate MCQs using Gemini
+def generate_mcqs(context, num_questions, session_title, session_description):
+    """Generate MCQs either from context or session details"""
+    try:
+        # Initialize Gemini model
+        if context:
+            prompt = f"""
+            Based on the following content, generate {num_questions} multiple choice questions.
+            Format each question as a Python dictionary with the following structure:
+            {{
+                "question": "Question text here",
+                "options": ["A) option1", "B) option2", "C) option3", "D) option4"],
+                "correct_option": "A) option1" or "B) option2" or "C) option3" or "D) option4"
+            }}
+            
+            Content:
+            {context}
+            
+            Generate challenging but clear questions that test understanding of key concepts.
+            Return only the Python list of dictionaries.
+            """
+        else:
+            prompt = f"""
+            Generate {num_questions} multiple choice questions about the topic:
+            Title: {session_title}
+            Description: {session_description}
+            
+            Format each question as a Python dictionary with the following structure:
+            {{
+                "question": "Question text here",
+                "options": ["A) option1", "B) option2", "C) option3", "D) option4"],
+                "correct_option": "A" or "B" or "C" or "D"
+            }}
+            
+            Generate challenging but clear questions.
+            Return only the Python list of dictionaries.
+            """
+        
+        response = model.generate_content(prompt)
+        # Extract and parse the response to get the list of MCQs
+        mcqs = eval(response.text)  # Be careful with eval, consider using ast.literal_eval for production
+        print(mcqs)
+        return mcqs
+    except Exception as e:
+        print(f"Error generating MCQs: {e}")
+        return None
+
+# New function to save quiz to database
+def save_quiz(course_id, session_id, title, questions):
+    """Save quiz to database"""
+    try:
+        quiz_data = {
+            "course_id": course_id,
+            "session_id": session_id,
+            "title": title,
+            "questions": questions,
+            "created_at": datetime.utcnow(),
+            "status": "active"
+        }
+        result = quizzes_collection.insert_one(quiz_data)
+        return result.inserted_id
+    except Exception as e:
+        print(f"Error saving quiz: {e}")
+        return None
+    
+
+def get_student_quiz_score(quiz_id, student_id):
+    """Get student's score for a specific quiz"""
+    quiz = quizzes_collection.find_one(
+        {
+            "_id": quiz_id,
+            "submissions.student_id": student_id
+        },
+        {"submissions.$": 1}
+    )
+    if quiz and quiz.get('submissions'):
+        return quiz['submissions'][0].get('score')
+    return None
+
+def submit_quiz_answers(quiz_id, student_id, student_answers):
+    """Submit and score student's quiz answers"""
+    quiz = quizzes_collection.find_one({"_id": quiz_id})
+    if not quiz:
+        return None
+    
+    # Calculate score
+    correct_answers = 0
+    total_questions = len(quiz['questions'])
+    
+    for q_idx, question in enumerate(quiz['questions']):
+        if student_answers.get(str(q_idx)) == question['correct_option']:
+            correct_answers += 1
+    
+    score = (correct_answers / total_questions) * 100
+    
+    # Store submission
+    submission_data = {
+        "student_id": student_id,
+        "answers": student_answers,
+        "score": score,
+        "submitted_at": datetime.utcnow()
+    }
+    
+    # Update quiz with submission
+    quizzes_collection.update_one(
+        {"_id": quiz_id},
+        {
+            "$push": {"submissions": submission_data}
+        }
+    )
+    
+    return score

main.py

@@ -10,12 +10,8 @@ from db import (
     research_assistants_collection,
 )
 from werkzeug.security import generate_password_hash, check_password_hash
-import hashlib
 import os
-import openai
 from openai import OpenAI
-from bson import ObjectId
-from pymongo import MongoClient
 from dotenv import load_dotenv
 
 client = OpenAI(api_key=os.getenv("OPENAI_KEY"))
@@ -476,10 +472,9 @@ def main_dashboard():
                 st.session_state.username, st.session_state.user_type
             )
 
-            if st.button(
-                "Create New Course", key="create_course", use_container_width=True
-            ):
-                st.session_state.show_create_course_form = True
+            if st.session_state.user_type == "faculty":
+                if st.button("Create New Course", key="create_course", use_container_width=True):
+                        st.session_state.show_create_course_form = True
 
             if not enrolled_courses:
                 st.warning("No courses found")
@@ -543,255 +538,6 @@ def main_dashboard():
         # if create_session:
         #     create_session_form(selected_course_id)
 
-
-load_dotenv()
-MONGO_URI = os.getenv("MONGO_URI")
-
-
-def modify_courses_collection_schema():
-    """Modify the schema of courses_collection2 to include start_date and end_date"""
-    client = MongoClient(MONGO_URI)
-    db = client["novascholar_db"]
-    courses_collection2 = db["courses_collection2"]
-
-    # Define the updated schema
-    updated_course_schema = {
-        "bsonType": "object",
-        "required": [
-            "course_id",
-            "title",
-            "description",
-            "faculty",
-            "faculty_id",
-            "duration",
-            "created_at",
-            "start_date",
-            "end_date",
-        ],
-        "properties": {
-            "course_id": {
-                "bsonType": "string",
-                "description": "Unique identifier for the course",
-            },
-            "title": {"bsonType": "string", "description": "Title of the course"},
-            "description": {
-                "bsonType": "string",
-                "description": "Description of the course",
-            },
-            "faculty": {"bsonType": "string", "description": "Name of the faculty"},
-            "faculty_id": {
-                "bsonType": "string",
-                "description": "Unique identifier for the faculty",
-            },
-            "duration": {"bsonType": "string", "description": "Duration of the course"},
-            "created_at": {
-                "bsonType": "date",
-                "description": "Date when the course was created",
-            },
-            "start_date": {
-                "bsonType": "date",
-                "description": "Start date of the course",
-            },
-            "end_date": {"bsonType": "date", "description": "End date of the course"},
-            "sessions": {
-                "bsonType": "array",
-                "description": "List of sessions associated with the course",
-                "items": {
-                    "bsonType": "object",
-                    "required": ["session_id", "title", "date", "status", "created_at"],
-                    "properties": {
-                        "session_id": {
-                            "bsonType": "string",
-                            "description": "Unique identifier for the session",
-                        },
-                        "title": {
-                            "bsonType": "string",
-                            "description": "Title of the session",
-                        },
-                        "date": {
-                            "bsonType": "date",
-                            "description": "Date of the session",
-                        },
-                        "status": {
-                            "bsonType": "string",
-                            "description": "Status of the session (e.g., completed, upcoming)",
-                        },
-                        "created_at": {
-                            "bsonType": "date",
-                            "description": "Date when the session was created",
-                        },
-                        "pre_class": {
-                            "bsonType": "object",
-                            "description": "Pre-class segment data",
-                            "properties": {
-                                "resources": {
-                                    "bsonType": "array",
-                                    "description": "List of pre-class resources",
-                                    "items": {
-                                        "bsonType": "object",
-                                        "required": ["type", "title", "url"],
-                                        "properties": {
-                                            "type": {
-                                                "bsonType": "string",
-                                                "description": "Type of resource (e.g., pdf, video)",
-                                            },
-                                            "title": {
-                                                "bsonType": "string",
-                                                "description": "Title of the resource",
-                                            },
-                                            "url": {
-                                                "bsonType": "string",
-                                                "description": "URL of the resource",
-                                            },
-                                            "vector": {
-                                                "bsonType": "array",
-                                                "description": "Vector representation of the resource",
-                                                "items": {"bsonType": "double"},
-                                            },
-                                        },
-                                    },
-                                },
-                                "completion_required": {
-                                    "bsonType": "bool",
-                                    "description": "Indicates if completion of pre-class resources is required",
-                                },
-                            },
-                        },
-                        "in_class": {
-                            "bsonType": "object",
-                            "description": "In-class segment data",
-                            "properties": {
-                                "topics": {
-                                    "bsonType": "array",
-                                    "description": "List of topics covered in the session",
-                                    "items": {"bsonType": "string"},
-                                },
-                                "quiz": {
-                                    "bsonType": "object",
-                                    "description": "Quiz data",
-                                    "properties": {
-                                        "title": {
-                                            "bsonType": "string",
-                                            "description": "Title of the quiz",
-                                        },
-                                        "questions": {
-                                            "bsonType": "int",
-                                            "description": "Number of questions in the quiz",
-                                        },
-                                        "duration": {
-                                            "bsonType": "int",
-                                            "description": "Duration of the quiz in minutes",
-                                        },
-                                    },
-                                },
-                                "polls": {
-                                    "bsonType": "array",
-                                    "description": "List of polls conducted during the session",
-                                    "items": {
-                                        "bsonType": "object",
-                                        "required": ["question", "options"],
-                                        "properties": {
-                                            "question": {
-                                                "bsonType": "string",
-                                                "description": "Poll question",
-                                            },
-                                            "options": {
-                                                "bsonType": "array",
-                                                "description": "List of poll options",
-                                                "items": {"bsonType": "string"},
-                                            },
-                                            "responses": {
-                                                "bsonType": "object",
-                                                "description": "Responses to the poll",
-                                                "additionalProperties": {
-                                                    "bsonType": "int"
-                                                },
-                                            },
-                                        },
-                                    },
-                                },
-                            },
-                        },
-                        "post_class": {
-                            "bsonType": "object",
-                            "description": "Post-class segment data",
-                            "properties": {
-                                "assignments": {
-                                    "bsonType": "array",
-                                    "description": "List of assignments",
-                                    "items": {
-                                        "bsonType": "object",
-                                        "required": [
-                                            "id",
-                                            "title",
-                                            "due_date",
-                                            "status",
-                                        ],
-                                        "properties": {
-                                            "id": {
-                                                "bsonType": "int",
-                                                "description": "Assignment ID",
-                                            },
-                                            "title": {
-                                                "bsonType": "string",
-                                                "description": "Title of the assignment",
-                                            },
-                                            "due_date": {
-                                                "bsonType": "date",
-                                                "description": "Due date of the assignment",
-                                            },
-                                            "status": {
-                                                "bsonType": "string",
-                                                "description": "Status of the assignment (e.g., pending, completed)",
-                                            },
-                                            "submissions": {
-                                                "bsonType": "array",
-                                                "description": "List of submissions",
-                                                "items": {
-                                                    "bsonType": "object",
-                                                    "required": [
-                                                        "student_id",
-                                                        "file_url",
-                                                        "submitted_at",
-                                                    ],
-                                                    "properties": {
-                                                        "student_id": {
-                                                            "bsonType": "string",
-                                                            "description": "ID of the student who submitted the assignment",
-                                                        },
-                                                        "file_url": {
-                                                            "bsonType": "string",
-                                                            "description": "URL of the submitted file",
-                                                        },
-                                                        "submitted_at": {
-                                                            "bsonType": "date",
-                                                            "description": "Date when the assignment was submitted",
-                                                        },
-                                                    },
-                                                },
-                                            },
-                                        },
-                                    },
-                                }
-                            },
-                        },
-                    },
-                },
-            },
-        },
-    }
-
-    # Update the schema using the collMod command
-    db.command(
-        {
-            "collMod": "courses_collection2",
-            "validator": {"$jsonSchema": updated_course_schema},
-        }
-    )
-
-    print("Schema updated successfully!")
-
-
 def main():
     st.set_page_config(page_title="NOVAScholar", page_icon="📚", layout="wide")
     init_session_state()

research_assistant_dashboard.py

@@ -2,52 +2,244 @@ import streamlit as st
 from openai import OpenAI
 import os
 from dotenv import load_dotenv
+from llama_index.core import (
+    VectorStoreIndex,
+    SimpleDirectoryReader,
+    Document,
+    GPTVectorStoreIndex,
+)
+from bson import ObjectId
+import requests
+import openai
+import numpy as np
+from pymongo import MongoClient
+from bson import ObjectId
+from datetime import datetime
+from llama_index.embeddings.openai import OpenAIEmbedding
+from typing import List, Dict
 
-# Initialize OpenAI client
+# Initialize Perplexity API and OpenAI API
 load_dotenv()
-client = OpenAI(api_key=os.getenv("OPENAI_KEY"))
+perplexity_api_key = os.getenv("PERPLEXITY_KEY")
+openai.api_key = os.getenv("OPENAI_KEY")
+
+# MongoDB setup
+MONGO_URI = os.getenv("MONGO_URI")
+client = MongoClient(MONGO_URI)
+db = client["novascholar_db"]
+research_papers_collection = db["research_papers"]
+
+
+def fetch_perplexity_data(api_key, topic):
+    """
+    Fetch research papers data from Perplexity API with proper formatting
+    """
+    headers = {
+        "accept": "application/json",
+        "content-type": "application/json",
+        "authorization": f"Bearer {api_key}",
+    }
+
+    # Structured prompt to get properly formatted response
+    messages = [
+        {
+            "role": "system",
+            "content": """You are a research paper retrieval expert. For the given topic, return exactly 10 research papers in the following format:
+            Title: Paper Title
+            Authors: Author 1, Author 2
+            Year: YYYY
+            Content: Detailed paper content with abstract and key findings
+            URL: DOI or paper URL
+            """,
+        },
+        {"role": "user", "content": f"Find 10 research papers about: {topic}"},
+    ]
+
+    try:
+        client = OpenAI(api_key=api_key, base_url="https://api.perplexity.ai")
+        response = client.chat.completions.create(
+            model="llama-3.1-sonar-small-128k-chat",  # Use the best Perplexity model
+            messages=messages,
+        )
+
+        # Extract and validate response
+        content = response.choices[0].message.content
+        st.write("Fetched Data:", content)  # Debugging line to check the fetched data
+
+        return content
+
+    except Exception as e:
+        st.error(f"Failed to fetch data from Perplexity API: {str(e)}")
+        return ""
+
+
+def split_and_vectorize_papers(content: str) -> List[Dict]:
+    """Split and vectorize papers using OpenAI embeddings"""
+    papers = content.split("\n\n")
+
+    # Initialize OpenAI client
+    # client = OpenAI()  # Uses api_key from environment variable
+    vectors = []
+
+    for paper in papers:
+        try:
+            # Get embedding using OpenAI's API directly
+            response = openai.embeddings.create(
+                model="text-embedding-ada-002", input=paper, encoding_format="float"
+            )
+
+            # Extract embedding from response
+            embedding = response.data[0].embedding
+
+            vectors.append(
+                {"content": paper, "vector": embedding, "timestamp": datetime.utcnow()}
+            )
+
+        except Exception as e:
+            st.error(f"Error vectorizing paper: {str(e)}")
+            continue
+
+    return vectors
+
+
+def store_papers_in_mongodb(papers):
+    """Store papers with vectors in MongoDB"""
+    try:
+        for paper in papers:
+            # Prepare MongoDB document
+            mongo_doc = {
+                "content": paper["content"],
+                "vector": paper["vector"],
+                "created_at": datetime.utcnow(),
+            }
+
+            # Insert into MongoDB
+            db.papers.update_one(
+                {"content": paper["content"]}, {"$set": mongo_doc}, upsert=True
+            )
+
+        st.success(f"Stored {len(papers)} papers in database")
+        return True
+    except Exception as e:
+        st.error(f"Error storing papers: {str(e)}")
 
 
 def get_research_papers(query):
-    """Get research paper recommendations based on query"""
+    """
+    Get and store research papers with improved error handling
+    """
+    # Fetch papers from Perplexity
+    content = fetch_perplexity_data(perplexity_api_key, query)
+
+    if not content:
+        return []
+
+    # Split and vectorize papers
+    papers = split_and_vectorize_papers(content)
+
+    # Store papers in MongoDB
+    if store_papers_in_mongodb(papers):
+        return papers
+    else:
+        st.warning("Failed to store papers in database, but returning fetched results")
+        return papers
+
+
+def analyze_research_gaps(papers):
+    """
+    Analyze research gaps with improved prompt and error handling
+    """
+    if not papers:
+        return "No papers provided for analysis"
+
+    # Prepare paper summaries for analysis
+    paper_summaries = "\n\n".join(
+        [
+            f"Key Findings: {paper['content'][:500]}..."
+            # f"Title: {paper['title']}\nYear: {paper['year']}\nKey Findings: {paper['content'][:500]}..."
+            for paper in papers
+        ]
+    )
+
+    headers = {
+        "Authorization": f"Bearer {perplexity_api_key}",
+        "Content-Type": "application/json",
+    }
+
+    data = {
+        "messages": [
+            {
+                "role": "system",
+                "content": "You are a research analysis expert. Identify specific research gaps and future research directions based on the provided papers. Format your response with clear sections: Current State, Identified Gaps, and Future Directions.",
+            },
+            {
+                "role": "user",
+                "content": f"Analyze these papers and identify research gaps:\n\n{paper_summaries}",
+            },
+        ]
+    }
+
     try:
+        client = OpenAI(
+            api_key=perplexity_api_key, base_url="https://api.perplexity.ai"
+        )
         response = client.chat.completions.create(
-            model="gpt-3.5-turbo",
-            messages=[
-                {
-                    "role": "system",
-                    "content": "You are a helpful research assistant. Provide 10 relevant research papers with titles, authors, brief descriptions, and DOI/URL links. Format each paper as: \n\n1. **Title**\nAuthors: [names]\nLink: [DOI/URL]\nDescription: [brief summary]",
-                },
-                {
-                    "role": "user",
-                    "content": f"Give me 10 research papers about: {query}. Include valid DOI links or URLs to the papers where available.",
-                },
-            ],
+            model="llama-3.1-sonar-small-128k-chat",  # Use the best Perplexity model
+            messages=data["messages"],
         )
         return response.choices[0].message.content
+
     except Exception as e:
-        return f"Error getting recommendations: {str(e)}"
+        st.error(f"Failed to analyze research gaps: {str(e)}")
+        return "Error analyzing research gaps"
 
 
-def analyze_research_gaps(papers):
-    """Analyze gaps in research based on recommended papers"""
+def create_research_paper(gaps, topic, papers):
+    """
+    Create a research paper that addresses the identified gaps using Perplexity API
+    """
+    full_texts = "\n\n".join([paper["content"] for paper in papers])
+    headers = {
+        "Authorization": f"Bearer {perplexity_api_key}",
+        "Content-Type": "application/json",
+    }
+    data = {
+        "messages": [
+            {
+                "role": "system",
+                "content": "You are a research paper generation expert. Create a comprehensive research paper that addresses the identified gaps based on the provided papers. Format your response with clear sections: Introduction, Literature Review, Methodology, Results, Discussion, Conclusion, and References.",
+            },
+            {
+                "role": "user",
+                "content": f"Create a research paper on the topic '{topic}' that addresses the following research gaps:\n\n{gaps}\n\nBased on the following papers:\n\n{full_texts}",
+            },
+        ]
+    }
     try:
+        client = OpenAI(
+            api_key=perplexity_api_key, base_url="https://api.perplexity.ai"
+        )
         response = client.chat.completions.create(
-            model="gpt-3.5-turbo",
-            messages=[
-                {
-                    "role": "system",
-                    "content": "You are a research analysis expert. Based on the provided papers, identify potential research gaps and future research directions.",
-                },
-                {
-                    "role": "user",
-                    "content": f"Based on these papers, what are the key areas that need more research?\n\nPapers:\n{papers}",
-                },
-            ],
+            model="llama-3.1-sonar-small-128k-chat",  # Use the best Perplexity model
+            messages=data["messages"],
         )
         return response.choices[0].message.content
+
     except Exception as e:
-        return f"Error analyzing research gaps: {str(e)}"
+        st.error(f"Failed to create research paper: {str(e)}")
+        return "Error creating research paper"
+
+
+def cosine_similarity(vec1, vec2):
+    """Calculate the cosine similarity between two vectors"""
+    vec1 = np.array(vec1)
+    vec2 = np.array(vec2)
+    return np.dot(vec1, vec2) / (np.linalg.norm(vec1) * np.linalg.norm(vec2))
+
+
+def calculate_cosine_similarity(vec1: List[float], vec2: List[float]) -> float:
+    """Calculate cosine similarity between two vectors"""
+    return np.dot(vec1, vec2) / (np.linalg.norm(vec1) * np.linalg.norm(vec2))
 
 
 def display_research_assistant_dashboard():
@@ -55,6 +247,10 @@ def display_research_assistant_dashboard():
     # Initialize session state for recommendations
     if "recommendations" not in st.session_state:
         st.session_state.recommendations = None
+    if "vectors" not in st.session_state:
+        st.session_state.vectors = None
+    if "generated_paper" not in st.session_state:
+        st.session_state.generated_paper = None
 
     # Sidebar
     with st.sidebar:
@@ -67,28 +263,80 @@ def display_research_assistant_dashboard():
     # Main content
     st.title("Research Paper Recommendations")
     search_query = st.text_input("Enter research topic:")
-
     col1, col2 = st.columns(2)
     with col1:
         if st.button("Get Research Papers"):
             if search_query:
                 with st.spinner("Fetching recommendations..."):
                     st.session_state.recommendations = get_research_papers(search_query)
-                    st.markdown(st.session_state.recommendations)
+                    st.session_state.vectors = [
+                        paper["vector"] for paper in st.session_state.recommendations
+                    ]
+                    st.markdown(
+                        "\n\n".join(
+                            [
+                                f"**{i+1}.**\n{paper['content']}"
+                                # f"**{i+1}. {paper['title']}**\n{paper['content']}"
+                                for i, paper in enumerate(
+                                    st.session_state.recommendations
+                                )
+                            ]
+                        )
+                    )
             else:
                 st.warning("Please enter a search query")
-
     with col2:
         if st.button("Analyze Research Gaps"):
             if st.session_state.recommendations:
                 with st.spinner("Analyzing research gaps..."):
                     gaps = analyze_research_gaps(st.session_state.recommendations)
+                    st.session_state.generated_paper = create_research_paper(
+                        gaps, search_query, st.session_state.recommendations
+                    )
                     st.markdown("### Potential Research Gaps")
                     st.markdown(gaps)
             else:
                 st.warning("Please get research papers first")
 
-    # Display recommendations if they exist
-    if st.session_state.recommendations:
-        st.markdown("### Research Papers")
-        st.markdown(st.session_state.recommendations)
+    if st.button("Save and Vectorize"):
+        if st.session_state.generated_paper:
+            try:
+                # Initialize OpenAI client
+
+                # Get embedding for generated paper
+                response = openai.embeddings.create(
+                    model="text-embedding-ada-002",
+                    input=st.session_state.generated_paper,
+                    encoding_format="float",
+                )
+                generated_vector = response.data[0].embedding
+
+                # Calculate similarities with stored vectors
+                similarities = [
+                    calculate_cosine_similarity(generated_vector, paper_vector)
+                    for paper_vector in st.session_state.vectors
+                ]
+
+                # Display results
+                st.markdown("### Generated Research Paper")
+                st.markdown(st.session_state.generated_paper)
+
+                st.markdown("### Cosine Similarities with Original Papers")
+                for i, similarity in enumerate(similarities):
+                    st.metric(
+                        f"Paper {i+1}",
+                        value=f"{similarity:.3f}",
+                        help="Cosine similarity (1.0 = identical, 0.0 = completely different)",
+                    )
+
+            except Exception as e:
+                st.error(f"Error during vectorization: {str(e)}")
+        else:
+            st.warning("Please analyze research gaps first")
+
+
+# Run the dashboard
+if __name__ == "__main__":
+    display_research_assistant_dashboard()
+
+

session_page.py

@@ -1,11 +1,9 @@
 import streamlit as st
 from datetime import datetime
-from utils.sample_data import SAMPLE_CHAT_HISTORY, SAMPLE_STUDENT_PROGRESS
 from utils.helpers import display_progress_bar, create_notification, format_datetime
-from utils.sample_data import SAMPLE_SESSIONS, SAMPLE_COURSES
 from file_upload_vectorize import upload_resource, extract_text_from_file, create_vector_store, resources_collection, model, assignment_submit
 from db import courses_collection2, chat_history_collection, students_collection, faculty_collection, vectors_collection
-from chatbot import insert_chat_message
+from chatbot import give_chat_response
 from bson import ObjectId
 from live_polls import LivePollFeature
 import pandas as pd
@@ -13,6 +11,7 @@ import plotly.express as px
 from dotenv import load_dotenv
 import os
 from pymongo import MongoClient
+from gen_mcqs import generate_mcqs, save_quiz, quizzes_collection, get_student_quiz_score, submit_quiz_answers
 
 load_dotenv()
 MONGO_URI = os.getenv('MONGO_URI')
@@ -25,146 +24,90 @@ def get_current_user():
         return None
     return students_collection.find_one({"_id": st.session_state.user_id})
 
-def display_preclass_content(session, student_id):
+def display_preclass_content(session, student_id, course_id):
     """Display pre-class materials for a session"""
-    st.subheader("Pre-class Materials")
-
+    
+    # Initialize 'messages' in session_state if it doesn't exist
+    if 'messages' not in st.session_state:
+        st.session_state.messages = []
+        
     # Display pre-class materials
-    print(f"student_id: {type(student_id)}")
-
-    materials = resources_collection.find({"session_id": session['session_id']})
-    print(f"materials: {type(materials)}")
-    for material in materials:
-        print(f"material: {type(material)}")
-        with st.expander(f"{material['file_name']} ({material['material_type'].upper()})"):
-            file_type = material.get('file_type', 'unknown')
-            if file_type == 'application/pdf':
-                st.markdown(f"📑 [Open PDF Document]({material['file_name']})")
-                if st.button("View PDF", key=f"view_pdf_{material['file_name']}"):
-                    st.text_area("PDF Content", material['text_content'], height=300)
-                if st.button("Download PDF", key=f"download_pdf_{material['file_name']}"):
-                    st.download_button(
-                        label="Download PDF",
-                        data=material['file_content'],
-                        file_name=material['file_name'],
-                        mime='application/pdf'
-                    )
-                if st.button("Mark PDF as Read", key=f"pdf_{material['file_name']}"):
-                    create_notification("PDF marked as read!", "success")
-
-    user = get_current_user()
-    print(f"user: {type(user)}")
-
-    user = get_current_user()
+    materials = list(resources_collection.find({"course_id": course_id, "session_id": session['session_id']}))
+    st.subheader("Pre-class Materials")
     
-    # Chat input
-    # Add a check, if materials are available, only then show the chat input
-    if(st.session_state.user_type == "student"):
-        if materials:
-            if prompt := st.chat_input("Ask a question about Pre-class Materials"):
-                if len(st.session_state.messages) >= 20:
-                    st.warning("Message limit (20) reached for this session.")
-                    return
-
-                st.session_state.messages.append({"role": "user", "content": prompt})
-                
-                # Display User Message
-                with st.chat_message("user"):
-                    st.markdown(prompt)
-
-                # Get document context
-                context = ""
-                materials = resources_collection.find({"session_id": session['session_id']})
-                context = ""
-                vector_data = None
-
-                context = ""
-                for material in materials:
-                    resource_id = material['_id']
-                    vector_data = vectors_collection.find_one({"resource_id": resource_id})
-                    if vector_data and 'text' in vector_data:
-                        context += vector_data['text'] + "\n"
-
-                if not vector_data:
-                    st.error("No Pre-class materials found for this session.")
-                    return
-                
-                try:
-                    # Generate response using Gemini
-                    context_prompt = f"""
-                    Based on the following context, answer the user's question:
-                    
-                    Context:
-                    {context}
-                    
-                    Question: {prompt}
-                    
-                    Please provide a clear and concise answer based only on the information provided in the context.
-                    """
-
-                    response = model.generate_content(context_prompt)
-                    if not response or not response.text:
-                        st.error("No response received from the model")
-                        return
-                    
-                    assistant_response = response.text
-                    # Display Assistant Response
-                    with st.chat_message("assistant"):
-                        st.markdown(assistant_response)
-                    
-                    # Build the message
-                    new_message = {
-                        "prompt": prompt,
-                        "response": assistant_response,
-                        "timestamp": datetime.utcnow()
-                    }
-                    st.session_state.messages.append(new_message)
-
-                    # Update database
-                    try:
-                        chat_history_collection.update_one(
-                            {
-                                "user_id": student_id,
-                                "session_id": session['session_id']
-                            },
-                            {
-                                "$push": {"messages": new_message},
-                                "$setOnInsert": {
-                                    "user_id": student_id,
-                                    "session_id": session['session_id'],
-                                    "timestamp": datetime.utcnow()
-                                }
-                            },
-                            upsert=True
+    if materials:
+        for material in materials:
+            with st.expander(f"{material['file_name']} ({material['material_type'].upper()})"):
+                file_type = material.get('file_type', 'unknown')
+                if file_type == 'application/pdf':
+                    st.markdown(f"📑 [Open PDF Document]({material['file_name']})")
+                    if st.button("View PDF", key=f"view_pdf_{material['file_name']}"):
+                        st.text_area("PDF Content", material['text_content'], height=300)
+                    if st.button("Download PDF", key=f"download_pdf_{material['file_name']}"):
+                        st.download_button(
+                            label="Download PDF",
+                            data=material['file_content'],
+                            file_name=material['file_name'],
+                            mime='application/pdf'
                         )
-                    except Exception as db_error:
-                        st.error(f"Error saving chat history: {str(db_error)}")
-                except Exception as e:
-                    st.error(f"Error generating response: {str(e)}")
+                    if st.button("Mark PDF as Read", key=f"pdf_{material['file_name']}"):
+                        create_notification("PDF marked as read!", "success")
+    else:
+        st.info("No pre-class materials uploaded by the faculty.")
+        st.subheader("Upload Pre-class Material")
+        
+        # File upload section for students
+        uploaded_file = st.file_uploader("Upload Material", type=['txt', 'pdf', 'docx'])
+        if uploaded_file is not None:
+            with st.spinner("Processing document..."):
+                file_name = uploaded_file.name
+                file_content = extract_text_from_file(uploaded_file)
+                if file_content:
+                    material_type = st.selectbox("Select Material Type", ["pdf", "docx", "txt"])
+                    if st.button("Upload Material"):
+                        upload_resource(course_id, session['session_id'], file_name, uploaded_file, material_type)
+
+                        # Search for the newly uploaded resource's _id in resources_collection
+                        resource_id = resources_collection.find_one({"file_name": file_name})["_id"]
+                        create_vector_store(file_content, resource_id)
+                        st.success("Material uploaded successfully!")
+        
+    st.subheader("Learn the Topic Using Chatbot")
+    st.write(f"**Session Title:** {session['title']}")
+    st.write(f"**Description:** {session.get('description', 'No description available.')}")
     
-    st.subheader("Your Chat History")
-    # Initialize chat messages from database
-    if 'messages' not in st.session_state:
-        existing_chat = chat_history_collection.find_one({
-            "user_id": student_id,
-            "session_id": session['session_id']
-        })
-        if existing_chat and 'messages' in existing_chat:
-            st.session_state.messages = existing_chat['messages']
-        else:
-            st.session_state.messages = []
+    # Chatbot interface
+    if prompt := st.chat_input("Ask a question about the session topic"):
+        if len(st.session_state.messages) >= 20:
+            st.warning("Message limit (20) reached for this session.")
+            return
 
-    # Display existing chat history
-    try:
-        for message in st.session_state.messages:
-            if 'prompt' in message and 'response' in message:
-                with st.chat_message("user"):
-                    st.markdown(message["prompt"])
-                with st.chat_message("assistant"):
-                    st.markdown(message["response"])
-    except Exception as e:
-        st.error(f"Error displaying chat history: {str(e)}")
-        st.session_state.messages = []
+        st.session_state.messages.append({"role": "user", "content": prompt})
+        
+        # Display User Message
+        with st.chat_message("user"):
+            st.markdown(prompt)
+        
+        # Get response from chatbot
+        context = ""
+        for material in materials:
+            if 'text_content' in material:
+                context += material['text_content'] + "\n"
+        
+        response = give_chat_response(student_id, session['session_id'], prompt, session['title'], session.get('description', ''), context)
+        st.session_state.messages.append({"role": "assistant", "content": response})
+        
+        # Display Assistant Response
+        with st.chat_message("assistant"):
+            st.markdown(response)
+    
+    st.subheader("Your Chat History")
+    for message in st.session_state.messages:
+        content = message.get("content", "")  # Default to an empty string if "content" is not present
+        role = message.get("role", "user")  # Default to "user" if "role" is not present
+        with st.chat_message(role):
+            st.markdown(content)
+    user = get_current_user()
 
 def display_in_class_content(session, user_type):
     # """Display in-class activities and interactions"""
@@ -185,6 +128,57 @@ def display_post_class_content(session, student_id, course_id):
     st.header("Post-class Work")
     
     if st.session_state.user_type == 'faculty':
+        """Create quiz section UI for faculty"""
+        st.subheader("Create Quiz")
+        
+        questions = []
+        with st.form("create_quiz_form"):
+            quiz_title = st.text_input("Quiz Title")
+            num_questions = st.number_input("Number of Questions", min_value=1, max_value=20, value=5)
+            
+            # Option to choose quiz generation method
+            generation_method = st.radio(
+                "Question Generation Method",
+                ["Generate from Pre-class Materials", "Generate Random Questions"]
+            )
+            
+            submit_quiz = st.form_submit_button("Generate Quiz")
+            if submit_quiz:
+                if generation_method == "Generate from Pre-class Materials":
+                    # Get pre-class materials from resources_collection
+                    materials = resources_collection.find({"session_id": session['session_id']})
+                    context = ""
+                    for material in materials:
+                        if 'text_content' in material:
+                            context += material['text_content'] + "\n"
+                    
+                    if not context:
+                        st.error("No pre-class materials found for this session.")
+                        return
+                    
+                    # Generate MCQs from context
+                    questions = generate_mcqs(context, num_questions, session['title'], session.get('description', ''))
+                else:
+                    # Generate random MCQs based on session title and description
+                    questions = generate_mcqs(None, num_questions, session['title'], session.get('description', ''))
+                    print(questions)
+                
+                if questions:
+                    # Preview generated questions
+                    st.subheader("Preview Generated Questions")
+                    for i, q in enumerate(questions, 1):
+                        st.markdown(f"**Question {i}:** {q['question']}")
+                        for opt in q['options']:
+                            st.markdown(f"- {opt}")
+                        st.markdown(f"*Correct Answer: {q['correct_option']}*")
+                    
+                    # Save quiz 
+                    quiz_id = save_quiz(course_id, session['session_id'], quiz_title, questions)
+                    if quiz_id:
+                        st.success("Quiz saved successfully!")
+                    else:
+                        st.error("Error saving quiz.")
+
         st.subheader("Add Assignments")
         # Add assignment form
         with st.form("add_assignment_form"):
@@ -310,6 +304,26 @@ def display_preclass_analytics(session, course_id):
         student_chat = next((chat for chat in chat_data if chat['user_id'] == student_id), None)
         
         if student_chat:
+            messages = student_chat.get('messages', [])
+            message_count = len(messages)
+            status = "Completed" if message_count >= 20 else "Incomplete"
+
+            # Format chat history for display
+            chat_history = []
+            for msg in messages:
+                timestamp_str = msg.get('timestamp', '')
+                if isinstance(timestamp_str, str):
+                    timestamp = datetime.fromisoformat(timestamp_str)
+                else:
+                    timestamp = timestamp_str
+                # timestamp = msg.get('timestamp', '').strftime("%Y-%m-%d %H:%M:%S")
+                chat_history.append({
+                    # 'timestamp': timestamp,
+                    'timestamp': timestamp.strftime("%Y-%m-%d %H:%M:%S"),
+                    'prompt': msg.get('prompt'),
+                    'response': msg.get('response')
+                })
+            
             message_count = len(student_chat.get('messages', []))
             status = "Completed" if message_count >= 20 else "Incomplete"
             if status == "Incomplete":
@@ -321,6 +335,7 @@ def display_preclass_analytics(session, course_id):
         else:
             message_count = 0
             status = "Not Started"
+            chat_history = []
             incomplete_students.append({
                 'name': student_name,
                 'sid': student_sid,
@@ -331,7 +346,8 @@ def display_preclass_analytics(session, course_id):
             'Student Name': student_name,
             'SID': student_sid,
             'Messages': message_count,
-            'Status': status
+            'Status': status,
+            'Chat History': chat_history
         })
     
     # Create DataFrame
@@ -356,16 +372,58 @@ def display_preclass_analytics(session, course_id):
     st.markdown("### Overall Completion Rate")
     st.progress(completion_rate / 100)
     st.markdown(f"**{completion_rate:.1f}%** of students have completed pre-class materials")
-    
-    # Display full student completion table
-    st.markdown("### Student Completion Details")
-    st.dataframe(
-        df.style.apply(lambda x: ['background-color: #90EE90' if v == 'Completed' 
-                                 else 'background-color: #FFB6C1' if v == 'Incomplete'
-                                 else 'background-color: #FFE4B5' 
-                                 for v in x],
-                      subset=['Status'])
-    )
+
+    # Create tabs for different views
+    tab1, tab2 = st.tabs(["Student Overview", "Detailed Chat History"])
+    
+    with tab1:
+        # Display completion summary table
+        st.markdown("### Student Completion Details")
+        summary_df = df[['Student Name', 'SID', 'Messages', 'Status']].copy()
+        st.dataframe(
+            summary_df.style.apply(lambda x: ['background-color: #90EE90' if v == 'Completed' 
+                                            else 'background-color: #FFB6C1' if v == 'Incomplete'
+                                            else 'background-color: #FFE4B5' 
+                                            for v in x],
+                                 subset=['Status'])
+        )
+        
+    with tab2:
+        # Display detailed chat history
+        st.markdown("### Student Chat Histories")
+        
+        # Add student selector
+        selected_student = st.selectbox(
+            "Select a student to view chat history:",
+            options=df['Student Name'].tolist()
+        )
+        
+        # Get selected student's data
+        student_data = df[df['Student Name'] == selected_student].iloc[0]
+        print(student_data)
+        chat_history = student_data['Chat History']
+        # Refresh chat history when a new student is selected
+        if 'selected_student' not in st.session_state or st.session_state.selected_student != selected_student:
+            st.session_state.selected_student = selected_student
+            st.session_state.selected_student_chat_history = chat_history
+        else:
+            chat_history = st.session_state.selected_student_chat_history
+        # Display student info and chat statistics
+        st.markdown(f"**Student ID:** {student_data['SID']}")
+        st.markdown(f"**Status:** {student_data['Status']}")
+        st.markdown(f"**Total Messages:** {student_data['Messages']}")
+        
+        
+
+
+        # Display chat history in a table
+        if chat_history:
+            chat_df = pd.DataFrame(chat_history)
+            st.dataframe(
+                chat_df.style.apply(lambda x: ['background-color: #E8F0FE' if v == 'response' else 'background-color: #FFFFFF' for v in x], subset=['prompt']), use_container_width=True
+            )
+        else:
+            st.info("No chat history available for this student.")
     
     # Display students who haven't completed
     if incomplete_students:
@@ -644,16 +702,69 @@ def upload_preclass_materials(session_id, course_id):
             Uploaded on: {material['uploaded_at'].strftime('%Y-%m-%d %H:%M')}
         """)
 
-
-
+def display_quiz_tab(student_id, course_id, session_id):
+    """Display quizzes for students"""
+    st.header("Course Quizzes")
+    
+    # Get available quizzes for this session
+    quizzes = quizzes_collection.find({
+        "course_id": course_id,
+        "session_id": session_id,
+        "status": "active"
+    })
+    
+    quizzes = list(quizzes)
+    if not quizzes:
+        st.info("No quizzes available for this session.")
+        return
+    
+    for quiz in quizzes:
+        with st.expander(f"📝 {quiz['title']}", expanded=True):
+            # Check if student has already taken this quiz
+            existing_score = get_student_quiz_score(quiz['_id'], student_id)
+            
+            if existing_score is not None:
+                st.success(f"Quiz completed! Your score: {existing_score:.1f}%")
+                
+                # Display correct answers after submission
+                st.subheader("Quiz Review")
+                for i, question in enumerate(quiz['questions']):
+                    st.markdown(f"**Question {i+1}:** {question['question']}")
+                    for opt in question['options']:
+                        if opt.startswith(question['correct_option']):
+                            st.markdown(f"✅ {opt}")
+                        else:
+                            st.markdown(f"- {opt}")
+                
+            else:
+                # Display quiz questions
+                st.write("Please select your answers:")
+                
+                # Create a form for quiz submission
+                with st.form(f"quiz_form_{quiz['_id']}"):
+                    student_answers = {}
+                    
+                    for i, question in enumerate(quiz['questions']):
+                        st.markdown(f"**Question {i+1}:** {question['question']}")
+                        options = [opt for opt in question['options']]
+                        student_answers[str(i)] = st.radio(
+                            f"Select answer for question {i+1}:",
+                            options=options,
+                            key=f"q_{quiz['_id']}_{i}"
+                        )
+                    
+                    # Submit button
+                    if st.form_submit_button("Submit Quiz"):
+                        print(student_answers)
+                        score = submit_quiz_answers(quiz['_id'], student_id, student_answers)
+                        if score is not None:
+                            st.success(f"Quiz submitted successfully! Your score: {score:.1f}%")
+                            st.rerun()  # Refresh to show results
+                        else:
+                            st.error("Error submitting quiz. Please try again.")
 
 def display_session_content(student_id, course_id, session, username, user_type):
     st.title(f"Session {session['session_id']}: {session['title']}")
-    # st.markdown(f"**Date:** {format_datetime(session['date'])}")
-
-    # Convert date string to datetime object
-    # session_date = datetime.fromisoformat(session['date'])
-    # st.markdown(f"**Date:** {format_datetime(session_date)}")
 
     # Check if the date is a string or a datetime object
     if isinstance(session['date'], str):
@@ -672,30 +783,23 @@ def display_session_content(student_id, course_id, session, username, user_type)
     else:
         tabs = (["Pre-class Analytics", "In-class Analytics", "Post-class Analytics"])
 
-    # Create tabs for different sections
-    # pre_class_tab, in_class_tab, post_class_tab, faculty_tab = st.tabs([
-    #     "Pre-class Work",
-    #     "In-class Work",
-    #     "Post-class Work",
-    #     "Faculty Analytics"
-    # ])
-
     if st.session_state.user_type == 'student':
-        pre_class_tab, in_class_tab, post_class_tab = st.tabs(["Pre-class Work", "In-class Work", "Post-class Work"])
+        pre_class_tab, in_class_tab, post_class_tab, quiz_tab = st.tabs(["Pre-class Work", "In-class Work", "Post-class Work", "Quizzes"])
     else:
         pre_class_work, in_class_work, post_class_work, preclass_analytics, inclass_analytics, postclass_analytics = st.tabs(["Pre-class Work", "In-class Work", "Post-class Work", "Pre-class Analytics", "In-class Analytics", "Post-class Analytics"])
 
     # Display pre-class materials
     if st.session_state.user_type == 'student':
         with pre_class_tab:
-            display_preclass_content(session, student_id)
-        
+            display_preclass_content(session, student_id, course_id)
         with in_class_tab:
             display_in_class_content(session, st.session_state.user_type)
         
         # Post-class Content
         with post_class_tab:
             display_post_class_content(session, student_id, course_id)
+        with quiz_tab:
+            display_quiz_tab(student_id, course_id, session['session_id'])
 
     if st.session_state.user_type == 'faculty':
         with pre_class_work:
@@ -709,4 +813,4 @@ def display_session_content(student_id, course_id, session, username, user_type)
         with inclass_analytics:
             display_inclass_analytics(session, course_id)
         with postclass_analytics:
-            display_postclass_analytics(session, course_id)
+            display_postclass_analytics(session, course_id)