Upload 10 files

.env

@@ -0,0 +1,4 @@
+GOOGLE_CLIENT_ID=862058885628-e6mjev28p8e112qrp9gnn4q8mlif3bbf.apps.googleusercontent.com
+GOOGLE_CLIENT_SECRET=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
+GOOGLE_REDIRECT_URI=http://localhost:5173/callback
+GEMINI_API_KEYS=AIzaSyAbYBc-lMZhgKujtDogbVmyoP0GtwzMmIQ,AIzaSyAwi5BZeHJZw8hU6xdlO3sY3VN_IaVnjuU,AIzaSyBV7muBFoEWL6GkSrf31KH_zgea-Vj25RY,AIzaSyB8BwqbD2wv2rnqaDtUfp5BVO2Afu3UZb0,AIzaSyD8QQjWPxyW1C8W2cDNFGlKpNiSvRz6Jpw,AIzaSyArv7uT7PeGRs17czv02PV7SENWfmEbXcE

.gitignore

@@ -0,0 +1,4 @@
+.env
+venv/
+
+__pycache__/

Dockerfile

@@ -0,0 +1,28 @@
+# Use Python as base image
+FROM python:3.10-slim
+
+# Set environment variables
+ENV PYTHONUNBUFFERED=1 \
+    PYTHONDONTWRITEBYTECODE=1 \
+    CELERY_BROKER_URL=redis://redis:6379/0
+
+# Set the working directory inside the container
+WORKDIR /app
+
+# Copy the project files into the container
+COPY . /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    gcc \
+    libpq-dev \
+    && rm -rf /var/lib/apt/lists/*
+
+# Install Python dependencies
+RUN pip install --upgrade pip && pip install -r requirements.txt
+
+# Expose the application's port
+EXPOSE 8000
+
+# Start the FastAPI application
+CMD ["gunicorn", "-k", "uvicorn.workers.UvicornWorker", "main:app", "--bind", "0.0.0.0:8000", "--workers", "4"]

README.md

@@ -1,10 +1,8 @@
----
-title: Eduscope
-emoji: 🐢
-colorFrom: green
-colorTo: gray
-sdk: docker
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---
+title: EDUCSCOPEAI
+emoji: 🐳
+colorFrom: purple
+colorTo: gray
+sdk: docker
+app_port: 8000
+---

db.py

@@ -0,0 +1,54 @@
+from sqlalchemy import create_engine, Column, String, Text, ForeignKey, DateTime
+from sqlalchemy.orm import sessionmaker, declarative_base, relationship
+from datetime import datetime
+
+# Database Configuration
+DATABASE_URL = "sqlite:///./chats.db"
+engine = create_engine(DATABASE_URL, connect_args={"check_same_thread": False})
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+Base = declarative_base()
+
+class User(Base):
+    __tablename__ = "users"
+    id = Column(String, primary_key=True, unique=True, nullable=False)
+    email = Column(String, unique=True, nullable=False)
+    name = Column(String, nullable=False)
+    chats = relationship("Chat", back_populates="user", cascade="all, delete-orphan")
+
+class Chat(Base):
+    __tablename__ = "chats"
+    chat_id = Column(String, primary_key=True, unique=True, nullable=False)
+    user_id = Column(String, ForeignKey("users.id", ondelete="CASCADE"), nullable=False)
+    title = Column(String, nullable=False)
+    timestamp = Column(DateTime, default=datetime.utcnow, nullable=False)
+    messages = relationship("ChatMessage", back_populates="chat", cascade="all, delete-orphan")
+    documents = relationship("Document", back_populates="chat", cascade="all, delete-orphan")
+    user = relationship("User", back_populates="chats")
+
+class ChatMessage(Base):
+    __tablename__ = "chat_messages"
+    id = Column(String, primary_key=True, unique=True, nullable=False)
+    chat_id = Column(String, ForeignKey("chats.chat_id", ondelete="CASCADE"), nullable=False)
+    type = Column(String, nullable=False)  # 'user' or 'assistant'
+    content = Column(Text, nullable=False)
+    timestamp = Column(DateTime, default=datetime.utcnow, nullable=False)
+    referenced_docs = Column(Text, nullable=True)  # JSON string of referenced documents
+    chat = relationship("Chat", back_populates="messages")
+
+class Document(Base):
+    __tablename__ = "documents"
+    id = Column(String, primary_key=True, unique=True, nullable=False)
+    chat_id = Column(String, ForeignKey("chats.chat_id", ondelete="CASCADE"), nullable=False)
+    name = Column(String, nullable=False)
+    content = Column(Text, nullable=False)
+    timestamp = Column(DateTime, default=datetime.utcnow, nullable=False)
+    chat = relationship("Chat", back_populates="documents")
+
+Base.metadata.create_all(bind=engine)
+
+def get_db():
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()

main.py

@@ -0,0 +1,373 @@
+from fastapi import FastAPI, UploadFile, File, HTTPException, Depends, Header
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+import google.generativeai as genai
+from typing import List
+import os
+from dotenv import load_dotenv
+import io
+from datetime import datetime, timedelta
+import uuid
+
+import json
+import re
+
+# File Format Libraries
+import PyPDF2
+import docx
+import openpyxl
+import csv
+import io
+import pptx
+from db import get_db, Chat, ChatMessage, User, Document, SessionLocal
+
+from fastapi.security import OAuth2PasswordBearer
+import requests
+from jose import jwt
+import random
+
+oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")
+
+load_dotenv()
+
+GOOGLE_CLIENT_ID = os.getenv('GOOGLE_CLIENT_ID')
+GOOGLE_CLIENT_SECRET = os.getenv('GOOGLE_CLIENT_SECRET')
+GOOGLE_REDIRECT_URI = os.getenv('GOOGLE_REDIRECT_URI')
+
+api_keys = os.getenv('GEMINI_API_KEYS').split(',')
+
+
+
+def parse_json_from_gemini(json_str: str):
+    try:
+        # Remove potential leading/trailing whitespace
+        json_str = json_str.strip()
+        # Extract JSON content from triple backticks and "json" language specifier
+        json_match = re.search(r"```json\s*(.*?)\s*```", json_str, re.DOTALL)
+        if json_match:
+            json_str = json_match.group(1)
+        return json.loads(json_str)
+    except (json.JSONDecodeError, AttributeError):
+        return None
+
+load_dotenv()
+
+app = FastAPI(title="EduScope AI")
+
+# Configure CORS
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+@app.get("/login/google")
+async def login_google():
+    return {
+        "url": f"https://accounts.google.com/o/oauth2/auth?response_type=code&client_id={GOOGLE_CLIENT_ID}&redirect_uri={GOOGLE_REDIRECT_URI}&scope=openid%20profile%20email&access_type=offline"
+    }
+
+@app.get("/auth/google")
+async def auth_google(code: str, db: SessionLocal = Depends(get_db)):
+    token_url = "https://accounts.google.com/o/oauth2/token"
+    data = {
+        "code": code,
+        "client_id": GOOGLE_CLIENT_ID,
+        "client_secret": GOOGLE_CLIENT_SECRET,
+        "redirect_uri": GOOGLE_REDIRECT_URI,
+        "grant_type": "authorization_code",
+    }
+    response = requests.post(token_url, data=data)
+    access_token = response.json().get("access_token")
+    user_info = requests.get("https://www.googleapis.com/oauth2/v1/userinfo", headers={"Authorization": f"Bearer {access_token}"}).json()
+    user = db.query(User).filter(User.id == user_info["id"]).first()
+    if not user:
+        user = User(id=user_info["id"], email=user_info["email"], name=user_info["name"])
+        db.add(user)
+        db.commit()
+
+    return {"token": jwt.encode(user_info, GOOGLE_CLIENT_SECRET, algorithm="HS256")}
+    # return user_info.json()
+
+
+async def decode_token(authorization: str = Header(...)):
+    if not authorization.startswith("Bearer "):
+        raise HTTPException(
+            status_code=400,
+            detail="Authorization header must start with 'Bearer '"
+        )
+    
+    token = authorization[len("Bearer "):]  # Extract token part
+
+    try:
+        # Decode and verify the JWT token
+        token_data = jwt.decode(token, GOOGLE_CLIENT_SECRET, algorithms=["HS256"])
+        return token_data  # Return decoded token data
+    except jwt.ExpiredSignatureError:
+        raise HTTPException(status_code=401, detail="Token has expired")
+    except jwt.InvalidTokenError:
+        raise HTTPException(status_code=401, detail="Invalid token")
+    
+
+@app.get("/token")
+async def get_token(user_data: dict = Depends(decode_token)):
+    return user_data
+
+
+@app.post("/chats")
+async def create_chat(title: str, user_data: dict = Depends(decode_token), db: SessionLocal = Depends(get_db)):
+    user_id = user_data["id"]
+
+    chat = Chat(chat_id=str(uuid.uuid4()), user_id=user_id, title=title)
+    db.add(chat)
+    db.commit()
+    return {"chat_id": chat.chat_id, "title": title, "timestamp": chat.timestamp}
+
+
+@app.get("/chats")
+async def get_chats(user_data: dict = Depends(decode_token), db: SessionLocal = Depends(get_db)):
+    user_id = user_data["id"]
+
+    chats = db.query(Chat).filter(Chat.user_id == user_id).all()
+    return [{"chat_id": chat.chat_id, "title": chat.title, "timestamp": chat.timestamp} for chat in chats]
+
+
+
+class DocumentSchema(BaseModel):
+    id: str
+    name: str
+    timestamp: str
+
+class Query(BaseModel):
+    text: str
+    selected_docs: List[str]
+
+class ChatMessageSchema(BaseModel):
+    id: str
+    type: str  # 'user' or 'assistant'
+    content: str
+    timestamp: str
+    referenced_docs: List[str] = []
+
+class Analysis(BaseModel):
+    insight: str
+    pareto_analysis: dict
+
+def extract_text_from_file(file: UploadFile):
+    """
+    Extract text from various file types
+    Supports: PDF, DOCX, XLSX, CSV, TXT, PPTX
+    """
+    file_extension = os.path.splitext(file.filename)[1].lower()
+    content = file.file.read()
+    print(file_extension)
+    
+    try:
+        if file_extension == '.pdf':
+            pdf_reader = PyPDF2.PdfReader(io.BytesIO(content))
+            text = "\n".join([page.extract_text() for page in pdf_reader.pages])
+        
+        elif file_extension == '.docx':
+            doc = docx.Document(io.BytesIO(content))
+            text = "\n".join([para.text for para in doc.paragraphs])
+        
+        elif file_extension == '.xlsx':
+            wb = openpyxl.load_workbook(io.BytesIO(content), read_only=True)
+            text = ""
+            for sheet in wb:
+                for row in sheet.iter_rows(values_only=True):
+                    text += " ".join(str(cell) for cell in row if cell is not None) + "\n"
+        
+        elif file_extension == '.csv':
+            csv_reader = csv.reader(io.StringIO(content.decode('utf-8')))
+            text = "\n".join([" ".join(row) for row in csv_reader])
+        
+        elif file_extension == '.txt':
+            text = content.decode('utf-8')
+
+        elif file_extension in ['.ppt', '.pptx']:
+            ppt = pptx.Presentation(io.BytesIO(content))
+            text = ""
+            for slide in ppt.slides:
+                for shape in slide.shapes:
+                    if hasattr(shape, "text"):
+                        text += shape.text + "\n"
+        
+        else:
+            raise ValueError(f"Unsupported file type: {file_extension}")
+        
+        return text
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=f"Error processing file: {str(e)}")
+
+@app.post("/chats/{chat_id}/upload")
+async def upload_document(chat_id: str, file: UploadFile = File(...), user_data: dict = Depends(decode_token), db: SessionLocal = Depends(get_db)):
+    user_id = user_data["id"]
+    # Check if the chat exists and belongs to the user
+    chat = db.query(Chat).filter(Chat.chat_id == chat_id, Chat.user_id == user_id).first()
+    if not chat:
+        raise HTTPException(status_code=404, detail="Chat not found")
+    try:
+        text = extract_text_from_file(file)
+        doc_id = str(uuid.uuid4())
+        document = Document(
+            id=doc_id,
+            chat_id=chat_id,
+            name=file.filename,
+            content=text,
+            timestamp=datetime.now()
+        )
+        db.add(document)
+        db.commit()
+        db.refresh(document)
+        return {
+            "id": document.id,
+            "name": document.name,
+            "timestamp": document.timestamp.isoformat()
+        }
+    except HTTPException as e:
+        raise e
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Unexpected error: {str(e)}")
+
+@app.get("/chats/{chat_id}/documents")
+async def get_documents(chat_id: str, user_data: dict = Depends(decode_token), db: SessionLocal = Depends(get_db)):
+    user_id = user_data["id"]
+    chat = db.query(Chat).filter(Chat.chat_id == chat_id, Chat.user_id == user_id).first()
+    if not chat:
+        raise HTTPException(status_code=404, detail="Chat not found")
+    documents = db.query(Document).filter(Document.chat_id == chat_id).all()
+    return [{
+        "id": doc.id,
+        "name": doc.name,
+        "timestamp": doc.timestamp.isoformat()
+    } for doc in documents]
+
+@app.post("/chats/{chat_id}/analyze", response_model=Analysis)
+async def analyze_text(chat_id: str, query: Query, user_data: dict = Depends(decode_token), db: SessionLocal = Depends(get_db)):
+    user_id = user_data["id"]
+    # Check if the chat exists and belongs to the user
+    chat = db.query(Chat).filter(Chat.chat_id == chat_id, Chat.user_id == user_id).first()
+    if not chat:
+        raise HTTPException(status_code=404, detail="Chat not found")
+    # Fetch documents
+    docs = db.query(Document).filter(Document.chat_id == chat_id, Document.id.in_(query.selected_docs)).all()
+    if not docs:
+        raise HTTPException(status_code=400, detail="No documents found for analysis")
+    # Combine content from selected documents
+    combined_context = "\n\n".join([
+        f"Document '{doc.name}':\n{doc.content}" for doc in docs
+    ])
+    
+    prompt = f"""
+    Analyze the following text in the context of this query: {query.text}
+
+    Context from multiple documents:
+    {combined_context}
+
+    Provide:
+    1. Detailed insights and analysis, comparing information across documents when relevant
+    2. Apply the Pareto Principle (80/20 rule) to identify the most important aspects
+
+    Format the response as JSON with 'insight' and 'pareto_analysis' keys.
+
+    Example format:
+    {{
+        "insight": "Key findings and analysis from the documents based on query...",
+        "pareto_analysis": {{
+            "vital_few": "The 20% of factors that drive 80% of the impact...",
+            "trivial_many": "The remaining 80% of factors that contribute 20% of the impact..."
+        }}
+    }}
+
+    also give a complete html document with a intreactive quiz (minimum 5 questions) using jquery and also a flashcards to help the user understand the content better.
+    """
+    
+    api_key = random.choice(api_keys)
+    genai.configure(api_key=api_key)
+    print("Selected API Key: ", api_key)
+    
+    model = genai.GenerativeModel('gemini-1.5-flash')
+
+    response = model.generate_content(prompt)
+    response_text = response.text
+
+    # Save user message
+    user_message = ChatMessage(
+        id=str(uuid.uuid4()),
+        chat_id=chat_id,
+        type="user",
+        content=query.text,
+        timestamp=datetime.now(),
+        referenced_docs=json.dumps(query.selected_docs)
+    )
+    db.add(user_message)
+    # Parse analysis
+    analysis = parse_json_from_gemini(response_text)
+    # Save assistant message
+
+    assistant_message = ChatMessage(
+        id=str(uuid.uuid4()),
+        chat_id=chat_id,
+        type="assistant",
+        content=json.dumps(analysis, indent=4),
+        timestamp=datetime.now() -timedelta(seconds=3),
+        referenced_docs=json.dumps(query.selected_docs)
+    )
+
+    db.add(assistant_message)
+
+    if '```html' in response_text:
+        html = response_text.split('```html')[1]
+        html = html.split('```')[0]
+        html = html.strip()
+        assistant_message_1 = ChatMessage(
+            id=str(uuid.uuid4()),
+            chat_id=chat_id,
+            type="assistant",
+            content=html,
+            timestamp=datetime.now(),
+            referenced_docs=json.dumps(query.selected_docs)
+        )
+
+        db.add(assistant_message_1)
+
+    db.commit()
+    return analysis
+
+@app.get("/chats/{chat_id}/chat-history")
+async def get_chat_history(chat_id: str, user_data: dict = Depends(decode_token), db: SessionLocal = Depends(get_db)):
+    user_id = user_data["id"]
+    # Check if the chat exists and belongs to the user
+    chat = db.query(Chat).filter(Chat.chat_id == chat_id, Chat.user_id == user_id).first()
+    if not chat:
+        raise HTTPException(status_code=404, detail="Chat not found")
+    messages = db.query(ChatMessage).filter(ChatMessage.chat_id == chat_id).order_by(ChatMessage.timestamp).all()
+    return [{
+        "id": msg.id,
+        "type": msg.type,
+        "content": msg.content,
+        "timestamp": msg.timestamp.isoformat(),
+        "referenced_docs": json.loads(msg.referenced_docs) if msg.referenced_docs else []
+    } for msg in messages]
+
+@app.delete("/chats/{chat_id}/clear")
+async def clear_chat(chat_id: str, user_data: dict = Depends(decode_token), db: SessionLocal = Depends(get_db)):
+    user_id = user_data["id"]
+    chat = db.query(Chat).filter(Chat.chat_id == chat_id, Chat.user_id == user_id).first()
+    if not chat:
+        raise HTTPException(status_code=404, detail="Chat not found")
+    # Delete documents and messages
+    db.query(Document).filter(Document.chat_id == chat_id).delete()
+    db.query(ChatMessage).filter(ChatMessage.chat_id == chat_id).delete()
+    db.commit()
+    return {"message": "Chat cleared successfully"}
+
+
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8000)

old/MainPage copy.jsx

@@ -0,0 +1,419 @@
+import React, { useState, useEffect } from 'react';
+import { motion, AnimatePresence } from 'framer-motion';
+import { Upload, BookOpen, Search, File, Send, Trash2, Gem, Loader2 } from 'lucide-react';
+import { Card, CardContent, CardHeader, CardTitle } from '@/components/ui/card';
+import { Button } from '@/components/ui/button';
+import { Textarea } from '@/components/ui/textarea';
+import { Alert, AlertTitle, AlertDescription } from '@/components/ui/alert';
+import { Checkbox } from '@/components/ui/checkbox';
+import { toast, Toaster } from 'sonner';
+import GeminiResponseDisplay from './GeminiResponse';
+
+const FileTypeIcons = {
+  '.pdf': File,
+  '.docx': File,
+  '.xlsx': File,
+  '.csv': File,
+  '.txt': File,
+  '.ppt': File,
+  '.pptx': File
+};
+
+const containerVariants = {
+  hidden: { opacity: 0 },
+  visible: { 
+    opacity: 1,
+    transition: {
+      delayChildren: 0.2,
+      staggerChildren: 0.1
+    }
+  }
+};
+
+const itemVariants = {
+  hidden: { y: 20, opacity: 0 },
+  visible: { 
+    y: 0, 
+    opacity: 1,
+    transition: {
+      type: "spring",
+      stiffness: 300,
+      damping: 24
+    }
+  }
+};
+
+const chatMessageVariants = {
+  hidden: { opacity: 0, x: -20 },
+  visible: { 
+    opacity: 1, 
+    x: 0,
+    transition: {
+      type: "tween",
+      duration: 0.3
+    }
+  }
+};
+
+const MainPage = () => {
+  // State Management
+  const [documents, setDocuments] = useState([]);
+  const [query, setQuery] = useState('');
+  const [chatHistory, setChatHistory] = useState([]);
+  const [loading, setLoading] = useState(false);
+  const [selectedDocs, setSelectedDocs] = useState([]);
+
+  // Error Handling
+  const showError = (message, description = '') => {
+    toast.error(message, {
+      description,
+      duration: 4000
+    });
+  };
+
+  const showSuccess = (message, description = '') => {
+    toast.success(message, {
+      description,
+      duration: 3000
+    });
+  };
+
+  // Fetch Initial Data
+  useEffect(() => {
+    fetchDocuments();
+    fetchChatHistory();
+  }, []);
+
+  const fetchDocuments = async () => {
+    try {
+      const response = await fetch('http://localhost:8000/documents');
+      const data = await response.json();
+      setDocuments(data);
+    } catch (err) {
+      showError('Failed to fetch documents', err.message);
+    }
+  };
+
+  const fetchChatHistory = async () => {
+    try {
+      const response = await fetch('http://localhost:8000/chat-history');
+      const data = await response.json();
+      setChatHistory(data);
+    } catch (err) {
+      showError('Failed to fetch chat history', err.message);
+    }
+  };
+
+  const ALLOWED_TYPES = ['.pdf', '.docx', '.xlsx', '.csv', '.txt','.ppt', '.pptx'];
+
+  const handleFileUpload = async (event) => {
+    const file = event.target.files[0];
+    if (!file) return;
+
+    // File Validation
+    const MAX_FILE_SIZE = 35 * 1024 * 1024; // 35MB
+    const fileExtension = '.' + file.name.split('.').pop().toLowerCase();
+
+    if (file.size > MAX_FILE_SIZE) {
+      showError('File Too Large', 'Maximum file size is 35MB');
+      return;
+    }
+
+    if (!ALLOWED_TYPES.includes(fileExtension)) {
+      showError('Unsupported File Type', `Supported: ${ALLOWED_TYPES.join(', ')}`);
+      return;
+    }
+
+    const formData = new FormData();
+    formData.append('file', file);
+
+    try {
+      setLoading(true);
+      const response = await fetch('http://localhost:8000/upload', {
+        method: 'POST',
+        body: formData,
+      });
+
+      if (!response.ok) throw new Error('Upload failed');
+
+      const data = await response.json();
+      setDocuments([...documents, data]);
+      showSuccess('Document Uploaded', `${file.name} processed successfully`);
+    } catch (err) {
+      showError('Failed to upload document', err.message);
+    } finally {
+      setLoading(false);
+    }
+  };
+
+  const handleClearAll = async () => {
+    try {
+      setLoading(true);
+      const response = await fetch('http://localhost:8000/clear-all', {
+        method: 'GET',
+      });
+
+      if (!response.ok) throw new Error('Clear all failed');
+
+      setDocuments([]);
+      setChatHistory([]);
+      setSelectedDocs([]);
+      showSuccess('Data Cleared', 'All documents and chat history removed');
+    } catch (err) {
+      showError('Failed to clear all', err.message);
+    } finally {
+      setLoading(false);
+    }
+  };
+
+  const handleAnalyze = async () => {
+    if (!selectedDocs.length || !query) {
+      showError('Incomplete Request', 'Select documents and enter a query');
+      return;
+    }
+
+    try {
+      setLoading(true);
+      const response = await fetch('http://localhost:8000/analyze', {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+          text: query,
+          selected_docs: selectedDocs,
+        }),
+      });
+
+      if (!response.ok) throw new Error('Analysis failed');
+
+      await fetchChatHistory();
+      setQuery('');
+      showSuccess('Analysis Complete', 'Results are available in chat history');
+    } catch (err) {
+      showError('Failed to analyze', err.message);
+    } finally {
+      setLoading(false);
+    }
+  };
+
+  const formatTimestamp = (timestamp) => {
+    return new Date(timestamp).toLocaleString();
+  };
+
+  return (
+    <motion.div 
+      initial="hidden"
+      animate="visible"
+      variants={containerVariants}
+      className="min-h-screen bg-gray-100 p-8"
+    >
+      <Toaster position="top-right" />
+      <motion.div 
+        variants={itemVariants}
+        className="max-w-6xl mx-auto space-y-6"
+      >
+        <Card>
+          <CardHeader>
+            <motion.div 
+              variants={itemVariants}
+              className="flex items-center justify-between"
+            >
+              <CardTitle className="text-2xl font-bold flex items-center gap-2">
+                <BookOpen className="w-6 h-6" />
+                EduScope AI
+              </CardTitle>
+              <motion.div
+                whileHover={{ scale: 1.05 }}
+                whileTap={{ scale: 0.95 }}
+              >
+                <Gem className="w-6 h-6 text-purple-600" />
+              </motion.div>
+            </motion.div>
+          </CardHeader>
+          <CardContent>
+            <div className="grid grid-cols-12 gap-6">
+              {/* Document Management Sidebar */}
+              <motion.div 
+                variants={itemVariants}
+                className="col-span-4 space-y-4"
+              >
+                <Card>
+                  <CardHeader>
+                    <CardTitle className="text-lg">Documents</CardTitle>
+                  </CardHeader>
+                  <CardContent>
+                    <div className="space-y-4">
+                      <motion.div 
+                        whileHover={{ scale: 1.02 }}
+                        whileTap={{ scale: 0.98 }}
+                      >
+                        <Button
+                          variant="outline"
+                          onClick={() => document.getElementById('file-upload').click()}
+                          className="w-full"
+                        >
+                          <Upload className="w-4 h-4 mr-2" />
+                          Upload Document
+                        </Button>
+                      </motion.div>
+
+                      <motion.div 
+                        whileHover={{ scale: 1.02 }}
+                        whileTap={{ scale: 0.98 }}
+                      >
+                        <Button
+                          onClick={handleClearAll}
+                          disabled={loading}
+                          className="w-full"
+                        >
+                          {loading ? (
+                            <Loader2 className="w-4 h-4 mr-2 animate-spin" />
+                          ) : (
+                            <Trash2 className="w-4 h-4 mr-2" />
+                          )}
+                          Clear All
+                        </Button>
+                      </motion.div>
+
+                      <input
+                        id="file-upload"
+                        type="file"
+                        accept={ALLOWED_TYPES.join(',')}
+                        className="hidden"
+                        onChange={handleFileUpload}
+                      />
+
+                      <motion.div 
+                        variants={containerVariants}
+                        className="space-y-2"
+                      >
+                        <AnimatePresence>
+                          {documents.map((doc) => {
+                            const FileIcon = FileTypeIcons[`.${doc.name.split('.').pop().toLowerCase()}`] || File;
+                            return (
+                              <motion.div 
+                                key={doc.id}
+                                initial={{ opacity: 0, x: -20 }}
+                                animate={{ opacity: 1, x: 0 }}
+                                exit={{ opacity: 0, x: 20 }}
+                                transition={{ type: "spring", stiffness: 300, damping: 30 }}
+                                className="flex items-center space-x-2"
+                              >
+                                <Checkbox
+                                  checked={selectedDocs.includes(doc.id)}
+                                  onCheckedChange={(checked) => {
+                                    if (checked) {
+                                      setSelectedDocs([...selectedDocs, doc.id]);
+                                    } else {
+                                      setSelectedDocs(selectedDocs.filter(id => id !== doc.id));
+                                    }
+                                  }}
+                                />
+                                <div className="flex items-center space-x-2">
+                                  <FileIcon className="w-4 h-4" />
+                                  <span className="text-sm truncate">{doc.name}</span>
+                                </div>
+                              </motion.div>
+                            );
+                          })}
+                        </AnimatePresence>
+                      </motion.div>
+                    </div>
+                  </CardContent>
+                </Card>
+              </motion.div>
+
+              {/* Chat Interface */}
+              <motion.div 
+                variants={itemVariants}
+                className="col-span-8 space-y-4"
+              >
+                <motion.div 
+                  className="h-[500px] overflow-y-auto bg-white rounded-lg p-4 border"
+                  initial={{ opacity: 0 }}
+                  animate={{ opacity: 1 }}
+                >
+                  <AnimatePresence>
+                    {chatHistory.map((message) => (
+                      <motion.div
+                        key={message.id}
+                        variants={chatMessageVariants}
+                        initial="hidden"
+                        animate="visible"
+                        exit={{ opacity: 0, x: 20 }}
+                        className={`mb-4 ${message.type === 'assistant' ? 'ml-4' : 'mr-4'}`}
+                      >
+                        <div
+                          className={`p-3 rounded-lg ${
+                            message.type === 'assistant'
+                              ? 'bg-blue-100'
+                              : 'bg-gray-100'
+                          }`}
+                        >
+                          <div className="text-sm text-gray-500 mb-1">
+                            {message.type === 'assistant' ? 'AI Assistant' : 'You'} •{' '}
+                            {formatTimestamp(message.timestamp)}
+                          </div>
+                          <div className="text-gray-800">
+                            {message.content.includes('pareto_analysis') || message.content.includes('<html') 
+                              ? <GeminiResponseDisplay responseStr={message.content} /> 
+                              : message.content}
+                          </div>
+                          {message.referenced_docs.length > 0 && (
+                            <div className="text-xs text-gray-500 mt-2">
+                              Referenced documents:{' '}
+                              {message.referenced_docs
+                                .map(
+                                  (docId) =>
+                                    documents.find((d) => d.id === docId)?.name
+                                )
+                                .join(', ')}
+                            </div>
+                          )}
+                        </div>
+                      </motion.div>
+                    ))}
+                  </AnimatePresence>
+                </motion.div>
+
+                <motion.div 
+                  variants={itemVariants}
+                  className="flex gap-2"
+                >
+                  <Textarea
+                    value={query}
+                    onChange={(e) => setQuery(e.target.value)}
+                    placeholder="Ask a question about the selected documents..."
+                    className="flex-1"
+                  />
+                  <motion.div
+                    whileHover={{ scale: 1.05 }}
+                    whileTap={{ scale: 0.95 }}
+                  >
+                    <Button
+                      onClick={handleAnalyze}
+                      disabled={loading}
+                      className="self-end"
+                    >
+                      {loading ? (
+                        <Loader2 className="w-4 h-4 mr-2 animate-spin" />
+                      ) : (
+                        <>
+                          <Send className="w-4 h-4 mr-2" />
+                          Send
+                        </>
+                      )}
+                    </Button>
+                  </motion.div>
+                </motion.div>
+              </motion.div>
+            </div>
+          </CardContent>
+        </Card>
+      </motion.div>
+    </motion.div>
+  );
+};
+
+export default MainPage;

old/main_old.py

@@ -0,0 +1,337 @@
+# main.py
+from fastapi import FastAPI, UploadFile, File, HTTPException,Depends,Header
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+import google.generativeai as genai
+from typing import List, Dict
+import os
+from dotenv import load_dotenv
+import io
+from datetime import datetime
+import uuid
+
+import json
+import re
+
+# File Format Libraries
+import PyPDF2
+import docx
+import openpyxl
+import csv
+import io
+import pptx
+from db import get_db,Chat,ChatMessage,User,SessionLocal
+
+
+from fastapi.security import OAuth2PasswordBearer
+import requests
+from jose import jwt
+
+oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")
+
+DOMAIN = "http://localhost:8000"
+# Replace these with your own values from the Google Developer Console
+GOOGLE_CLIENT_ID = "862058885628-e6mjev28p8e112qrp9gnn4q8mlif3bbf.apps.googleusercontent.com"
+GOOGLE_CLIENT_SECRET = "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"
+GOOGLE_REDIRECT_URI = "http://localhost:5173/callback"
+
+
+def parse_json_from_gemini(json_str: str):
+    try:
+        # Remove potential leading/trailing whitespace
+        json_str = json_str.strip()
+        # Extract JSON content from triple backticks and "json" language specifier
+        json_match = re.search(r"```json\s*(.*?)\s*```", json_str, re.DOTALL)
+        if json_match:
+            json_str = json_match.group(1)
+        return json.loads(json_str)
+    except (json.JSONDecodeError, AttributeError):
+        return None
+
+load_dotenv()
+
+app = FastAPI(title="EduScope AI")
+
+# Configure CORS
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+@app.get("/login/google")
+async def login_google():
+    return {
+        "url": f"https://accounts.google.com/o/oauth2/auth?response_type=code&client_id={GOOGLE_CLIENT_ID}&redirect_uri={GOOGLE_REDIRECT_URI}&scope=openid%20profile%20email&access_type=offline"
+    }
+
+@app.get("/auth/google")
+async def auth_google(code: str, db: SessionLocal = Depends(get_db)):
+    token_url = "https://accounts.google.com/o/oauth2/token"
+    data = {
+        "code": code,
+        "client_id": GOOGLE_CLIENT_ID,
+        "client_secret": GOOGLE_CLIENT_SECRET,
+        "redirect_uri": GOOGLE_REDIRECT_URI,
+        "grant_type": "authorization_code",
+    }
+    response = requests.post(token_url, data=data)
+    access_token = response.json().get("access_token")
+    user_info = requests.get("https://www.googleapis.com/oauth2/v1/userinfo", headers={"Authorization": f"Bearer {access_token}"}).json()
+    user = db.query(User).filter(User.id == user_info["id"]).first()
+    if not user:
+        user = User(id=user_info["id"], email=user_info["email"], name=user_info["name"])
+        db.add(user)
+        db.commit()
+
+    return {"token": jwt.encode(user_info, GOOGLE_CLIENT_SECRET, algorithm="HS256")}
+    # return user_info.json()
+
+
+async def decode_token(authorization: str = Header(...)):
+    if not authorization.startswith("Bearer "):
+        raise HTTPException(
+            status_code=400,
+            detail="Authorization header must start with 'Bearer '"
+        )
+    
+    token = authorization[len("Bearer "):]  # Extract token part
+
+    try:
+        # Decode and verify the JWT token
+        token_data = jwt.decode(token, GOOGLE_CLIENT_SECRET, algorithms=["HS256"])
+        return token_data  # Return decoded token data
+    except jwt.ExpiredSignatureError:
+        raise HTTPException(status_code=401, detail="Token has expired")
+    except jwt.InvalidTokenError:
+        raise HTTPException(status_code=401, detail="Invalid token")
+    
+
+@app.get("/token")
+async def get_token(user_data: dict = Depends(decode_token)):
+    return user_data
+
+
+@app.post("/chats")
+async def create_chat(title: str,user_data: dict = Depends(decode_token), db: SessionLocal = Depends(get_db)):
+    user_id = user_data["id"]
+
+    chat = Chat(chat_id=str(uuid.uuid4()), user_id=user_id, title=title)
+    db.add(chat)
+    db.commit()
+    return {"chat_id": chat.chat_id, "title": title, "timestamp": chat.timestamp}
+
+
+@app.get("/chats")
+async def get_chats(user_data: dict = Depends(decode_token), db: SessionLocal = Depends(get_db)):
+    user_id = user_data["id"]
+
+    chats = db.query(Chat).filter(Chat.user_id == user_id).all()
+    return [{"chat_id": chat.chat_id, "title": chat.title, "timestamp": chat.timestamp} for chat in chats]
+
+
+genai.configure(api_key="AIzaSyDZsN3hnnNQOBLSAznFh7xWbWKNohvqff0")
+model = genai.GenerativeModel('gemini-1.5-flash')
+
+documents = {}
+chat_history = []
+
+class Document(BaseModel):
+    id: str
+    name: str
+    content: str
+    timestamp: str
+
+class Query(BaseModel):
+    text: str
+    selected_docs: List[str]
+
+class ChatMessage(BaseModel):
+    id: str
+    type: str  # 'user' or 'assistant'
+    content: str
+    timestamp: str
+    referenced_docs: List[str] = []
+
+    
+
+class Analysis(BaseModel):
+    insight: str
+    pareto_analysis: dict
+
+def extract_text_from_file(file: UploadFile):
+    """
+    Extract text from various file types
+    Supports: PDF, DOCX, XLSX, CSV, TXT
+    """
+    file_extension = os.path.splitext(file.filename)[1].lower()
+    content = file.file.read()
+    
+    try:
+        if file_extension == '.pdf':
+            pdf_reader = PyPDF2.PdfReader(io.BytesIO(content))
+            text = "\n".join([page.extract_text() for page in pdf_reader.pages])
+        
+        elif file_extension == '.docx':
+            doc = docx.Document(io.BytesIO(content))
+            text = "\n".join([para.text for para in doc.paragraphs])
+        
+        elif file_extension == '.xlsx':
+            wb = openpyxl.load_workbook(io.BytesIO(content), read_only=True)
+            text = ""
+            for sheet in wb:
+                for row in sheet.iter_rows(values_only=True):
+                    text += " ".join(str(cell) for cell in row if cell is not None) + "\n"
+        
+        elif file_extension == '.csv':
+            csv_reader = csv.reader(io.StringIO(content.decode('utf-8')))
+            text = "\n".join([" ".join(row) for row in csv_reader])
+        
+        elif file_extension == '.txt':
+            text = content.decode('utf-8')
+
+        elif file_extension in ['.ppt', '.pptx']:
+            ppt = pptx.Presentation(io.BytesIO(content))
+            text = ""
+            for slide in ppt.slides:
+                for shape in slide.shapes:
+                    if hasattr(shape, "text"):
+                        text += shape.text + "\n"
+        
+        else:
+            raise ValueError(f"Unsupported file type: {file_extension}")
+        
+        return text
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=f"Error processing file: {str(e)}")
+
+@app.post("/upload")
+async def upload_document(file: UploadFile = File(...)):
+    try:
+        text = extract_text_from_file(file)
+        
+        doc_id = str(uuid.uuid4())
+        document = Document(
+            id=doc_id,
+            name=file.filename,
+            content=text,
+            timestamp=datetime.now().isoformat()
+        )
+        documents[doc_id] = document
+        
+        return document.dict()
+    except HTTPException as e:
+        raise e
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Unexpected error: {str(e)}")
+
+@app.get("/documents")
+async def get_documents():
+    return list(documents.values())
+
+@app.post("/analyze", response_model=Analysis)
+async def analyze_text(query: Query):
+    # try:
+        # Combine content from selected documents
+        combined_context = "\n\n".join([
+            f"Document '{documents[doc_id].name}':\n{documents[doc_id].content}"
+            for doc_id in query.selected_docs
+        ])
+        
+        prompt = f"""
+        Analyze the following text in the context of this query: {query.text}
+
+        Context from multiple documents:
+        {combined_context}
+
+        Provide:
+        1. Detailed insights and analysis, comparing information across documents when relevant
+        2. Apply the Pareto Principle (80/20 rule) to identify the most important aspects
+
+        Format the response as JSON with 'insight' and 'pareto_analysis' keys.
+
+        Example format:
+        {{
+            "insight": "Key findings and analysis from the documents...",
+            "pareto_analysis": {{
+                "vital_few": "The 20% of factors that drive 80% of the impact...",
+                "trivial_many": "The remaining 80% of factors that contribute 20% of the impact..."
+            }}
+        }}
+
+        also give a complete html document with the illustrative analysis like pie charts, bar charts,graphs etc.
+        """
+        response = model.generate_content(prompt)
+        response_text = response.text
+        # print(response_text)
+
+        
+        # Create chat message
+        message = ChatMessage(
+            id=str(uuid.uuid4()),
+            type="user",
+            content=query.text,
+            timestamp=datetime.now().isoformat(),
+            referenced_docs=query.selected_docs
+        )
+        chat_history.append(message)
+        
+        # print(response_text)
+        # Create assistant response
+        # analysis = {
+        #     "insight": response_text.split("Pareto Analysis:")[0].strip(),
+        #     "pareto_analysis": {
+        #         "vital_few": response_text.split("Vital Few (20%):")[1].split("Trivial Many")[0].strip(),
+        #         "trivial_many": response_text.split("Trivial Many (80%):")[1].strip()
+        #     }
+        # }
+        analysis = parse_json_from_gemini(response_text)
+        
+        assistant_message = ChatMessage(
+            id=str(uuid.uuid4()),
+            type="assistant",
+            content=json.dumps(analysis, indent=4),
+            timestamp=datetime.now().isoformat(),
+            referenced_docs=query.selected_docs
+        )
+        chat_history.append(assistant_message)
+  
+
+
+
+        if '```html' in response_text:
+            html = response_text.split('```html')[1]
+            html = html.split('```')[0]
+            html = html.strip()
+            assistant_message = ChatMessage(
+                id=str(uuid.uuid4()),
+                type="assistant",
+                content=html,
+                timestamp=datetime.now().isoformat(),
+                referenced_docs=query.selected_docs
+            )
+            chat_history.append(assistant_message)
+        
+        return analysis
+    # except Exception as e:
+    #     raise HTTPException(status_code=500, detail=str(e))
+
+@app.get("/chat-history")
+async def get_chat_history():
+    return chat_history
+
+@app.get("/clear-all")
+async def clear_all():
+    chat_history.clear()
+    documents.clear()
+    return {"message": "All Data cleared successfully"}
+
+
+
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8000)

requirements.txt

@@ -0,0 +1,18 @@
+fastapi
+uvicorn
+python-multipart
+google-generativeai
+python-dotenv
+PyPDF2
+pydantic
+uuid
+starlette
+typing-extensions
+python-docx 
+openpyxl
+python-multipart
+python-jose[cryptography]
+requests
+sqlalchemy
+python-dotenv
+sqlalchemy-utils