Upload 12 files

.gitattributes

@@ -1,35 +1,35 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,33 @@
+FROM python:3.11-slim
+
+WORKDIR /code
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    && rm -rf /var/lib/apt/lists/*
+
+# Set up HuggingFace cache directory
+RUN mkdir -p /code/.cache/huggingface && chmod -R 777 /code/.cache/huggingface
+ENV HF_HOME /code/.cache/huggingface
+
+# Install Python dependencies
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY . .
+
+# Expose the port that Hugging Face Spaces expects
+EXPOSE 7860
+
+# Set environment variables
+ENV FLASK_APP=app.py
+ENV FLASK_ENV=production
+ENV PYTHONUNBUFFERED=1
+# Add Space-specific environment variables
+ENV HOST=0.0.0.0
+ENV PORT=7860
+
+# Run the application with the correct host and port for Spaces
+CMD ["python", "-c", "from app import app; app.run(host='0.0.0.0', port=7860)"]

app.py

@@ -0,0 +1,501 @@
+from flask import Flask, render_template, request, jsonify, redirect, url_for, flash, session, send_from_directory
+from flask_login import LoginManager, UserMixin, login_user, login_required, logout_user, current_user
+from flask_wtf.csrf import CSRFProtect
+from flask_wtf import FlaskForm
+from wtforms import StringField, PasswordField, SubmitField
+from wtforms.validators import DataRequired
+from werkzeug.security import generate_password_hash, check_password_hash
+from langchain_google_genai import ChatGoogleGenerativeAI, HarmCategory, HarmBlockThreshold # Replaced Groq with Google Gemini
+import arxiv
+import requests
+import PyPDF2
+from io import BytesIO
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain_groq import ChatGroq
+from langchain.memory import ConversationBufferMemory
+from langchain_huggingface import HuggingFaceEmbeddings # Updated: Use the dedicated langchain-huggingface package
+import numpy as np
+from concurrent.futures import ThreadPoolExecutor, TimeoutError
+from functools import lru_cache
+import time
+import os
+from dotenv import load_dotenv
+import json
+from datetime import datetime
+import firebase_admin
+from firebase_admin import credentials, auth
+from huggingface_hub import login
+
+# Load environment variables
+load_dotenv()
+
+# Configure logging
+import logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+app = Flask(__name__, 
+    static_folder='static',
+    static_url_path='/static',
+    template_folder='templates'
+)
+app.secret_key = os.getenv('FLASK_SECRET_KEY')
+
+# Initialize CSRF protection
+csrf = CSRFProtect()
+csrf.init_app(app)
+
+# Initialize Flask-Login
+login_manager = LoginManager()
+login_manager.init_app(app)
+login_manager.login_view = 'login'
+
+# Initialize Groq
+# groq_api_key = os.getenv('GROQ_API_KEY')
+# llm = ChatGroq(
+#     temperature=0.3,
+#     groq_api_key=groq_api_key,
+#     model_name="qwen-qwq-32b"
+# )
+
+# Get the API key from environment variables
+google_api_key = os.getenv('GOOGLE_API_KEY')
+if not google_api_key:
+    raise ValueError("GOOGLE_API_KEY not found. Please set it in your .env file.")
+
+llm = ChatGoogleGenerativeAI(
+    model="gemini-2.5-flash",
+    google_api_key=google_api_key,
+    temperature=0.3,
+    safety_settings={
+        HarmCategory.HARM_CATEGORY_HARASSMENT: HarmBlockThreshold.BLOCK_NONE,
+        HarmCategory.HARM_CATEGORY_HATE_SPEECH: HarmBlockThreshold.BLOCK_NONE,
+        HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT: HarmBlockThreshold.BLOCK_NONE,
+        HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT: HarmBlockThreshold.BLOCK_NONE,
+    }
+)
+
+# Initialize embeddings with proper cache directory
+embeddings_model = HuggingFaceEmbeddings(
+    model_name="sentence-transformers/all-MiniLM-L6-v2"
+)
+# Constants
+MAX_CHUNKS = 50
+MAX_RESPONSE_LENGTH = 4028
+CACHE_DURATION = 3600  # 1 hour in seconds
+
+# Form Classes
+class LoginForm(FlaskForm):
+    username = StringField('Username', validators=[DataRequired()])
+    password = PasswordField('Password', validators=[DataRequired()])
+    submit = SubmitField('Login')
+
+class RegisterForm(FlaskForm):
+    username = StringField('Username', validators=[DataRequired()])
+    password = PasswordField('Password', validators=[DataRequired()])
+    submit = SubmitField('Register')
+
+# User class for Flask-Login
+class User(UserMixin):
+    def __init__(self, user_id, email):
+        self.id = user_id
+        self.email = email
+
+def generate_analysis(chunks):
+    analysis_prompts = {
+    'executive_summary': """
+## 🧠 Role  
+You are an AI assistant that explains research papers in a way that makes reading the original paper unnecessary. Your explanations should be **clear, engaging, and easy to understand**, even for someone who is not deeply familiar with the subject.  
+
+## 🎯 Goal  
+Given any research paper, provide a **simple breakdown** covering:  
+
+### 1️⃣ What problem does this paper solve?  
+- Explain the **issue the paper addresses**.  
+- Why is this problem **important**?  
+- What **challenges** existed before this research?  
+
+### 2️⃣ How does it solve the problem?  
+- Summarize the **key idea, method, or approach** used in the paper.  
+- If applicable, break it down into **steps or components**.  
+- Compare it to **previous solutions** and highlight what makes it better.  
+
+### 3️⃣ Why does this matter? (Real-world impact & applications)  
+- How can this research be **used in practice**?  
+- What **industries or fields** benefit from it?  
+- Does it improve **efficiency, accuracy, cost, or scalability**?  
+
+### 4️⃣ Explain with a simple analogy (if applicable)  
+- Use a **real-life example** to explain complex ideas.  
+- Keep it **relatable** (e.g., compare it to something like cooking, traveling, or streaming music).  
+
+### 5️⃣ Key findings & results  
+- Summarize the **main results** in simple terms.  
+- If possible, include **numbers, graphs, or comparisons** for clarity.  
+
+### 6️⃣ Limitations & Future Work  
+- Mention any **weaknesses** or areas for improvement.  
+- What are the **next steps** for research in this area?  
+
+### 7️⃣ Final Takeaway (One-liner summary)  
+- Provide a **quick summary** of the research in a **single sentence**.  
+
+---
+
+## 🎨 Tone & Style  
+✔ **Simple & clear language** – Avoid jargon unless necessary.  
+✔ **Step-by-step explanations** – Organize information logically.  
+✔ **Engaging & structured** – Use bullet points, lists, or tables when needed.  
+✔ **Make it feel like a story** – Guide the reader smoothly from problem to solution.  
+
+---
+
+## ⚡ How to Use This Prompt  
+1️⃣ Enter the **title, abstract, or full text** of any research paper.  
+2️⃣ AI will generate a **detailed explanation** that makes the paper easy to understand.  
+3️⃣ Use it for **blog posts, study guides, or an AI-powered research assistant**.  
+
+
+Remember: The output should be properly formatted in markdown while providing comprehensive coverage of the paper's content."""
+    }
+    
+    analysis_results = {}
+    
+    for aspect, prompt in analysis_prompts.items():
+        try:
+            # Clean and join the chunks
+            context = "\n\n".join(
+                chunk.encode('ascii', 'ignore').decode('ascii')
+                for chunk in chunks[:3]
+            )
+            response = llm.invoke(
+                f"""Based on the following context from a research paper, {prompt}
+                
+                Context:
+                {context}
+
+                Additional Instructions:
+                - Provide specific examples and evidence from the text
+                - Use clear, academic language
+                - Maintain objectivity
+                - Include relevant quotes or data points
+                - Structure your response logically
+                - Use markdown formatting for clarity
+
+                Please provide a clear and specific response.""", 
+            )
+            analysis_results[aspect] = response.content[:MAX_RESPONSE_LENGTH]
+        except Exception as e:
+            analysis_results[aspect] = f"Analysis failed: {str(e)}"
+    
+    return analysis_results
+
+def process_pdf(pdf_url):
+    try:
+        print(f"Starting PDF processing for: {pdf_url}")
+        
+        response = requests.get(pdf_url, timeout=30)
+        response.raise_for_status()
+        pdf_file = BytesIO(response.content)
+
+        pdf_reader = PyPDF2.PdfReader(pdf_file)
+        # Clean and normalize the text
+        text = " ".join(
+            page.extract_text().encode('ascii', 'ignore').decode('ascii')
+            for page in pdf_reader.pages
+        )
+        
+        if not text.strip():
+            return {'error': 'No text could be extracted from the PDF'}
+
+        text_splitter = RecursiveCharacterTextSplitter(
+            chunk_size=2000,
+            chunk_overlap=200,
+            length_function=len,
+            separators=["\n\n", "\n", " ", ""]
+        )
+        
+        chunks = text_splitter.split_text(text)[:MAX_CHUNKS]
+        
+        analysis = generate_analysis(chunks)
+        return {
+            'success': True,
+            'analysis': analysis
+        }
+            
+    except Exception as e:
+        return {'error': f"PDF processing failed: {str(e)}"}
+
+
+@login_manager.user_loader
+def load_user(user_id):
+    if 'user_data' in session:
+        user_data = session['user_data']
+        return User(user_data['uid'], user_data['email'])
+    return None
+
+# User management functions
+def load_users():
+    try:
+        with open('users.json', 'r') as f:
+            return json.load(f)
+    except FileNotFoundError:
+        return {}
+
+def save_users(users):
+    with open('users.json', 'w') as f:
+        json.dump(users, f)
+
+# Routes
+@app.route('/')
+@login_required
+def index():
+    return render_template('index.html')
+
+@app.route('/login', methods=['GET'])
+def login():
+    if current_user.is_authenticated:
+        return redirect(url_for('index'))
+    return render_template('login.html')
+
+@app.route('/register', methods=['GET'])
+def register():
+    if current_user.is_authenticated:
+        print("User is already authenticated")
+        return redirect(url_for('index'))
+    return render_template('register.html')
+
+@app.route('/verify-token', methods=['POST'])
+def verify_token():
+    try:
+        data = request.json
+        if not data or not data.get('uid') or not data.get('email'):
+            return jsonify({'error': 'Missing required data'}), 400
+
+        # Store user data in session
+        session['user_data'] = {
+            'uid': data['uid'],
+            'email': data['email']
+        }
+        
+        # Create and login user
+        user = User(data['uid'], data['email'])
+        login_user(user)
+        
+        return jsonify({'success': True, 'redirect': url_for('index')})
+    except Exception as e:
+        print(f"Verification error: {str(e)}")  # Add logging
+        return jsonify({'error': str(e)}), 500
+
+@app.route('/logout')
+@login_required
+def logout():
+    logout_user()
+    session.clear()
+    return redirect(url_for('login'))
+
+@app.route('/search', methods=['POST'])
+@login_required
+def search():
+    try:
+        data = request.get_json()
+        paper_name = data.get('paper_name')
+        sort_by = data.get('sort_by', 'relevance')  # Default to relevance
+        max_results = data.get('max_results', 20)  # Increase to get more candidates for filtering
+
+        if not paper_name:
+            return jsonify({'error': 'No search query provided'}), 400
+
+        # Configure sorting based on user preference
+        sort_options = {
+            'relevance': arxiv.SortCriterion.Relevance,
+            'recent': arxiv.SortCriterion.SubmittedDate
+        }
+        
+        sort_criterion = sort_options.get(sort_by, arxiv.SortCriterion.Relevance)
+
+        # Perform the search
+        search = arxiv.Search(
+            query=paper_name,
+            max_results=max_results,
+            sort_by=sort_criterion
+        )
+
+        results = []
+        for paper in search.results():
+            # Extract citation count if available (not directly provided by arXiv API)
+            citation_count = 0
+            
+            # You could integrate with a citation API here (e.g., Semantic Scholar)
+            # For now, we'll use proxies for popularity like:
+            # - Papers with DOIs (published in journals) tend to be more established
+            # - Papers with more authors often have more visibility
+            # - More recent papers in the results might indicate ongoing relevance
+            
+            has_doi = hasattr(paper, 'doi') and paper.doi is not None
+            author_count = len(paper.authors)
+            
+            # Calculate a simple "popularity score" (this is a heuristic)
+            popularity_score = (10 if has_doi else 0) + min(author_count, 5)
+            
+            results.append({
+                'title': paper.title,
+                'authors': ', '.join(author.name for author in paper.authors),
+                'abstract': paper.summary,
+                'pdf_link': paper.pdf_url,
+                'arxiv_link': paper.entry_id,
+                'published': paper.published.strftime('%Y-%m-%d'),
+                'category': paper.primary_category,
+                'comment': paper.comment if hasattr(paper, 'comment') else None,
+                'doi': paper.doi if hasattr(paper, 'doi') else None,
+                'popularity_score': popularity_score  # Add popularity score
+            })
+        
+        # Sort results by our popularity score (higher is better)
+        results.sort(key=lambda x: x['popularity_score'], reverse=True)
+
+        return jsonify(results)
+
+    except Exception as e:
+        print(f"Search error: {str(e)}")
+        return jsonify({'error': f'Failed to search papers: {str(e)}'}), 500
+
+@app.route('/perform-rag', methods=['POST'])
+@login_required
+def perform_rag():
+    try:
+        pdf_url = request.json.get('pdf_url')
+        if not pdf_url:
+            return jsonify({'error': 'PDF URL is required'}), 400
+
+        result = process_pdf(pdf_url)
+        
+        if 'error' in result:
+            return jsonify({'error': result['error']}), 500
+            
+        return jsonify(result)
+
+    except Exception as e:
+        return jsonify({'error': str(e)}), 500
+
+@app.route('/chat-with-paper', methods=['POST'])
+@login_required
+def chat_with_paper():
+    try:
+        pdf_url = request.json.get('pdf_url')
+        question = request.json.get('question')
+        
+        if not pdf_url or not question:
+            return jsonify({'error': 'PDF URL and question are required'}), 400
+
+        # Get PDF text and create chunks
+        response = requests.get(pdf_url, timeout=30)
+        response.raise_for_status()
+        pdf_file = BytesIO(response.content)
+
+        pdf_reader = PyPDF2.PdfReader(pdf_file)
+        text = " ".join(page.extract_text() for page in pdf_reader.pages)
+        
+        if not text.strip():
+            return jsonify({'error': 'No text could be extracted from the PDF'})
+
+        # Create text chunks
+        text_splitter = RecursiveCharacterTextSplitter(
+            chunk_size=2000,
+            chunk_overlap=200,
+            length_function=len
+        )
+        chunks = text_splitter.split_text(text)[:MAX_CHUNKS]
+
+        # Generate embeddings for chunks
+        chunk_embeddings = embeddings_model.embed_documents(chunks)
+
+        # Generate embedding for the question
+        question_embedding = embeddings_model.embed_query(question)
+
+        # Find most relevant chunks using cosine similarity
+        similarities = []
+        for chunk_embedding in chunk_embeddings:
+            similarity = np.dot(question_embedding, chunk_embedding) / (
+                np.linalg.norm(question_embedding) * np.linalg.norm(chunk_embedding)
+            )
+            similarities.append(similarity)
+
+        # Get top 3 most relevant chunks
+        top_chunk_indices = np.argsort(similarities)[-3:][::-1]
+        relevant_chunks = [chunks[i] for i in top_chunk_indices]
+
+        # Construct prompt with relevant context
+        context = "\n\n".join(relevant_chunks)
+        prompt = f"""Based on the following relevant excerpts from the research paper, please answer this question: {question}
+
+        Context from paper:
+        {context}
+
+        Please provide a clear, specific, and accurate response based solely on the information provided in these excerpts. If the answer cannot be fully determined from the given context, please indicate this in your response."""
+
+        # Generate response using Groq
+        response = llm.invoke(prompt)
+
+        # Format and return response
+        formatted_response = response.content.strip()
+        
+        # Add source citations
+        source_info = "\n\nThis response is based on specific sections from the paper."
+        
+        return jsonify({
+            'response': formatted_response + source_info,
+            'relevance_scores': [float(similarities[i]) for i in top_chunk_indices]
+        })
+
+    except Exception as e:
+        print(f"Chat error: {str(e)}")
+        return jsonify({'error': f'Failed to process request: {str(e)}'}), 500
+
+@app.route('/api/data', methods=['GET'])
+def get_data():
+    try:
+        # Example: Get documents from a collection
+        docs = load_users()
+        data = [{doc_id: doc_data} for doc_id, doc_data in docs.items()]
+        return jsonify(data), 200
+    except Exception as e:
+        return jsonify({"error": str(e)}), 500
+
+# Add error handlers
+@app.errorhandler(404)
+def not_found_error(error):
+    logger.error(f'Page not found: {request.url}')
+    return render_template('404.html'), 404
+
+@app.errorhandler(500)
+def internal_error(error):
+    logger.error(f'Server Error: {error}')
+    return render_template('500.html'), 500
+
+@app.before_request
+def log_request_info():
+    logger.info(f'Request URL: {request.url}')
+    logger.info(f'Request Method: {request.method}')
+
+# Add cache control for static files
+@app.after_request
+def add_header(response):
+    if 'Cache-Control' not in response.headers:
+        response.headers['Cache-Control'] = 'no-store, no-cache, must-revalidate, post-check=0, pre-check=0, max-age=0'
+        response.headers['Pragma'] = 'no-cache'
+        response.headers['Expires'] = '-1'
+    return response
+
+# Serve static files with version parameter
+@app.context_processor
+def utility_processor():
+    def versioned_url(filename):
+        version = datetime.now().strftime("%Y%m%d%H%M%S")
+        return url_for('static', filename=filename, v=version)
+    return dict(versioned_url=versioned_url)
+
+if __name__ == '__main__':
+    port = int(os.environ.get('PORT', 7860))
+    debug = os.environ.get('DEBUG', 'False').lower() == 'true'
+    app.run(host='0.0.0.0', port=port, debug=debug)

auth_utils.py

@@ -0,0 +1,56 @@
+from firebase_admin import auth
+from typing import Dict, Optional
+
+def create_user(email: str, password: str) -> Dict:
+    """Create a new user with email and password"""
+    try:
+        user = auth.create_user(
+            email=email,
+            password=password,
+            email_verified=False
+        )
+        return {
+            "success": True,
+            "user_id": user.uid,
+            "email": user.email
+        }
+    except auth.EmailAlreadyExistsError:
+        return {
+            "success": False,
+            "error": "Email already exists"
+        }
+    except Exception as e:
+        return {
+            "success": False,
+            "error": str(e)
+        }
+
+def verify_token(id_token: str) -> Optional[Dict]:
+    """Verify Firebase ID token"""
+    try:
+        decoded_token = auth.verify_id_token(id_token)
+        return decoded_token
+    except Exception as e:
+        return None
+
+def get_user_by_email(email: str) -> Optional[Dict]:
+    """Get user by email"""
+    try:
+        user = auth.get_user_by_email(email)
+        return {
+            "user_id": user.uid,
+            "email": user.email,
+            "email_verified": user.email_verified
+        }
+    except auth.UserNotFoundError:
+        return None
+    except Exception:
+        return None
+
+def delete_user(uid: str) -> bool:
+    """Delete a user by UID"""
+    try:
+        auth.delete_user(uid)
+        return True
+    except Exception:
+        return False 

db_utils.py

@@ -0,0 +1,36 @@
+from firebase_admin import firestore
+from typing import Dict, List, Optional
+
+def add_user_data(db: firestore.Client, user_id: str, data: Dict) -> bool:
+    """Add user data to Firestore"""
+    try:
+        db.collection('users').document(user_id).set(data)
+        return True
+    except Exception:
+        return False
+
+def get_user_data(db: firestore.Client, user_id: str) -> Optional[Dict]:
+    """Get user data from Firestore"""
+    try:
+        doc = db.collection('users').document(user_id).get()
+        if doc.exists:
+            return doc.to_dict()
+        return None
+    except Exception:
+        return None
+
+def update_user_data(db: firestore.Client, user_id: str, data: Dict) -> bool:
+    """Update user data in Firestore"""
+    try:
+        db.collection('users').document(user_id).update(data)
+        return True
+    except Exception:
+        return False
+
+def delete_user_data(db: firestore.Client, user_id: str) -> bool:
+    """Delete user data from Firestore"""
+    try:
+        db.collection('users').document(user_id).delete()
+        return True
+    except Exception:
+        return False 

firebase_config.py

@@ -0,0 +1,14 @@
+import firebase_admin
+from firebase_admin import credentials, firestore, auth
+
+def initialize_firebase():
+    # Initialize Firebase Admin SDK
+    cred = credentials.Certificate('researchradarai-firebase-adminsdk-fbsvc-281fee7dee.json')
+    firebase_admin.initialize_app(cred, {
+        'projectId': 'researchradarai',
+        'storageBucket': 'researchradarai.firebasestorage.app'
+    })
+    
+    # Initialize Firestore client
+    db = firestore.client()
+    return db 

firestore.rules

@@ -0,0 +1,15 @@
+rules_version = '2';
+service cloud.firestore {
+  match /databases/{database}/documents {
+    // User profiles
+    match /users/{userId} {
+      allow read: if request.auth != null && request.auth.uid == userId;
+      allow write: if request.auth != null && request.auth.uid == userId;
+    }
+    
+    // Default deny
+    match /{document=**} {
+      allow read, write: if false;
+    }
+  }
+} 

init_db.py

@@ -0,0 +1 @@
+ 

requirements.txt

@@ -0,0 +1,24 @@
+flask
+flask-login
+flask-wtf
+werkzeug
+arxiv
+requests
+PyPDF2
+langchain
+langchain-groq
+langchain-community
+langchain-huggingface
+python-dotenv
+numpy
+sentence-transformers
+firebase-admin
+google-cloud-firestore
+google-auth
+google-auth-oauthlib
+google-auth-httplib2
+wtforms
+huggingface-hub
+transformers
+torch
+langchain_google_genai

researchradarai-firebase-adminsdk-fbsvc-281fee7dee.json

@@ -0,0 +1,13 @@
+{
+  "type": "service_account",
+  "project_id": "researchradarai",
+  "private_key_id": "281fee7dee23aa4df991aeffb650e418e51d08d0",
+  "private_key": "-----BEGIN PRIVATE KEY-----\nMIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQCfvkAA+uP5qyW3\nBPd9l5767K73DdRV60NBzygv9O9PjSDHCTIqpVdOMXwWSO8E4+9O5R013Dg8bVTm\ncMAZB+HnrBEWoYHFu7Jqzh0KI+WVejFlZ0rkYcekOfZ0sG43meIq9pFm8ehsIz/k\nC2Ow7FFeEd0b493oqvV3wF9c8u9l5jZVgbU7J8nyo3K638v+V22D+BPmgHEksbk2\nEiyHsypcDZmSV6woo8SCrh2vs2vSCHvqx05X6f0MxRBcmtZS6WcJJ+vvntktilpc\n+Q3hoPYLmMXwaZCaaujU12uKHYudGCrZf5PXVsPplSd63ztW2smw1oEDgYwuoxON\nmbqJwnZ9AgMBAAECggEAFI7qiSBriJfdzGESQj0/fkb0TuKeah79/TveOIB1mq+s\nq+Y4vkOgfyAKj9+mYI2+daaHjNqg+NM6nZxId1rhWEHNF97Z5wsR74GZO9MvhSjr\nBIQ3n47J9Q5p883k/A43jOnwqpFaz9f1grFzN14igVBxPAP7wimGWnlijIF4t+H6\n4HVxXCmhzz3IZcZYUKX//jg6r5lpFIVxZK5cIWDhmf9sKlD6GUR+3gKr7MQpzRJx\nsOfYbBe+KbHN0azSMNyKFNUvsDXUmGVTpjqun7Zuw9XUe6GyCM4WC9mN8+IPTZqm\n6AjnSgp9JUwZ+tJjuUo1ZSFblS2iNflUpioLsMbIDQKBgQDecLqA1vxY6+VW4v8M\n3+TuNEUe96LZA/ypLoBi07GhncxN9g2LuWnRpDyiZmbey3UQmFk/QrUem/j0UNzY\nYfLcfuE5UmXFUeySS+jJfjqvXp+996zYfSYVbOEba1QJjBPcOFsaXlk2AP0cWv36\nFRWF/Iug4kbX+JGyK+LvGQEaHwKBgQC31/rmW5m7XNA61gtbtK5Fg6KKBJB/27YL\n7aLSOEUmMYgfRiLB666y+4jdZDA3EkjKX88ddiVuoVyZuDGTsr0/ifG8hGOoSw0u\nvbykMBezPLPRkQyD1TBiErxBXa++WyNaHLEJFymCOCja7Xvxc141U8pSnKUGmUr1\nr/sxTCgT4wKBgF4It78poyoQJzaQ5ZNSvxu3+xR5SV2GovP+VYXxyiDxbWHzx4wu\nyL44OO3Kbmh3CDkIvonQsHKNKzRVTtcmqR1vgdTSsXU2CdVaw8ESXMqwLMWJA4fN\neCEMkykdOTyD/A1XwaOnCP2cc2PeT4m+CghHV9uebKZ2TVlN1jSPlHivAoGBAI14\nppqd4q9LvPGJxTPM1k6n/Ww4FvpNGMoVFDaxFoVNmHJ4hka0Fruk1K2Ja5D1gQ46\nrCb/w85eXePs2jnOUdOTU3K+bfITzxEo8QFoANTs4XNjKz5Hz/OodzXV4meZupqd\neZ6FNGwAy2+tULN9FAH1eLwZzuRFEmn+Ak7tS+oBAoGANo1QB4ZTX6NNBaz8zdGX\ngClsWRCY1wKg7bK87bnwv9u7nSyh+7ud7pjA9Km06kFSUrgEKiFS8IensxRwaE3T\ndteGp/+bOwkCIQW3w8d7bG7SiZuJ1UWoaJC7vN+eHaUSDM9+OzaK9cjWZDf0O/6D\nsxlQDuwbqOFEa/MGqZr8ZqU=\n-----END PRIVATE KEY-----\n",
+  "client_email": "[email protected]",
+  "client_id": "114293117382677247598",
+  "auth_uri": "https://accounts.google.com/o/oauth2/auth",
+  "token_uri": "https://oauth2.googleapis.com/token",
+  "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
+  "client_x509_cert_url": "https://www.googleapis.com/robot/v1/metadata/x509/firebase-adminsdk-fbsvc%40researchradarai.iam.gserviceaccount.com",
+  "universe_domain": "googleapis.com"
+}

text.txt

@@ -0,0 +1,404 @@
+from flask import Flask, render_template, request, jsonify, redirect, url_for, flash, session
+from flask_login import LoginManager, UserMixin, login_user, login_required, logout_user, current_user
+from flask_wtf.csrf import CSRFProtect
+from flask_wtf import FlaskForm
+from wtforms import StringField, PasswordField, SubmitField
+from wtforms.validators import DataRequired
+from werkzeug.security import generate_password_hash, check_password_hash
+import arxiv
+import requests
+import PyPDF2
+from io import BytesIO
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain_groq import ChatGroq
+from langchain.memory import ConversationBufferMemory
+from langchain_community.embeddings import HuggingFaceEmbeddings
+import numpy as np
+from concurrent.futures import ThreadPoolExecutor, TimeoutError
+from functools import lru_cache
+import time
+import os
+from dotenv import load_dotenv
+import json
+from datetime import datetime
+from flask_sqlalchemy import SQLAlchemy
+from config import Config
+
+# Load environment variables
+load_dotenv()
+
+# Initialize Flask extensions
+db = SQLAlchemy()
+login_manager = LoginManager()
+
+def create_app():
+    app = Flask(__name__)
+    app.config.from_object(Config)
+
+    # Initialize extensions
+    db.init_app(app)
+    login_manager.init_app(app)
+    login_manager.login_view = 'login'
+
+    with app.app_context():
+        # Import routes after db initialization
+        from routes import init_routes
+        init_routes(app)
+
+        # Create database tables
+        db.create_all()
+        
+        # Test database connection
+        try:
+            version = db.session.execute('SELECT VERSION()').scalar()
+            print(f"Connected to PostgreSQL: {version}")
+        except Exception as e:
+            print(f"Database connection error: {str(e)}")
+            raise e
+
+    return app
+
+# Initialize CSRF protection
+csrf = CSRFProtect()
+csrf.init_app(app)
+
+# Initialize Groq
+groq_api_key = os.getenv('GROQ_API_KEY')
+llm = ChatGroq(
+    temperature=0.1,
+    groq_api_key=groq_api_key,
+    model_name="mixtral-8x7b-32768"
+)
+
+# Initialize embeddings
+embeddings_model = HuggingFaceEmbeddings(
+    model_name="sentence-transformers/all-MiniLM-L6-v2"
+)
+
+# Constants
+MAX_CHUNKS = 50
+MAX_RESPONSE_LENGTH = 4000
+CACHE_DURATION = 3600  # 1 hour in seconds
+
+# Form Classes
+class LoginForm(FlaskForm):
+    username = StringField('Username', validators=[DataRequired()])
+    password = PasswordField('Password', validators=[DataRequired()])
+    submit = SubmitField('Login')
+
+class RegisterForm(FlaskForm):
+    username = StringField('Username', validators=[DataRequired()])
+    password = PasswordField('Password', validators=[DataRequired()])
+    submit = SubmitField('Register')
+
+# User class
+class User(UserMixin):
+    def __init__(self, user_id, username):
+        self.id = user_id
+        self.username = username
+
+    @staticmethod
+    def get(user_id):
+        users = load_users()
+        user_data = users.get(str(user_id))
+        if user_data:
+            return User(user_id=user_data['id'], username=user_data['username'])
+        return None
+
+# User management functions
+def load_users():
+    try:
+        with open('users.json', 'r') as f:
+            return json.load(f)
+    except FileNotFoundError:
+        return {}
+
+def save_users(users):
+    with open('users.json', 'w') as f:
+        json.dump(users, f)
+
+@login_manager.user_loader
+def load_user(user_id):
+    return User.get(user_id)
+
+# PDF Processing and Analysis
+def process_pdf(pdf_url):
+    try:
+        print(f"Starting PDF processing for: {pdf_url}")
+        
+        response = requests.get(pdf_url, timeout=30)
+        response.raise_for_status()
+        pdf_file = BytesIO(response.content)
+
+        pdf_reader = PyPDF2.PdfReader(pdf_file)
+        # Clean and normalize the text
+        text = " ".join(
+            page.extract_text().encode('ascii', 'ignore').decode('ascii')
+            for page in pdf_reader.pages
+        )
+        
+        if not text.strip():
+            return {'error': 'No text could be extracted from the PDF'}
+
+        text_splitter = RecursiveCharacterTextSplitter(
+            chunk_size=1000,
+            chunk_overlap=200,
+            length_function=len,
+            separators=["\n\n", "\n", " ", ""]
+        )
+        
+        chunks = text_splitter.split_text(text)[:MAX_CHUNKS]
+        
+        analysis = generate_analysis(chunks)
+        return {
+            'success': True,
+            'analysis': analysis
+        }
+            
+    except Exception as e:
+        return {'error': f"PDF processing failed: {str(e)}"}
+
+def generate_analysis(chunks):
+    analysis_prompts = {
+        'executive_summary': "Provide a concise executive summary of this research paper.",
+        'problem_analysis': "What is the main research problem and objectives?",
+        'methodology': "Describe the key methodology and approach.",
+        'findings': "What are the main findings and conclusions?",
+        'contributions': "What are the key contributions of this work?"
+    }
+    
+    analysis_results = {}
+    
+    for aspect, prompt in analysis_prompts.items():
+        try:
+            # Clean and join the chunks
+            context = "\n\n".join(
+                chunk.encode('ascii', 'ignore').decode('ascii')
+                for chunk in chunks[:3]
+            )
+            response = llm.invoke(
+                f"""Based on the following context from a research paper, {prompt}
+                
+                Context:
+                {context}
+                
+                Please provide a clear and specific response."""
+            )
+            analysis_results[aspect] = response.content[:MAX_RESPONSE_LENGTH]
+        except Exception as e:
+            analysis_results[aspect] = f"Analysis failed: {str(e)}"
+    
+    return analysis_results
+
+# Routes
+@app.route('/')
+@login_required
+def index():
+    return render_template('index.html')
+
+@app.route('/login', methods=['GET', 'POST'])
+def login():
+    if current_user.is_authenticated:
+        return redirect(url_for('index'))
+        
+    form = LoginForm()
+    if form.validate_on_submit():
+        username = form.username.data
+        password = form.password.data
+        
+        users = load_users()
+        user_found = None
+        
+        for user_id, user_data in users.items():
+            if user_data['username'] == username:
+                user_found = user_data
+                break
+                
+        if user_found and check_password_hash(user_found['password_hash'], password):
+            user = User(user_id=user_found['id'], username=username)
+            login_user(user, remember=True)
+            return redirect(url_for('index'))
+            
+        flash('Invalid username or password')
+    
+    return render_template('login.html', form=form)
+
+@app.route('/register', methods=['GET', 'POST'])
+def register():
+    if current_user.is_authenticated:
+        return redirect(url_for('index'))
+        
+    form = RegisterForm()
+    if form.validate_on_submit():
+        username = form.username.data
+        password = form.password.data
+        
+        users = load_users()
+        
+        if any(user['username'] == username for user in users.values()):
+            flash('Username already exists')
+            return render_template('register.html', form=form)
+            
+        user_id = str(len(users) + 1)
+        users[user_id] = {
+            'id': user_id,
+            'username': username,
+            'password_hash': generate_password_hash(password)
+        }
+        
+        save_users(users)
+        
+        user = User(user_id=user_id, username=username)
+        login_user(user)
+        
+        return redirect(url_for('index'))
+        
+    return render_template('register.html', form=form)
+
+@app.route('/logout')
+@login_required
+def logout():
+    logout_user()
+    return redirect(url_for('login'))
+
+@app.route('/search', methods=['POST'])
+@login_required
+def search():
+    try:
+        data = request.get_json()
+        paper_name = data.get('paper_name')
+        sort_by = data.get('sort_by', 'relevance')
+        max_results = data.get('max_results', 10)
+
+        if not paper_name:
+            return jsonify({'error': 'No search query provided'}), 400
+
+        # Map sort_by to arxiv.SortCriterion
+        sort_mapping = {
+            'relevance': arxiv.SortCriterion.Relevance,
+            'lastUpdated': arxiv.SortCriterion.LastUpdatedDate,
+            'submitted': arxiv.SortCriterion.SubmittedDate
+        }
+        sort_criterion = sort_mapping.get(sort_by, arxiv.SortCriterion.Relevance)
+
+        # Perform the search
+        search = arxiv.Search(
+            query=paper_name,
+            max_results=max_results,
+            sort_by=sort_criterion
+        )
+
+        results = []
+        for paper in search.results():
+            results.append({
+                'title': paper.title,
+                'authors': ', '.join(author.name for author in paper.authors),
+                'abstract': paper.summary,
+                'pdf_link': paper.pdf_url,
+                'arxiv_link': paper.entry_id,
+                'published': paper.published.strftime('%Y-%m-%d'),
+                'category': paper.primary_category,
+                'comment': paper.comment if hasattr(paper, 'comment') else None,
+                'doi': paper.doi if hasattr(paper, 'doi') else None
+            })
+
+        return jsonify(results)
+
+    except Exception as e:
+        print(f"Search error: {str(e)}")
+        return jsonify({'error': f'Failed to search papers: {str(e)}'}), 500
+
+@app.route('/perform-rag', methods=['POST'])
+@login_required
+def perform_rag():
+    try:
+        pdf_url = request.json.get('pdf_url')
+        if not pdf_url:
+            return jsonify({'error': 'PDF URL is required'}), 400
+
+        result = process_pdf(pdf_url)
+        
+        if 'error' in result:
+            return jsonify({'error': result['error']}), 500
+            
+        return jsonify(result)
+
+    except Exception as e:
+        return jsonify({'error': str(e)}), 500
+
+@app.route('/chat-with-paper', methods=['POST'])
+@login_required
+def chat_with_paper():
+    try:
+        pdf_url = request.json.get('pdf_url')
+        question = request.json.get('question')
+        
+        if not pdf_url or not question:
+            return jsonify({'error': 'PDF URL and question are required'}), 400
+
+        # Get PDF text and create chunks
+        response = requests.get(pdf_url, timeout=30)
+        response.raise_for_status()
+        pdf_file = BytesIO(response.content)
+
+        pdf_reader = PyPDF2.PdfReader(pdf_file)
+        text = " ".join(page.extract_text() for page in pdf_reader.pages)
+        
+        if not text.strip():
+            return jsonify({'error': 'No text could be extracted from the PDF'})
+
+        # Create text chunks
+        text_splitter = RecursiveCharacterTextSplitter(
+            chunk_size=1000,
+            chunk_overlap=200,
+            length_function=len
+        )
+        chunks = text_splitter.split_text(text)[:MAX_CHUNKS]
+
+        # Generate embeddings for chunks
+        chunk_embeddings = embeddings_model.embed_documents(chunks)
+
+        # Generate embedding for the question
+        question_embedding = embeddings_model.embed_query(question)
+
+        # Find most relevant chunks using cosine similarity
+        similarities = []
+        for chunk_embedding in chunk_embeddings:
+            similarity = np.dot(question_embedding, chunk_embedding) / (
+                np.linalg.norm(question_embedding) * np.linalg.norm(chunk_embedding)
+            )
+            similarities.append(similarity)
+
+        # Get top 3 most relevant chunks
+        top_chunk_indices = np.argsort(similarities)[-3:][::-1]
+        relevant_chunks = [chunks[i] for i in top_chunk_indices]
+
+        # Construct prompt with relevant context
+        context = "\n\n".join(relevant_chunks)
+        prompt = f"""Based on the following relevant excerpts from the research paper, please answer this question: {question}
+
+        Context from paper:
+        {context}
+
+        Please provide a clear, specific, and accurate response based solely on the information provided in these excerpts. If the answer cannot be fully determined from the given context, please indicate this in your response."""
+
+        # Generate response using Groq
+        response = llm.invoke(prompt)
+
+        # Format and return response
+        formatted_response = response.content.strip()
+        
+        # Add source citations
+        source_info = "\n\nThis response is based on specific sections from the paper."
+        
+        return jsonify({
+            'response': formatted_response + source_info,
+            'relevance_scores': [float(similarities[i]) for i in top_chunk_indices]
+        })
+
+    except Exception as e:
+        print(f"Chat error: {str(e)}")
+        return jsonify({'error': f'Failed to process request: {str(e)}'}), 500
+
+if __name__ == '__main__':
+    app.run(debug=True)

users.json

@@ -0,0 +1 @@
+{"1": {"id": "1", "username": "vinit", "password_hash": "scrypt:32768:8:1$eMBXSaH1nm6rZx3c$31f72052845c5c5c67006aa4cf8b29231560bbc67acd56ec4261f655a04b91719579b808d9ed31d73995e13e1f9cf535a04ed528fb1af67b58df8aaf86ab415d"}, "2": {"id": "2", "username": "tavde", "password_hash": "scrypt:32768:8:1$RgIBXfJjYPp20gLj$c62da6c0d894fa04998d666b7944f94c27125d5983a71cf4b57624b8a99e4ada4bad85fcc56ff4e9d08be218af842971d93c07d1c8e89fad60b57aea56dbc587"}, "3": {"id": "3", "username": "divax.shah", "password_hash": "scrypt:32768:8:1$TqaCWPWa9h5yvQzv$0ea4dd33e2dc026f471e24d1f94ed3ed6381400c5d1dfcf099ea66cf32d7c81a4bef0b0e143d1b797e655e9e6cec460a9b2277ec5157efbfc95f0714e4d2377e"}, "4": {"id": "4", "username": "vidhi", "password_hash": "scrypt:32768:8:1$bUMFGywKUGvXpwW4$f3dada6114fa257d4ff7f08906b08d55f2a656d61f4bc6399504c05b03a353d6a2856fae2bc598b848c2b6a41cf82ab64679429b7a8b35680072ad29e3e528b0"}}