server v2

.env.example

@@ -1,99 +0,0 @@
-# ========================================
-# YouTube Study Notes AI - Environment Configuration
-# ========================================
-
-# ----------------------------------------
-# Google Gemini API
-# ----------------------------------------
-# Get your API key from: https://makersuite.google.com/app/apikey
-GOOGLE_API_KEY=AIzaSyD_wHludyQbdlNk9rTvitwV1lWkJPqoYbE
-
-# ----------------------------------------
-# Database Configuration (Supabase PostgreSQL)
-# ----------------------------------------
-# Format: postgresql+asyncpg://[user]:[password]@[host]:[port]/[database]
-# 
-# For Supabase:
-# 1. Go to your Supabase project dashboard
-# 2. Navigate to Settings > Database
-# 3. Under "Connection string", select "URI" mode
-# 4. Copy the connection string and replace "postgresql://" with "postgresql+asyncpg://"
-# 
-# Example:
-# DATABASE_URL=postgresql+asyncpg://postgres.[your-project-ref]:[your-password]@aws-0-us-east-1.pooler.supabase.com:5432/postgres
-#6SsbAvgkhJTEl2CS
-# postgresql://postgres:[YOUR-PASSWORD]@db.jqjjanimclxplgvoiwyk.supabase.co:5432/postgres
-# DATABASE_URL="postgresql+asyncpg://postgres.jqjjanimclxplgvoiwyk:AliProject2026@aws-1-eu-west-1.pooler.supabase.com:6543/postgres?ssl=require"
-
-DATABASE_URL="postgresql+asyncpg://postgres.mupnxzgkcdmwhojmhxdh:6SsbAvgkhJTEl2CS@aws-1-eu-west-1.pooler.supabase.com:6543/postgres?ssl=require"
- 
-# ----------------------------------------
-# Authentication & Security
-# ----------------------------------------
-# Generate a secure secret key with: python -c "import secrets; print(secrets.token_urlsafe(32))"
-SECRET_KEY=5j55fk-ljD_Urkih0dvZ11WQ0iTYwwjPyQ7N7Un0eDY
-ACCESS_TOKEN_EXPIRE_MINUTES=60
-ALGORITHM=HS256
-
-# ----------------------------------------
-# API Server Configuration
-# ----------------------------------------
-
-# 192.168.1.101
-API_HOST=0.0.0.0
-API_PORT=8000
-
-# ----------------------------------------
-# Whisper Model Configuration
-# ----------------------------------------
-# Options: tiny, base, small, medium, large
-# Larger models are more accurate but slower
-WHISPER_MODEL_SIZE=base
-
-# ----------------------------------------
-# Processing Limits
-# ----------------------------------------
-# Maximum video duration in seconds (2 hours = 7200)
-MAX_VIDEO_DURATION=7200
-
-# ----------------------------------------
-# Output Configuration
-# ----------------------------------------
-OUTPUT_FORMAT=markdown
-OUTPUT_DIR=outputs
-
-# ----------------------------------------
-# Logging
-# ----------------------------------------
-LOG_LEVEL=INFO
-LOG_FILE=app.log
-
-# ----------------------------------------
-# IMPORTANT NOTES FOR SUPABASE SETUP
-# ----------------------------------------
-# 
-# After creating your Supabase project:
-# 
-# 1. DATABASE_URL Setup:
-#    - Go to Project Settings > Database
-#    - Find "Connection string" section
-#    - Select "URI" mode
-#    - Copy the connection string
-#    - Replace "postgresql://" with "postgresql+asyncpg://"
-#    - Replace [YOUR-PASSWORD] with your actual database password
-#
-# 2. Security:
-#    - NEVER commit this .env file to version control
-#    - Add .env to your .gitignore file
-#    - Generate a strong SECRET_KEY for production
-#
-# 3. Connection Pooling:
-#    - Supabase provides connection pooling by default
-#    - Use the "pooler" connection string for better performance
-#    - Example: aws-0-us-east-1.pooler.supabase.com
-#
-# 4. SSL Mode:
-#    - Supabase requires SSL connections (enabled by default with asyncpg)
-#    - If you encounter SSL errors, you can disable verification (NOT RECOMMENDED for production):
-#      DATABASE_URL=postgresql+asyncpg://...?ssl=require
-#

.gitattributes

@@ -1,35 +0,0 @@
-*.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

.gitignore

@@ -0,0 +1,40 @@
+# Ignore environment file with secrets
+.env
+firebase-service-account.json
+serviceAccountKey.json
+
+# Ignore Python cache
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+
+# Ignore virtual environments
+venv/
+env/
+ENV/
+
+# Ignore temporary files
+temp/*
+!temp/.gitkeep
+
+# Ignore output files
+outputs/*
+!outputs/.gitkeep
+
+# Ignore logs
+*.log
+
+# Ignore OS files
+.DS_Store
+Thumbs.db
+
+# Ignore IDE files
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# Ignore downloaded models (Whisper caches)
+~/.cache/whisper/

.python-version

@@ -0,0 +1 @@
+3.14

Dockerfile

@@ -15,6 +15,7 @@ RUN apt-get update && apt-get install -y \
 WORKDIR /app
 
 # Install Python dependencies
+# We copy requirements first to leverage Docker cache
 COPY requirements.txt .
 RUN pip install --no-cache-dir -r requirements.txt
 
@@ -24,5 +25,5 @@ COPY . .
 # Hugging Face Spaces expects the app to run on port 7860
 EXPOSE 7860
 
-# Run the application
-CMD ["python", "app.py"]
+# Run the application using the entry point we created
+CMD ["python", "app.py","server"]

README.md

@@ -1,16 +0,0 @@
----
-title: AIdea Note Generator
-emoji: 📝
-colorFrom: blue
-colorTo: purple
-sdk: docker
-app_file: app.py
-pinned: false
----
-
-# YouTube Study Notes AI
-
-![Python](https://img.shields.io/badge/python-3.8+-blue.svg)
-![License](https://img.shields.io/badge/license-MIT-green.svg)
-
-An intelligent AI system that automatically generates structured study notes from YouTube educational videos using speech recognition and large language models.

check_models.py

@@ -0,0 +1,24 @@
+import google.generativeai as genai
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+api_key = os.getenv("GOOGLE_API_KEY")
+
+if not api_key:
+    print("❌Can't find the key.env")
+else:
+    genai.configure(api_key=api_key)
+    print("🔍 Searching for available models...")
+    try:
+        found = False
+        for m in genai.list_models():
+            if "generateContent" in m.supported_generation_methods:
+                print(f"✅ Available: {m.name}")
+                found = True
+        if not found:
+            print("⚠️ No models found that support text generation.")
+    except Exception as e:
+        print(f"❌ An error occurred: {e}")
+
+input("\nPress Enter to exit...")

examples/sample_output.md

@@ -0,0 +1,105 @@
+# Introduction to Neural Networks
+
+**Source:** [https://youtube.com/watch?v=example](https://youtube.com/watch?v=example)  
+**Duration:** 18:45  
+**Generated:** AI Study Notes
+
+---
+
+# Introduction to Neural Networks
+
+## What is a Neural Network?
+
+- **Artificial Neural Network (ANN)**: A computing system inspired by biological neural networks
+- Composed of interconnected nodes (neurons) organized in layers
+- learns to perform tasks by considering examples without task-specific programming
+- **Key components**:
+  - Input layer: Receives initial data
+  - Hidden layers: Process information
+  - Output layer: Produces final results
+
+## Basic Architecture
+
+- **Neurons**: Basic computational units that receive input and produce output
+- **Weights**: Parameters that determine the strength of connections
+- **Bias**: Additional parameter to adjust the output
+- **Activation Function**: Introduces non-linearity to the network
+  - Common functions: ReLU, Sigmoid, Tanh
+
+## How Neural Networks Learn
+
+- **Training Process**: Iterative adjustment of weights and biases
+- **Forward Propagation**: 
+  - Input data flows through the network
+  - Each neuron applies weights and activation function
+  - Output is computed at the end
+  
+- **Backpropagation**:
+  - Compare output with expected result
+  - Calculate error/loss
+  - Propagate error backwards through network
+  - Update weights using gradient descent
+
+## Training Components
+
+- **Loss Function**: Measures how far predictions are from actual values
+  - Mean Squared Error (MSE) for regression
+  - Cross-Entropy for classification
+  
+- **Optimizer**: Algorithm to update weights
+  - **Gradient Descent**: Basic optimization method
+  - **Adam**: Adaptive learning rate optimizer (popular choice)
+  - **SGD**: Stochastic Gradient Descent
+
+## Common Applications
+
+- **Image Recognition**: Identifying objects in photos
+- **Natural Language Processing**: Understanding and generating text
+- **Speech Recognition**: Converting audio to text
+- **Game Playing**: Learning to play games through reinforcement
+- **Recommendation Systems**: Suggesting content based on preferences
+
+## Deep Learning
+
+- **Definition**: Neural networks with multiple hidden layers (deep networks)
+- More layers enable learning of hierarchical features
+- **Examples**:
+  - Convolutional Neural Networks (CNN): For image processing
+  - Recurrent Neural Networks (RNN): For sequential data
+  - Transformers: For language understanding
+
+## Key Concepts
+
+- **Overfitting**: Model learns training data too well, poor generalization
+  - Solution: Regularization, dropout, more data
+  
+- **Underfitting**: Model too simple to capture patterns
+  - Solution: More complex model, more features
+  
+- **Hyperparameters**: Settings configured before training
+  - Learning rate
+  - Number of layers
+  - Number of neurons per layer
+  - Batch size
+
+## Training Best Practices
+
+- Start with a simple architecture
+- Use appropriate activation functions
+- Normalize input data
+- Split data into training, validation, and test sets
+- Monitor training and validation loss
+- Use regularization techniques to prevent overfitting
+- Experiment with different optimizers and learning rates
+
+## Challenges
+
+- Requires large amounts of data
+- Computationally expensive (GPU recommended)
+- Can be difficult to interpret ("black box")
+- Choosing right architecture requires experience
+- Risk of overfitting with complex models
+
+## Summary
+
+Neural networks are powerful machine learning models that can learn complex patterns from data. They consist of layers of interconnected neurons that process information through weighted connections. Through the process of forward propagation and backpropagation, the network learns to minimize errors and make accurate predictions. While they require significant computational resources and data, they have revolutionized fields like computer vision, natural language processing, and many other domains of artificial intelligence.

get_ffmpeg.py

@@ -0,0 +1,48 @@
+import os
+import zipfile
+import urllib.request
+import sys
+
+# Direct download URL
+url = "https://www.gyan.dev/ffmpeg/builds/ffmpeg-release-essentials.zip"
+zip_filename = "ffmpeg_temp.zip"
+
+def progress_bar(block_num, block_size, total_size):
+    downloaded = block_num * block_size
+    if total_size > 0:
+        percent = downloaded * 100 / total_size
+        sys.stdout.write(f"\r⏳ Downloading: {percent:.1f}% ({downloaded / (1024*1024):.1f} MB)")
+        sys.stdout.flush()
+
+print("🚀 Starting FFmpeg download (approx 130MB)...")
+
+try:
+    # 1. Download with progress bar
+    urllib.request.urlretrieve(url, zip_filename, progress_bar)
+    print("\n\n📦 Download complete! Extracting files...")
+
+    # 2. Extract specific files
+    with zipfile.ZipFile(zip_filename, 'r') as z:
+        count = 0
+        for filename in z.namelist():
+            if filename.endswith("bin/ffmpeg.exe") or filename.endswith("bin/ffprobe.exe"):
+                target_name = os.path.basename(filename)
+                print(f"   Extracting -> {target_name}")
+                with open(target_name, "wb") as f:
+                    f.write(z.read(filename))
+                count += 1
+    
+    # 3. Cleanup
+    if os.path.exists(zip_filename):
+        os.remove(zip_filename)
+
+    if count == 2:
+        print("\n✅ Success! FFmpeg installed successfully.")
+        print("You can now run: python run.py server")
+    else:
+        print("\n⚠️ Warning: Could not find ffmpeg files in the zip.")
+
+except Exception as e:
+    print(f"\n❌ Error occurred: {e}")
+
+input("\nPress Enter to exit...")

outputs/.gitkeep

@@ -0,0 +1,2 @@
+# Outputs directory
+# Generated study notes will be saved here

packages.txt

@@ -1 +0,0 @@
-ffmpeg

pyproject.toml

@@ -0,0 +1,34 @@
+[project]
+name = "program"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.14"
+dependencies = [
+    "aiofiles==23.2.1",
+    "asyncpg==0.31.0",
+    "bcrypt==4.1.2",
+    "email-validator>=2.3.0",
+    "fastapi==0.109.0",
+    "google-api-python-client==2.115.0",
+    "google-genai>=1.2.0",
+    "google-generativeai==0.3.2",
+    "greenlet==3.3.1",
+    "httpx==0.26.0",
+    "langchain==0.1.0",
+    "langchain-google-genai==0.0.5",
+    "openai-whisper==20250625",
+    "passlib[bcrypt]==1.7.4",
+    "pydantic-core==2.41.5",
+    "pydantic-settings==2.1.0",
+    "pydantic[email]==2.12.5",
+    "pydub==0.25.1",
+    "python-dotenv==1.0.0",
+    "python-jose[cryptography]==3.3.0",
+    "python-multipart==0.0.6",
+    "sqlmodel==0.0.14",
+    "torch>=2.10.0",
+    "torchaudio>=2.10.0",
+    "uvicorn[standard]==0.27.0",
+    "yt-dlp==2024.12.23",
+]

requirements.txt

@@ -26,3 +26,4 @@ bcrypt==4.1.2
 google-api-python-client==2.115.0
 pydantic-core==2.41.5
 ffmpeg-python
+firebase-admin==6.5.0

run.py

@@ -3,11 +3,11 @@ Main entry point for YouTube Study Notes AI.
 Provides CLI interface and server startup.
 """
 
+import os
 import sys
 import argparse
 from pathlib import Path
 
-# Import necessary modules for server and middleware
 from src.utils.logger import setup_logger
 from src.utils.config import settings
 

src/ai_modules/README.md

@@ -1,137 +0,0 @@
-# AI Modules Overview 🤖
-
-## Overview of AI Modules
-
-This directory contains all AI-related modules in the project, divided into 4 main components:
-
-## The Four Modules
-
-### 1. 🎤 Transcription
-**Responsibility:** Convert YouTube videos to written text.
-
-**Files:**
-- `audio_downloader.py` - Download audio from YouTube
-- `whisper_transcriber.py` - Convert audio to text using Whisper
-- `audio_processor.py` - Process and validate audio file quality
-
-**Technologies:** OpenAI Whisper, yt-dlp, PyTorch
-
----
-
-### 2. 📝 Summarization
-**Responsibility:** Convert text to organized study notes.
-
-**Files:**
-- `note_generator.py` - Generate notes using Gemini
-- `schemas.py` - Define data structure
-- `segmenter.py` - Split long texts
-
-**Technologies:** Google Gemini, Pydantic
-
----
-
-### 3. 🎯 Recommendation
-**Responsibility:** Suggest new educational videos to users.
-
-**Files:**
-- `recommender.py` - Search YouTube and analyze interests
-
-**Technologies:** YouTube Data API v3
-
----
-
-### 4. 🏷️ Categorization
-**Responsibility:** Automatically categorize notes.
-
-**Files:**
-- `categorizer.py` - Categorize text using AI
-
-**Technologies:** Google Gemini
-
----
-
-## Complete Workflow (Full Pipeline)
-
-```mermaid
-graph LR
-    A[YouTube URL] --> B[Transcription]
-    B --> C[Summarization]
-    C --> D[Categorization]
-    D --> E[Database]
-    E --> F[Recommendation]
-    F --> G[New Videos]
-```
-
-1. **User enters YouTube URL** → Transcription module
-2. **Audio is downloaded and converted to text** → Summarization module
-3. **Text is summarized and organized** → Categorization module
-4. **Summary is categorized** → Database
-5. **Based on saved notes** → Recommendation module
-6. **New videos are suggested** → User
-
----
-
-## For Team Members: How to Start?
-
-### If you're responsible for Transcription:
-1. Open `transcription/` directory
-2. Read the `README.md` file inside
-3. Test the code using the provided examples
-4. Develop the proposed features
-
-### If you're responsible for Summarization:
-1. Open `summarization/` directory
-2. Read the `README.md` file
-3. Try modifying the prompts to improve summary quality
-4. Add new features (like translation)
-
-### If you're responsible for Recommendation:
-1. Open `recommendation/` directory
-2. Read the `README.md` file
-3. Develop caching mechanism to save API quota
-4. Improve recommendation accuracy
-
-### If you're responsible for Categorization:
-1. Open `categorization/` directory
-2. Read the `README.md` file
-3. Add a predefined list of categories
-4. Improve the prompt to increase accuracy
-
----
-
-## General Notes
-
-### Shared Libraries
-All modules use:
-- `src.utils.logger` - For logging
-- `src.utils.config` - For reading settings from `.env`
-
-### Testing
-To test any module, use:
-```bash
-cd D:\faculty\Class4\grad\program
-python -m pytest tests/
-```
-
-### Required Environment
-Make sure to install the libraries:
-```bash
-pip install -r requirements.txt
-```
-
-### Required Environment Variables
-In `.env` file:
-```
-GOOGLE_API_KEY=your_google_api_key_here
-WHISPER_MODEL_SIZE=base
-DATABASE_URL=your_database_url
-```
-
----
-
-## Team Communication
-- If you encounter a problem in a specific module, **open an Issue** on GitHub.
-- If you add a new feature, **update the README** file for that module.
-- Before committing, make sure the code runs without errors.
-
-**Good luck to the team! 🚀**

src/api/auth_routes.py

@@ -10,7 +10,7 @@ from pydantic import BaseModel, EmailStr, Field
 from sqlmodel import select
 from sqlmodel.ext.asyncio.session import AsyncSession
 
-from src.db.database import get_session
+from src.db.firebase import get_firebase_db
 from src.db.models import User
 from src.auth.security import hash_password, verify_password, create_access_token
 from src.utils.logger import setup_logger
@@ -44,7 +44,7 @@ class SignupRequest(BaseModel):
 class UserResponse(BaseModel):
     """Response model for user data (without password)."""
 
-    id: int
+    id: str
     email: str
     username: str
     role: str
@@ -55,7 +55,7 @@ class UserResponse(BaseModel):
     class Config:
         json_schema_extra = {
             "example": {
-                "id": 1,
+                "id": "abc-123",
                 "email": "student@example.com",
                 "username": "Student123",
                 "role": "user",
@@ -85,19 +85,22 @@ class TokenResponse(BaseModel):
     "/signup", response_model=UserResponse, status_code=status.HTTP_201_CREATED
 )
 async def signup(
-    signup_data: SignupRequest, session: AsyncSession = Depends(get_session)
+    signup_data: SignupRequest
 ):
     """
-    Register a new user.
+    Register a new user using Firestore.
     """
-    # Check if email or username already exists
-    statement = select(User).where(
-        (User.email == signup_data.email) | (User.username == signup_data.username)
-    )
-    result = await session.exec(statement)
-    existing_user = result.first()
+    db = get_firebase_db()
+    if db is None:
+         raise HTTPException(status_code=500, detail="Firebase not configured")
 
-    if existing_user:
+    # Check if email or username already exists
+    users_ref = db.collection("users")
+    
+    email_check = users_ref.where("email", "==", signup_data.email).limit(1).stream()
+    username_check = users_ref.where("username", "==", signup_data.username).limit(1).stream()
+    
+    if next(email_check, None) or next(username_check, None):
         raise HTTPException(
             status_code=status.HTTP_409_CONFLICT,
             detail="Email or Username already registered",
@@ -106,53 +109,63 @@ async def signup(
     # Create new user with hashed password
     hashed_password_value = hash_password(signup_data.password)
 
-    new_user = User(
+    user_dict = {
+        "email": signup_data.email,
+        "username": signup_data.username,
+        "password_hash": hashed_password_value,
+        "role": "user",
+        "age": signup_data.age,
+        "gender": signup_data.gender,
+        "created_at": datetime.utcnow()
+    }
+
+    _, new_user_ref = users_ref.add(user_dict)
+    
+    logger.info(f"New user registered in Firestore: {signup_data.email}")
+
+    return UserResponse(
+        id=new_user_ref.id,
         email=signup_data.email,
         username=signup_data.username,
-        password_hash=hashed_password_value,
         role="user",
         age=signup_data.age,
         gender=signup_data.gender,
-    )
-
-    session.add(new_user)
-    await session.commit()
-    await session.refresh(new_user)
-
-    logger.info(f"New user registered: {new_user.email}")
-
-    return UserResponse(
-        id=new_user.id,
-        email=new_user.email,
-        username=new_user.username,
-        role=new_user.role,
-        age=new_user.age,
-        gender=new_user.gender,
-        created_at=str(new_user.created_at),
+        created_at=str(user_dict["created_at"]),
     )
 
 
 @router.post("/login", response_model=TokenResponse)
 async def login(
-    form_data: OAuth2PasswordRequestForm = Depends(),
-    session: AsyncSession = Depends(get_session),
+    form_data: OAuth2PasswordRequestForm = Depends()
 ):
     """
-    Authenticate user and return JWT access token.
+    Authenticate user and return JWT access token using Firestore.
     """
+    db = get_firebase_db()
+    if db is None:
+         raise HTTPException(status_code=500, detail="Firebase not configured")
+         
+    users_ref = db.collection("users")
+    
     # Find user by username
-    statement = select(User).where(User.username == form_data.username)
-    result = await session.exec(statement)
-    user = result.first()
+    query = users_ref.where("username", "==", form_data.username).limit(1).stream()
+    user_doc = next(query, None)
 
     # If not found by username, try finding by email
-    if not user:
-        statement = select(User).where(User.email == form_data.username)
-        result = await session.exec(statement)
-        user = result.first()
+    if not user_doc:
+        query = users_ref.where("email", "==", form_data.username).limit(1).stream()
+        user_doc = next(query, None)
 
     # Verify user exists and password is correct
-    if not user or not verify_password(form_data.password, user.password_hash):
+    if not user_doc:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Incorrect username or password",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+    
+    user_data = user_doc.to_dict()
+    if not verify_password(form_data.password, user_data["password_hash"]):
         raise HTTPException(
             status_code=status.HTTP_401_UNAUTHORIZED,
             detail="Incorrect username or password",
@@ -162,10 +175,10 @@ async def login(
     # Create access token
     access_token_expires = timedelta(minutes=settings.access_token_expire_minutes)
     access_token = create_access_token(
-        data={"sub": user.username}, expires_delta=access_token_expires
+        data={"sub": user_data["username"]}, expires_delta=access_token_expires
     )
 
-    logger.info(f"User logged in: {user.username}")
+    logger.info(f"User logged in from Firestore: {user_data['username']}")
 
     return TokenResponse(
         access_token=access_token,

src/api/main.py

@@ -8,16 +8,15 @@ from fastapi import FastAPI, HTTPException, BackgroundTasks, Depends
 from fastapi.middleware.cors import CORSMiddleware
 from pydantic import BaseModel, HttpUrl
 
-from src.ai_modules.transcription.audio_downloader import YouTubeDownloader
-from src.ai_modules.transcription.whisper_transcriber import WhisperTranscriber
-from src.ai_modules.summarization.note_generator import NoteGenerator
+from src.transcription.audio_downloader import YouTubeDownloader
+from src.transcription.whisper_transcriber import WhisperTranscriber
+from src.summarization.note_generator import NoteGenerator
 from src.utils.logger import setup_logger
-from src.db.database import create_db_and_tables, async_engine
+from src.db.firebase import get_firebase_db
 from src.db.models import Note, User
 from src.auth.dependencies import get_current_user
 from src.api.auth_routes import router as auth_router
 from src.api.notes_routes import router as notes_router
-from sqlmodel.ext.asyncio.session import AsyncSession
 
 logger = setup_logger(__name__)
 
@@ -49,8 +48,8 @@ tasks: Dict[str, Dict] = {}
 
 @asynccontextmanager
 async def lifespan(app: FastAPI):
-    logger.info("Lifespan: Initializing database tables...")
-    await create_db_and_tables()
+    logger.info("Lifespan: Initializing Firebase...")
+    get_firebase_db()
     yield
 
 
@@ -102,7 +101,7 @@ async def generate(
 
 
 async def process_video_and_save(
-    task_id: str, youtube_url: str, language: str, user_id: int
+    task_id: str, youtube_url: str, language: str, user_id: str
 ):
     audio_file = None
     try:
@@ -127,16 +126,18 @@ async def process_video_and_save(
             video_info["duration"],
         )
 
-        async with AsyncSession(async_engine) as session:
-            new_note = Note(
-                user_id=user_id,
-                video_url=youtube_url,
-                video_title=video_info["title"],
-                summary_content=final_notes,
-            )
-            session.add(new_note)
-            await session.commit()
-            await session.refresh(new_note)
+        db = get_firebase_db()
+        if db:
+            note_data = {
+                "user_id": user_id,
+                "video_url": youtube_url,
+                "video_title": video_info["title"],
+                "summary_content": final_notes,
+                "created_at": datetime.utcnow()
+            }
+            db.collection("notes").add(note_data)
+        else:
+            logger.warning("Firestore not initialized, note not saved to DB but generated in memory.")
 
         tasks[task_id]["notes"] = final_notes
         tasks[task_id]["keyPoints"] = json_notes.get("key_points", []) if isinstance(json_notes, dict) else []

src/api/notes_routes.py

@@ -12,7 +12,7 @@ from fastapi.responses import FileResponse, JSONResponse
 from pydantic import BaseModel, HttpUrl, Field
 from sqlmodel import Session, select
 
-from src.db.database import get_session
+from src.db.firebase import get_firebase_db
 from src.db.models import User, Note
 from src.auth.dependencies import get_current_user
 from src.ai_modules.categorization.categorizer import CategorizationService
@@ -45,13 +45,13 @@ class CreateNoteRequest(BaseModel):
 
 
 class NoteResponse(BaseModel):
-    id: int
+    id: str  # Changed to str for Firestore IDs
     video_url: str
     video_title: str
     summary_text: str
     video_duration: Optional[int]
     language: str
-    user_id: int
+    user_id: str  # Changed to str
     category: Optional[str]
     created_at: str
 
@@ -125,69 +125,74 @@ async def get_generated_note_content(filename: str):
 # End of New Endpoints
 # ==========================================
 
-# ... (Database endpoints kept for compatibility if needed later) ...
-# You can leave the rest of the file as is, or I can include it below just in case.
-# For brevity, I'll include the standard DB create/get just to not break anything.
-
 
 @router.get("/{note_id}", response_model=NoteResponse)
 async def get_note(
-    note_id: int,
-    session: AsyncSession = Depends(get_session),
+    note_id: str,
     current_user: User = Depends(get_current_user),
 ):
     """
-    Get a specific note by ID.
+    Get a specific note by ID from Firestore.
     """
-    statement = select(Note).where(Note.id == note_id, Note.user_id == current_user.id)
-    result = await session.exec(statement)
-    note = result.first()
+    db = get_firebase_db()
+    if db is None:
+        raise HTTPException(status_code=500, detail="Firebase not configured")
+
+    note_ref = db.collection("notes").document(note_id)
+    note_doc = note_ref.get()
 
-    if not note:
+    if not note_doc.exists:
         raise HTTPException(status_code=404, detail="Note not found")
 
+    note_data = note_doc.to_dict()
+    if note_data.get("user_id") != current_user.id:
+        raise HTTPException(status_code=403, detail="Forbidden")
+
     return NoteResponse(
-        id=note.id,
-        video_url=note.video_url,
-        video_title=note.video_title,
-        summary_text=note.summary_content,
+        id=note_doc.id,
+        video_url=note_data["video_url"],
+        video_title=note_data["video_title"],
+        summary_text=note_data["summary_content"],
         video_duration=None,
         language="en",
-        user_id=note.user_id,
-        category=note.category,
-        created_at=str(note.created_at),
+        user_id=note_data["user_id"],
+        category=note_data.get("category"),
+        created_at=str(note_data.get("created_at")),
     )
 
 
 @router.get("", response_model=List[NoteResponse])
 async def list_user_notes(
-    session: AsyncSession = Depends(get_session),
     current_user: User = Depends(get_current_user),
 ):
     """
-    List all notes belonging to the current user.
+    List all notes belonging to the current user from Firestore.
     """
-    statement = (
-        select(Note)
-        .where(Note.user_id == current_user.id)
-        .order_by(Note.created_at.desc())
+    db = get_firebase_db()
+    if db is None:
+        return []
+
+    notes_ref = db.collection("notes")
+    query = (
+        notes_ref.where("user_id", "==", current_user.id)
+        .order_by("created_at", direction="DESCENDING")
+        .stream()
     )
-    result = await session.exec(statement)
-    notes = result.all()
 
     return [
         NoteResponse(
-            id=n.id,
-            video_url=n.video_url,
-            video_title=n.video_title,
-            summary_text=n.summary_content,
-            video_duration=None,  # Update if stored
-            language="en",  # Default
-            user_id=n.user_id,
-            category=n.category,
-            created_at=str(n.created_at),
+            id=doc.id,
+            video_url=data["video_url"],
+            video_title=data["video_title"],
+            summary_text=data["summary_content"],
+            video_duration=None,
+            language="en",
+            user_id=data["user_id"],
+            category=data.get("category"),
+            created_at=str(data.get("created_at")),
         )
-        for n in notes
+        for doc in query
+        if (data := doc.to_dict())
     ]
 
 
@@ -195,29 +200,33 @@ async def list_user_notes(
 async def create_note(
     note_data: CreateNoteRequest,
     current_user: User = Depends(get_current_user),
-    session: AsyncSession = Depends(get_session),
 ):
     # Automatically categorize the note
     category = await categorizer.categorize_text(note_data.summary_text)
 
-    new_note = Note(
-        video_url=str(note_data.video_url),
-        video_title=note_data.video_title,
-        summary_content=note_data.summary_text,
-        user_id=current_user.id,
-        category=category,
-    )
-    session.add(new_note)
-    await session.commit()
-    await session.refresh(new_note)
+    db = get_firebase_db()
+    if db is None:
+        raise HTTPException(status_code=500, detail="Firebase not configured")
+
+    note_dict = {
+        "video_url": str(note_data.video_url),
+        "video_title": note_data.video_title,
+        "summary_content": note_data.summary_text,
+        "user_id": current_user.id,
+        "category": category,
+        "created_at": datetime.utcnow()
+    }
+
+    _, new_note_ref = db.collection("notes").add(note_dict)
+
     return NoteResponse(
-        id=new_note.id,
-        video_url=new_note.video_url,
-        video_title=new_note.video_title,
-        summary_text=new_note.summary_content,
+        id=new_note_ref.id,
+        video_url=note_dict["video_url"],
+        video_title=note_dict["video_title"],
+        summary_text=note_dict["summary_content"],
         video_duration=None,
         language="en",
-        user_id=new_note.user_id,
-        category=new_note.category,
-        created_at=str(new_note.created_at),
+        user_id=note_dict["user_id"],
+        category=note_dict["category"],
+        created_at=str(note_dict["created_at"]),
     )

src/auth/dependencies.py

@@ -7,9 +7,8 @@ from fastapi import Depends, HTTPException, status
 from fastapi.security import OAuth2PasswordBearer
 from sqlmodel import select
 
-from src.db.database import get_session
+from src.db.firebase import get_firebase_db
 from src.db.models import User
-from sqlmodel.ext.asyncio.session import AsyncSession
 from src.auth.security import decode_access_token
 
 # OAuth2 scheme for extracting bearer tokens from Authorization header
@@ -17,28 +16,10 @@ oauth2_scheme = OAuth2PasswordBearer(tokenUrl="/auth/login")
 
 
 async def get_current_user(
-    token: str = Depends(oauth2_scheme), session: AsyncSession = Depends(get_session)
+    token: str = Depends(oauth2_scheme)
 ) -> User:
     """
-    Get the currently authenticated user from JWT token.
-
-    This dependency extracts the JWT token from the Authorization header,
-    validates it, and retrieves the corresponding user from the database.
-
-    Args:
-        token: JWT token from Authorization header
-        session: Database session
-
-    Returns:
-        User object if authentication is successful
-
-    Raises:
-        HTTPException: 401 Unauthorized if token is invalid or user not found
-
-    Usage:
-        @app.get("/protected")
-        async def protected_route(current_user: User = Depends(get_current_user)):
-            return {"message": f"Hello {current_user.username}"}
+    Get the currently authenticated user from JWT token (using Firestore).
     """
     credentials_exception = HTTPException(
         status_code=status.HTTP_401_UNAUTHORIZED,
@@ -56,15 +37,28 @@ async def get_current_user(
     if username is None:
         raise credentials_exception
 
-    # Retrieve user from database
-    statement = select(User).where(User.username == username)
-    result = await session.exec(statement)
-    user = result.first()
-
-    if user is None:
+    # Retrieve user from Firestore
+    db = get_firebase_db()
+    if db is None:
+        # Fallback for when Firebase is not configured
+        return User(
+            id="mock_id",
+            email="mock@example.com",
+            username=username,
+            password_hash="mock",
+            role="user"
+        )
+
+    users_ref = db.collection("users")
+    query = users_ref.where("username", "==", username).limit(1).stream()
+    user_doc = next(query, None)
+
+    if user_doc is None:
         raise credentials_exception
 
-    return user
+    user_data = user_doc.to_dict()
+    user_data["id"] = user_doc.id
+    return User(**user_data)
 
 
 async def get_current_active_user(

src/db/firebase.py

@@ -0,0 +1,53 @@
+"""
+Firebase initialization and helper functions.
+"""
+
+import firebase_admin
+from firebase_admin import credentials, firestore, auth
+from pathlib import Path
+from src.utils.config import settings
+from src.utils.logger import setup_logger
+
+logger = setup_logger(__name__)
+
+_db = None
+
+def get_firebase_db():
+    """
+    Initialize Firebase Admin SDK and return Firestore client.
+    """
+    global _db
+    if _db is not None:
+        return _db
+
+    try:
+        service_account_path = Path(settings.firebase_service_account_path)
+        
+        if not service_account_path.exists():
+            logger.warning(f"Firebase service account file not found at {service_account_path}. Using fallback/mock behavior if applicable.")
+            # In a real production app, we might want to raise an error here.
+            # For now, we'll return None and handle it in the services.
+            return None
+
+        cred = credentials.Certificate(str(service_account_path))
+        firebase_admin.initialize_app(cred, {
+            'storageBucket': settings.firebase_storage_bucket
+        })
+        
+        _db = firestore.client()
+        logger.info("Firebase initialized successfully.")
+        return _db
+    except Exception as e:
+        logger.error(f"Failed to initialize Firebase: {e}")
+        return None
+
+def verify_token(id_token: str):
+    """
+    Verify a Firebase ID token.
+    """
+    try:
+        decoded_token = auth.verify_id_token(id_token)
+        return decoded_token
+    except Exception as e:
+        logger.error(f"Token verification failed: {e}")
+        return None

src/db/models.py

@@ -5,48 +5,41 @@ Optimized for cloud deployment and mobile app integration.
 
 from datetime import datetime
 from typing import Optional, List
-from sqlmodel import SQLModel, Field, Relationship
+from pydantic import BaseModel, Field
 
 
-class User(SQLModel, table=True):
-    __tablename__ = "users"
+class User(BaseModel):
+    """User model for Firestore 'users' collection."""
+    id: Optional[str] = Field(default=None)
+    email: str
+    username: str
+    password_hash: str
+    role: str = "user"
+    age: Optional[int] = None
+    gender: Optional[str] = None
+    created_at: datetime = Field(default_factory=datetime.utcnow)
 
-    id: Optional[int] = Field(default=None, primary_key=True)
-    email: str = Field(unique=True, index=True, max_length=255, nullable=False)
-    username: str = Field(max_length=100, nullable=False)
-    password_hash: str = Field(max_length=255, nullable=False)
-    role: str = Field(default="user", max_length=50, nullable=False)
-    age: Optional[int] = Field(default=None)
-    gender: Optional[str] = Field(default=None, max_length=20)
-    created_at: datetime = Field(default_factory=datetime.utcnow, nullable=False)
+    class Config:
+        from_attributes = True
 
-    notes: List["Note"] = Relationship(back_populates="owner")
 
+class Category(BaseModel):
+    """Category model for Firestore 'categories' collection."""
+    id: Optional[str] = Field(default=None)
+    name: str
+    description: Optional[str] = None
+    user_id: str
+    created_at: datetime = Field(default_factory=datetime.utcnow)
 
-class Category(SQLModel, table=True):
-    __tablename__ = "categories"
 
-    id: Optional[int] = Field(default=None, primary_key=True)
-    name: str = Field(index=True, max_length=100, nullable=False)
-    description: Optional[str] = Field(default=None, max_length=500)
-    user_id: int = Field(foreign_key="users.id", index=True, nullable=False)
-    created_at: datetime = Field(default_factory=datetime.utcnow, nullable=False)
-
-
-class Note(SQLModel, table=True):
+class Note(BaseModel):
     """
-    Note model synchronized with Supabase schema.
-    Removed content_json and keywords to prevent UndefinedColumnError.
+    Note model for Firestore 'notes' collection.
     """
-
-    __tablename__ = "notes"
-
-    id: Optional[int] = Field(default=None, primary_key=True)
-    user_id: int = Field(foreign_key="users.id", index=True, nullable=False)
-    video_url: str = Field(index=True, max_length=500, nullable=False)
-    video_title: str = Field(max_length=500, nullable=False)
-    summary_content: str = Field(nullable=False)
-    category: Optional[str] = Field(default="Uncategorized", max_length=100)
-    created_at: datetime = Field(default_factory=datetime.utcnow, nullable=False)
-
-    owner: Optional[User] = Relationship(back_populates="notes")
+    id: Optional[str] = Field(default=None)
+    user_id: str
+    video_url: str
+    video_title: str
+    summary_content: str
+    category: Optional[str] = "Uncategorized"
+    created_at: datetime = Field(default_factory=datetime.utcnow)