first commit

README.md

@@ -0,0 +1,108 @@
+# Video RAG System Project
+
+This FastAPI-based Video RAG (Retrieval-Augmented Generation) system provides endpoints to:
+
+1. **Register & Authenticate** users
+2. **Transcribe** YouTube or uploaded videos
+3. **Query** the RAG system
+4. **Manage** sessions (list, view, delete)
+
+---
+
+## Endpoint Flow
+
+```mermaid
+graph TD
+  A[POST /register] --> B[POST /token]
+  B --> C[POST /transcribe]
+  B --> D[POST /upload]
+  C --> E[Start RAG session]
+  D --> E
+  E --> F[POST /query]
+  E --> G[GET /sessions]
+  G --> H[GET /sessions/{session_id}]
+  H --> F
+  G --> I[DELETE /sessions/{session_id}]
+```
+
+1. **User Registration & Login**  
+   - **POST /register**: Create a new user.  
+   - **POST /token**: Obtain JWT access token.
+
+2. **Video Transcription**  
+   - **POST /transcribe** (YouTube URL): Transcribe via Google GenAI → split & store chunks → initialize chat history → return `session_id`.  
+   - **POST /upload** (Multipart Form Video): Upload & transcribe file → split & store chunks → initialize chat history → return `session_id`.
+
+3. **Query RAG System**  
+   - **POST /query** with `{ session_id, query }`:  
+     • Rebuild FAISS retriever from MongoDB chunks  
+     • Invoke ConversationalRetrievalChain  
+     • Append messages to chat history  
+     • Return `{ answer, session_id, source_documents }`
+
+4. **Session Management**  
+   - **GET /sessions**: List all sessions for current user.  
+   - **GET /sessions/{session_id}**: Get full transcription & Q&A history.  
+   - **DELETE /sessions/{session_id}**: Remove metadata, chunks, chat history, and video files.
+
+---
+
+## README.md
+
+```markdown
+# Video RAG System
+
+## Overview
+A FastAPI application that:
+
+- Authenticates users (JWT)
+- Transcribes videos (YouTube or upload) via Google GenAI
+- Stores transcription chunks in MongoDB
+- Builds a FAISS retriever on demand
+- Provides a conversational retrieval endpoint
+- Manages sessions and associated data
+
+## API Endpoints
+
+| Method | Path                       | Auth Required | Description                                   |
+|--------|----------------------------|---------------|-----------------------------------------------|
+| POST   | /register                  | No            | Create a new user                             |
+| POST   | /token                     | No            | Login and return JWT token                    |
+| POST   | /transcribe                | Yes           | Transcribe YouTube video and init session     |
+| POST   | /upload                    | Yes           | Upload & transcribe video file                |
+| POST   | /query                     | Yes           | Run Q&A against a session                     |
+| GET    | /sessions                  | Yes           | List all user sessions                        |
+| GET    | /sessions/{session_id}     | Yes           | Get session transcription & chat history      |
+| DELETE | /sessions/{session_id}     | Yes           | Delete session & all associated data          |
+
+## Usage
+1. Clone repo & install dependencies:
+   ```bash
+   pip install -r requirements.txt
+   ```
+2. Create `.env` with your credentials (MongoDB, JWT secret, API keys).
+3. Run the app:
+   ```bash
+   uvicorn app.main:app --reload
+   ```
+4. Interact via HTTP clients (curl, Postman) following the flow above.
+
+## Folder Structure
+```
+rag_system/
+├── app/
+│   ├── main.py
+│   ├── config.py
+│   ├── dependencies.py
+│   ├── models/
+│   ├── db/
+│   ├── services/
+│   ├── routes/
+│   └── utils/
+├── temp_videos/
+├── .env
+├── requirements.txt
+└── README.md
+```
+```
+```

app/config.py

@@ -0,0 +1,26 @@
+import os
+from dotenv import load_dotenv
+from urllib.parse import quote_plus
+
+load_dotenv()
+
+class Settings:
+    # MongoDB
+    MONGO_USERNAME = os.getenv("MONGO_USERNAME")
+    MONGO_PASSWORD = quote_plus(os.getenv("MONGO_PASSWORD"))  # Escape special characters
+    DATABASE_NAME = os.getenv("DATABASE_NAME")
+    COLLECTION_NAME = os.getenv("COLLECTION_NAME")
+    CONNECTION_STRING = os.getenv("CONNECTION_STRING_TEMPLATE").format(
+        username=MONGO_USERNAME,
+        password=MONGO_PASSWORD
+    )
+
+    # Security
+    SECRET_KEY = os.getenv("SECRET_KEY")
+    ALGORITHM = "HS256"
+    ACCESS_TOKEN_EXPIRE_MINUTES = 30
+
+    # Video storage
+    VIDEOS_DIR = "temp_videos"
+
+settings = Settings()

app/db/chat_manager.py

@@ -0,0 +1,64 @@
+# app/db/chat_manager.py
+import uuid
+from langchain_mongodb.chat_message_histories import MongoDBChatMessageHistory
+from ..config import settings
+
+class ChatManagement:
+    def __init__(self, connection_string, database_name, collection_name):
+        self.connection_string = connection_string
+        self.database_name = database_name
+        self.collection_name = collection_name
+        # map session_id to MongoDBChatMessageHistory instances
+        self.chat_sessions = {}
+
+    def _create_history(self, session_id: str) -> MongoDBChatMessageHistory:
+        """
+        Internal: create a new MongoDBChatMessageHistory for a session_id.
+        """
+        history = MongoDBChatMessageHistory(
+            session_id=session_id,
+            connection_string=self.connection_string,
+            database_name=self.database_name,
+            collection_name=self.collection_name
+        )
+        # store in memory
+        self.chat_sessions[session_id] = history
+        return history
+
+    def get_chat_history(self, session_id: str) -> MongoDBChatMessageHistory | None:
+        """
+        Retrieve an existing chat history object from memory or database.
+        Returns None if no history found.
+        """
+        # in-memory
+        if session_id in self.chat_sessions:
+            return self.chat_sessions[session_id]
+        # instantiate from DB
+        history = MongoDBChatMessageHistory(
+            session_id=session_id,
+            connection_string=self.connection_string,
+            database_name=self.database_name,
+            collection_name=self.collection_name
+        )
+        if history.messages:
+            self.chat_sessions[session_id] = history
+            return history
+        return None
+
+    def initialize_chat_history(self, session_id: str) -> MongoDBChatMessageHistory:
+        """
+        Ensure a chat history exists for the session_id. Return the history instance.
+        """
+        history = self.get_chat_history(session_id)
+        if history:
+            return history
+        # no existing history, create new object (and DB entries)
+        return self._create_history(session_id)
+
+# create a global instance for use in routes
+from ..config import settings
+chat_manager = ChatManagement(
+    settings.CONNECTION_STRING,
+    settings.DATABASE_NAME,
+    settings.COLLECTION_NAME
+)

app/db/mongodb.py

@@ -0,0 +1,19 @@
+from pymongo import MongoClient
+from ..config import settings
+
+class MongoDB:
+    def __init__(self):
+        self.client = MongoClient(settings.CONNECTION_STRING)
+        self.db = self.client[settings.DATABASE_NAME]
+        self.users = self.db["users"]
+        self.videos = self.db[settings.COLLECTION_NAME]
+        # Indexes
+        self.users.create_index("username", unique=True)
+        self.users.create_index("email", unique=True)
+        self.videos.create_index("video_id", unique=True)
+        self.videos.create_index("user_id")
+
+    def close(self):
+        self.client.close()
+
+mongodb = MongoDB()

app/dependencies.py

@@ -0,0 +1,27 @@
+from fastapi import Depends, HTTPException
+from fastapi.security import OAuth2PasswordBearer
+import jwt
+from .config import settings
+from .services.auth import get_user
+from .models.user import TokenData
+
+oauth2_scheme = OAuth2PasswordBearer(tokenUrl="/token")
+
+async def get_current_user(token: str = Depends(oauth2_scheme)):
+    credentials_exception = HTTPException(
+        status_code=401,
+        detail="Could not validate credentials",
+        headers={"WWW-Authenticate": "Bearer"},
+    )
+    try:
+        payload = jwt.decode(token, settings.SECRET_KEY, algorithms=[settings.ALGORITHM])
+        username: str = payload.get("sub")
+        if username is None:
+            raise credentials_exception
+        token_data = TokenData(username=username)
+    except jwt.PyJWTError:
+        raise credentials_exception
+    user = get_user(token_data.username)
+    if user is None:
+        raise credentials_exception
+    return user

app/main.py

@@ -0,0 +1,46 @@
+import os
+import shutil
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from dotenv import load_dotenv
+from .config import settings
+from .db.mongodb import mongodb
+from .routes import auth, video, query, sessions
+
+load_dotenv()
+
+app = FastAPI(
+    title="RAG System API",
+    description="An API for question answering based on video content with user authentication"
+)
+
+# CORS
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Include routers
+app.include_router(auth.router)
+app.include_router(video.router)
+app.include_router(query.router)
+app.include_router(sessions.router)
+
+@app.get("/")
+async def root():
+    return {"message": "Video Transcription and QA API"}
+
+@app.on_event("shutdown")
+def on_shutdown():
+    # Close DB
+    mongodb.close()
+    # Clean up temp videos
+    shutil.rmtree(settings.VIDEOS_DIR, ignore_errors=True)
+
+if __name__ == "__main__":
+    import uvicorn
+    os.environ["TOKENIZERS_PARALLELISM"] = "false"
+    uvicorn.run(app, host="0.0.0.0", port=8000)

app/models/transcription.py

@@ -0,0 +1,25 @@
+from pydantic import BaseModel, Field
+from typing import List, Optional, Dict, Any
+from datetime import datetime
+
+class TranscriptionRequest(BaseModel):
+    youtube_url: str
+
+class QueryRequest(BaseModel):
+    query: str
+    session_id: str
+
+class QueryResponse(BaseModel):
+    answer: str
+    session_id: str
+    source_documents: Optional[List[str]]
+
+class VideoData(BaseModel):
+    video_id: str
+    user_id: str
+    title: str
+    source_type: str
+    source_url: Optional[str]
+    created_at: datetime = Field(default_factory=datetime.utcnow)
+    transcription: str
+    size: Optional[int]

app/models/user.py

@@ -0,0 +1,20 @@
+from pydantic import BaseModel, EmailStr
+from typing import Optional
+
+class User(BaseModel):
+    username: str
+    email: EmailStr
+    full_name: Optional[str]
+
+class UserInDB(User):
+    hashed_password: str
+
+class UserCreate(User):
+    password: str
+
+class Token(BaseModel):
+    access_token: str
+    token_type: str
+
+class TokenData(BaseModel):
+    username: Optional[str]

app/routes/auth.py

@@ -0,0 +1,27 @@
+from fastapi import APIRouter, HTTPException, Depends
+from fastapi.security import OAuth2PasswordRequestForm
+from ..models.user import UserCreate, User, Token
+from ..services.auth import get_password_hash, authenticate_user, create_access_token
+from ..db.mongodb import mongodb
+
+router = APIRouter()
+
+@router.post("/register", response_model=User)
+async def register(user: UserCreate):
+    if mongodb.users.find_one({"username": user.username}):
+        raise HTTPException(400, "Username already registered")
+    if mongodb.users.find_one({"email": user.email}):
+        raise HTTPException(400, "Email already registered")
+    hashed = get_password_hash(user.password)
+    user_dict = user.dict(exclude={"password"})
+    user_dict["hashed_password"] = hashed
+    mongodb.users.insert_one(user_dict)
+    return User(**user_dict)
+
+@router.post("/token", response_model=Token)
+async def login(form_data: OAuth2PasswordRequestForm = Depends()):
+    user = authenticate_user(form_data.username, form_data.password)
+    if not user:
+        raise HTTPException(401, "Incorrect username or password", headers={"WWW-Authenticate": "Bearer"})
+    token = create_access_token({"sub": user.username})
+    return {"access_token": token, "token_type": "bearer"}

app/routes/query.py

@@ -0,0 +1,61 @@
+# app/routes/query.py
+from fastapi import APIRouter, Depends, HTTPException
+from ..models.transcription import QueryRequest, QueryResponse
+from ..dependencies import get_current_user
+from ..services.transcription import get_retriever
+from ..db.mongodb import mongodb
+from ..db.chat_manager import chat_manager
+from ..services.llm import create_chain
+
+router = APIRouter()
+
+@router.post("/query", response_model=QueryResponse)
+async def query_system(request: QueryRequest, current_user = Depends(get_current_user)):
+    """
+    Query the RAG system for a given session and question
+    """
+    # Verify metadata exists
+    video = mongodb.videos.find_one({"video_id": request.session_id})
+    if not video:
+        raise HTTPException(status_code=404, detail="Session not found. Please transcribe a video first.")
+    if video.get("user_id") != current_user.username:
+        raise HTTPException(status_code=403, detail="Not authorized to access this session.")
+
+    # Build retriever from MongoDB chunks
+    retriever = get_retriever(request.session_id)
+    chat_history = chat_manager.initialize_chat_history(request.session_id)
+    chain = create_chain(retriever)
+
+    # Format previous messages for chain
+    history = chat_history.messages or []
+    formatted_history = []
+    for i in range(0, len(history) - 1, 2):
+        formatted_history.append((history[i].content, history[i+1].content))
+
+    # Invoke chain
+    result = chain.invoke({
+        "question": request.query,
+        "chat_history": formatted_history
+    })
+
+    # Extract answer
+    answer = result.get("answer", "I couldn't find an answer to your question.")
+    # Save new messages
+    chat_history.add_user_message(request.query)
+    chat_history.add_ai_message(answer)
+
+    # Process source docs
+    source_docs = []
+    for doc in result.get("source_documents", []):
+        try:
+            text = getattr(doc, 'page_content', None) or str(doc)
+            snippet = text[:100] + "..." if len(text) > 100 else text
+            source_docs.append(snippet)
+        except:
+            continue
+
+    return QueryResponse(
+        answer=answer,
+        session_id=request.session_id,
+        source_documents=source_docs
+    )

app/routes/sessions.py

@@ -0,0 +1,90 @@
+# app/routes/sessions.py
+from fastapi import APIRouter, Depends, HTTPException
+from typing import List, Dict, Any
+import os
+
+from ..dependencies import get_current_user
+from ..db.mongodb import mongodb
+from ..db.chat_manager import chat_manager
+from ..config import settings
+
+router = APIRouter()
+
+@router.get("/sessions", response_model=List[Dict[str, Any]])
+async def list_sessions(current_user = Depends(get_current_user)):
+    """
+    List all video sessions for the current user.
+    """
+    videos = list(mongodb.videos.find({"user_id": current_user.username}))
+    sessions_list = []
+    for v in videos:
+        sessions_list.append({
+            "session_id": v["video_id"],
+            "title": v["title"],
+            "source_type": v["source_type"],
+            "created_at": v["created_at"],
+            "transcription_preview": (v["transcription"][:200] + "...") if len(v["transcription"]) > 200 else v["transcription"]
+        })
+    return sessions_list
+
+@router.get("/sessions/{session_id}", response_model=Dict[str, Any])
+async def get_session(session_id: str, current_user = Depends(get_current_user)):
+    """
+    Retrieve details and chat history for a specific session.
+    """
+    video = mongodb.videos.find_one({"video_id": session_id})
+    if not video:
+        raise HTTPException(status_code=404, detail="Session not found")
+    if video.get("user_id") != current_user.username:
+        raise HTTPException(status_code=403, detail="Not authorized to access this session")
+
+    # Fetch chat history
+    history = chat_manager.get_chat_history(session_id)
+    chat_messages = []
+    if history:
+        msgs = history.messages
+        for i in range(0, len(msgs) - 1, 2):
+            chat_messages.append({
+                "question": msgs[i].content,
+                "answer": msgs[i+1].content
+            })
+
+    return {
+        "session_id": session_id,
+        "title": video["title"],
+        "source_type": video["source_type"],
+        "source_url": video.get("source_url"),
+        "created_at": video["created_at"],
+        "transcription_preview": (video["transcription"][:200] + "...") if len(video["transcription"]) > 200 else video["transcription"],
+        "full_transcription": video["transcription"],
+        "chat_history": chat_messages
+    }
+
+@router.delete("/sessions/{session_id}")
+async def delete_session(session_id: str, current_user = Depends(get_current_user)):
+    """
+    Delete a session, its chunks, chat history, and associated video file.
+    """
+    video = mongodb.videos.find_one({"video_id": session_id})
+    if not video:
+        raise HTTPException(status_code=404, detail="Session not found")
+    if video.get("user_id") != current_user.username:
+        raise HTTPException(status_code=403, detail="Not authorized to delete this session")
+
+    # Delete video metadata
+    mongodb.videos.delete_one({"video_id": session_id})
+    # Delete chunks
+    mongodb.db.get_collection("chunks").delete_many({"session_id": session_id})
+    # Delete chat history
+    history = chat_manager.get_chat_history(session_id)
+    if history:
+        mongodb.db.get_collection(settings.COLLECTION_NAME).delete_many({"session_id": session_id})
+    # Delete video file(s)
+    video_files = [f for f in os.listdir(settings.VIDEOS_DIR) if f.startswith(session_id)]
+    for file in video_files:
+        try:
+            os.remove(os.path.join(settings.VIDEOS_DIR, file))
+        except OSError:
+            pass
+
+    return {"message": f"Session {session_id} deleted successfully"}

app/routes/video.py

@@ -0,0 +1,131 @@
+from fastapi import APIRouter, Depends, Form, File, UploadFile, BackgroundTasks, HTTPException
+from fastapi.responses import StreamingResponse
+from datetime import datetime
+from typing import Optional, List
+import os
+
+from ..models.transcription import TranscriptionRequest
+from ..dependencies import get_current_user
+from ..services.transcription import process_transcription, save_video_file
+from ..services.llm import init_google_client
+from ..config import settings
+from ..db.mongodb import mongodb
+from google.genai import types
+
+router = APIRouter()
+
+@router.post("/transcribe")
+async def transcribe(
+    request: TranscriptionRequest,
+    current_user = Depends(get_current_user)
+):
+    """
+    Transcribe a YouTube video via Google GenAI and prepare the RAG system
+    """
+    try:
+        client = init_google_client()
+        content = types.Content(
+            parts=[
+                types.Part(text="Transcribe the Video. Write all the things described in the video"),
+                types.Part(file_data=types.FileData(file_uri=request.youtube_url))
+            ]
+        )
+        response = client.models.generate_content(
+            model='models/gemini-2.0-flash',
+            contents=content
+        )
+        transcription = response.candidates[0].content.parts[0].text
+        title = f"YouTube Video - {datetime.utcnow().strftime('%Y-%m-%d %H:%M:%S')}"
+        session_id = process_transcription(
+            transcription,
+            current_user.username,
+            title,
+            source_type="youtube",
+            source_url=request.youtube_url
+        )
+        return {"session_id": session_id, "message": "YouTube video transcribed and RAG system prepared"}
+
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error transcribing video: {str(e)}")
+
+
+@router.post("/upload")
+async def upload_video(
+    background_tasks: BackgroundTasks,
+    title: str = Form(...),
+    file: UploadFile = File(...),
+    prompt: str = Form("Transcribe the Video. Write all the things described in the video"),
+    current_user = Depends(get_current_user)
+):
+    """
+    Upload a video file (max 20MB), transcribe via GenAI, and prepare the RAG system
+    """
+    try:
+        contents = await file.read()
+        file_size = len(contents)
+        if file_size > 20 * 1024 * 1024:
+            raise HTTPException(status_code=400, detail="File size exceeds 20MB limit")
+        if not file.content_type.startswith('video/'):
+            raise HTTPException(status_code=400, detail="File must be a video")
+
+        client = init_google_client()
+        content = types.Content(
+            parts=[
+                types.Part(text=prompt),
+                types.Part(inline_data=types.Blob(data=contents, mime_type=file.content_type))
+            ]
+        )
+        response = client.models.generate_content(
+            model='models/gemini-2.0-flash',
+            contents=content
+        )
+        transcription = response.candidates[0].content.parts[0].text
+        session_id = process_transcription(
+            transcription,
+            current_user.username,
+            title,
+            source_type="upload",
+            file_size=file_size
+        )
+        ext = os.path.splitext(file.filename)[1]
+        file_path = os.path.join(settings.VIDEOS_DIR, f"{session_id}{ext}")
+        background_tasks.add_task(save_video_file, session_id, file_path, contents)
+        return {"session_id": session_id, "message": "Uploaded video transcribed and RAG system prepared"}
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error processing uploaded video: {str(e)}")
+
+
+@router.get("/download/{video_id}")
+async def download_video(
+    video_id: str,
+    current_user = Depends(get_current_user)
+):
+    """
+    Download a previously uploaded video by streaming the saved file
+    """
+    video_data = mongodb.videos.find_one({"video_id": video_id})
+    if not video_data:
+        raise HTTPException(status_code=404, detail="Video not found")
+    if video_data["user_id"] != current_user.username:
+        raise HTTPException(status_code=403, detail="Not authorized to access this video")
+
+    if video_data["source_type"] == "youtube":
+        return {"message": "This is a YouTube video. Access via:", "url": video_data["source_url"]}
+
+    files = [f for f in os.listdir(settings.VIDEOS_DIR) if f.startswith(video_id)]
+    if not files:
+        raise HTTPException(status_code=404, detail="Video file not found")
+
+    path = os.path.join(settings.VIDEOS_DIR, files[0])
+    def iterfile():
+        with open(path, 'rb') as f:
+            yield from f
+    mime_type = f"video/{os.path.splitext(files[0])[1][1:]}"
+    return StreamingResponse(
+        iterfile(),
+        media_type=mime_type,
+        headers={"Content-Disposition": f"attachment; filename={video_data['title']}{os.path.splitext(files[0])[1]}"}
+    )

app/services/auth.py

@@ -0,0 +1,33 @@
+from passlib.context import CryptContext
+from datetime import datetime, timedelta
+import jwt
+from ..config import settings
+from ..db.mongodb import mongodb
+from ..models.user import UserInDB
+
+pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
+
+def verify_password(plain, hashed):
+    return pwd_context.verify(plain, hashed)
+
+def get_password_hash(password):
+    return pwd_context.hash(password)
+
+
+def create_access_token(data: dict):
+    to_encode = data.copy()
+    expire = datetime.utcnow() + timedelta(minutes=settings.ACCESS_TOKEN_EXPIRE_MINUTES)
+    to_encode.update({"exp": expire})
+    return jwt.encode(to_encode, settings.SECRET_KEY, algorithm=settings.ALGORITHM)
+
+
+def get_user(username: str):
+    user = mongodb.users.find_one({"username": username})
+    return UserInDB(**user) if user else None
+
+
+def authenticate_user(username: str, password: str):
+    user = get_user(username)
+    if not user or not verify_password(password, user.hashed_password):
+        return None
+    return user

app/services/llm.py

@@ -0,0 +1,68 @@
+import os
+from google import genai
+from google.genai import types
+from .auth import settings
+from langchain_groq import ChatGroq
+from langchain_huggingface import HuggingFaceEmbeddings
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain_community.docstore.in_memory import InMemoryDocstore
+from langchain_community.vectorstores import FAISS
+from langchain.chains import ConversationalRetrievalChain
+from langchain_core.prompts import ChatPromptTemplate
+
+
+def init_google_client():
+    api_key = os.getenv("GOOGLE_API_KEY")
+    if not api_key:
+        raise ValueError("GOOGLE_API_KEY not set")
+    return genai.Client(api_key=api_key)
+
+
+def get_llm():
+    api_key = os.getenv("CHATGROQ_API_KEY")
+    if not api_key:
+        raise ValueError("CHATGROQ_API_KEY not set")
+    return ChatGroq(model="meta-llama/llama-4-scout-17b-16e-instruct", temperature=0, max_tokens=1024, api_key=api_key)
+
+
+def get_embeddings():
+    return HuggingFaceEmbeddings(model_name="BAAI/bge-small-en", model_kwargs={"device": "cpu"}, encode_kwargs={"normalize_embeddings": True})
+
+# reuse prompt template
+prompt_template = """
+You are an assistant specialized in solving quizzes. Your goal is to provide accurate, concise, and contextually relevant answers.
+Use the following retrieved context to answer the user's question.
+If the context lacks sufficient information, respond with "I don't know." Do not make up answers or provide unverified information.
+
+Guidelines:
+1. Extract key information from the context to form a coherent response.
+2. Maintain a clear and professional tone.
+3. If the question requires clarification, specify it politely.
+
+Retrieved context:
+{context}
+
+User's question:
+{question}
+
+Your response:
+"""
+
+# Create a prompt template to pass the context and user input to the chain
+user_prompt = ChatPromptTemplate.from_messages(
+    [
+        ("system", prompt_template),
+        ("human", "{question}"),
+    ]
+)
+
+
+def create_chain(retriever):
+    return ConversationalRetrievalChain.from_llm(
+        llm=get_llm(),
+        retriever=retriever,
+        return_source_documents=True,
+        chain_type='stuff',
+        combine_docs_chain_kwargs={"prompt": user_prompt},
+        verbose=False,
+    )

app/services/transcription.py

@@ -0,0 +1,73 @@
+# app/services/transcription.py
+import os
+import uuid
+from datetime import datetime
+from fastapi import BackgroundTasks, HTTPException
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from ..services.llm import get_embeddings
+from ..config import settings
+from ..db.mongodb import mongodb
+from ..db.chat_manager import chat_manager
+from langchain_community.vectorstores import FAISS
+
+# ensure video dir exists
+os.makedirs(settings.VIDEOS_DIR, exist_ok=True)
+
+# Store text splits in MongoDB under "chunks" collection
+chunks_collection = mongodb.db.get_collection("chunks")
+
+
+def process_transcription(transcription: str, user_id: str, title: str, source_type: str,
+                          source_url: str = None, file_size: int = None) -> str:
+    """
+    Split transcription into chunks, store in MongoDB, initialize chat history, and return session ID.
+    """
+    # Split text
+    splitter = RecursiveCharacterTextSplitter(chunk_size=1024, chunk_overlap=20)
+    splits = splitter.split_text(transcription)
+
+    # Persist session metadata
+    session_id = str(uuid.uuid4())
+    mongodb.videos.insert_one({
+        "video_id": session_id,
+        "user_id": user_id,
+        "title": title,
+        "source_type": source_type,
+        "source_url": source_url,
+        "created_at": datetime.utcnow(),
+        "transcription": transcription,
+        "size": file_size
+    })
+
+    # Store chunks for retrieval
+    chunk_docs = [{"session_id": session_id, "text": chunk} for chunk in splits]
+    chunks_collection.insert_many(chunk_docs)
+
+    # Initialize chat history in Mongo
+    chat_manager.initialize_chat_history(session_id)
+
+    return session_id
+
+
+def get_retriever(session_id: str):
+    """
+    Build a Retriever by loading chunks from MongoDB and creating a FAISS vectorstore.
+    """
+    # Fetch stored text splits
+    docs = [doc["text"] for doc in chunks_collection.find({"session_id": session_id})]
+    if not docs:
+        raise HTTPException(status_code=404, detail="Session data not found. Please transcribe first.")
+
+    # Create embeddings and vectorstore
+    embeddings = get_embeddings()
+    vectorstore = FAISS.from_texts(docs, embeddings)
+    return vectorstore.as_retriever(search_kwargs={"k": 3})
+
+
+def save_video_file(video_id: str, file_path: str, contents: bytes) -> None:
+    """
+    Persist the uploaded video file to disk.
+    """
+    os.makedirs(os.path.dirname(file_path), exist_ok=True)
+    with open(file_path, "wb") as f:
+        f.write(contents)

app/utils/helpers.py

@@ -0,0 +1,6 @@
+# Generic helper functions
+
+def chunk_list(lst, size):
+    """Yield successive chunks from list."""
+    for i in range(0, len(lst), size):
+        yield lst[i:i+size]

asgi.py

@@ -0,0 +1,2 @@
+# asgi.py
+from app.main import app

requirements.txt

@@ -0,0 +1,124 @@
+aiohappyeyeballs==2.6.1
+aiohttp==3.12.13
+aiosignal==1.4.0
+annotated-types==0.7.0
+anyio==4.9.0
+arrow==1.3.0
+attrs==25.3.0
+bcrypt==4.3.0
+cachetools==5.5.2
+certifi==2025.6.15
+cffi==1.17.1
+charset-normalizer==3.4.2
+circuitbreaker==2.1.3
+click==8.0.4
+cryptography==44.0.3
+dataclasses-json==0.6.7
+distro==1.9.0
+dnspython==2.7.0
+email_validator==2.2.0
+faiss-cpu==1.11.0
+fastapi==0.116.0
+filelock==3.18.0
+frozenlist==1.7.0
+fsspec==2025.5.1
+google-auth==2.40.3
+google-genai==1.24.0
+greenlet==3.2.3
+groq==0.29.0
+h11==0.16.0
+hf-xet==1.1.5
+httpcore==1.0.9
+httpx==0.28.1
+httpx-sse==0.4.1
+huggingface-hub==0.33.2
+idna==3.10
+Jinja2==3.1.6
+jmespath==0.10.0
+joblib==1.5.1
+jsonpatch==1.33
+jsonpointer==3.0.0
+langchain==0.3.26
+langchain-community==0.3.27
+langchain-core==0.3.68
+langchain-groq==0.3.5
+langchain-huggingface==0.3.0
+langchain-mongodb==0.6.2
+langchain-text-splitters==0.3.8
+langsmith==0.4.4
+lark==1.2.2
+MarkupSafe==3.0.2
+marshmallow==3.26.1
+mpmath==1.3.0
+multidict==6.6.3
+mypy_extensions==1.1.0
+networkx==3.5
+numpy==2.3.1
+nvidia-cublas-cu12==12.6.4.1
+nvidia-cuda-cupti-cu12==12.6.80
+nvidia-cuda-nvrtc-cu12==12.6.77
+nvidia-cuda-runtime-cu12==12.6.77
+nvidia-cudnn-cu12==9.5.1.17
+nvidia-cufft-cu12==11.3.0.4
+nvidia-cufile-cu12==1.11.1.6
+nvidia-curand-cu12==10.3.7.77
+nvidia-cusolver-cu12==11.7.1.2
+nvidia-cusparse-cu12==12.5.4.2
+nvidia-cusparselt-cu12==0.6.3
+nvidia-nccl-cu12==2.26.2
+nvidia-nvjitlink-cu12==12.6.85
+nvidia-nvtx-cu12==12.6.77
+oci==2.155.0
+oci-cli==3.62.0
+orjson==3.10.18
+packaging==24.2
+passlib==1.7.4
+pillow==11.3.0
+prompt-toolkit==3.0.43
+propcache==0.3.2
+pyasn1==0.6.1
+pyasn1_modules==0.4.2
+pycparser==2.22
+pydantic==2.11.7
+pydantic-settings==2.10.1
+pydantic_core==2.33.2
+PyJWT==2.10.1
+pymongo==4.13.2
+pyOpenSSL==24.3.0
+python-dateutil==2.9.0.post0
+python-dotenv==1.1.1
+python-multipart==0.0.20
+pytz==2025.2
+PyYAML==6.0.2
+regex==2024.11.6
+requests==2.32.4
+requests-toolbelt==1.0.0
+rsa==4.9.1
+safetensors==0.5.3
+scikit-learn==1.7.0
+scipy==1.16.0
+sentence-transformers==5.0.0
+setuptools==80.9.0
+six==1.17.0
+sniffio==1.3.1
+SQLAlchemy==2.0.41
+starlette==0.46.2
+sympy==1.14.0
+tenacity==8.5.0
+terminaltables==3.1.10
+threadpoolctl==3.6.0
+tokenizers==0.21.2
+torch==2.7.1
+tqdm==4.67.1
+transformers==4.53.1
+triton==3.3.1
+types-python-dateutil==2.9.0.20250516
+typing-inspect==0.9.0
+typing-inspection==0.4.1
+typing_extensions==4.14.1
+urllib3==2.5.0
+uvicorn==0.35.0
+wcwidth==0.2.13
+websockets==15.0.1
+yarl==1.20.1
+zstandard==0.23.0

vercel.json

@@ -0,0 +1,9 @@
+{
+  "version": 2,
+  "builds": [
+    { "src": "asgi.py", "use": "@vercel/python" }
+  ],
+  "routes": [
+    { "src": "/(.*)", "dest": "asgi.py" }
+  ]
+}