'Upload'

.gitignore

@@ -0,0 +1,3 @@
+.env 
+requirements.txt
+__pycache__/

Dockerfile

@@ -0,0 +1,20 @@
+
+FROM python:3.10
+
+# Pehle root user hai by default, to yahan packages install karo
+RUN apt-get update && apt-get install -y libgl1 libglib2.0-0
+
+# Ab user add karo aur switch karo
+RUN useradd -m -u 1000 user
+USER user
+ENV PATH="/home/user/.local/bin:$PATH"
+
+WORKDIR /app
+
+
+COPY --chown=user ./requirements.txt requirements.txt
+RUN pip install --no-cache-dir --upgrade -r requirements.txt
+
+
+COPY --chown=user . /app
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

app/api/query.py

@@ -0,0 +1,16 @@
+from fastapi import APIRouter, HTTPException
+from ..schemas import QueryRequest, QueryResponse
+from ..services.rag_service import get_rag_response
+
+router = APIRouter()
+
+@router.post("/query", response_model=QueryResponse)
+async def query_chatbot(request: QueryRequest):
+    try:
+        response_text, sources = await get_rag_response(request.message, request.selected_text)
+        return QueryResponse(response=response_text, sources=sources)
+    except Exception as e:
+        # Log the full error to the backend console for debugging
+        print(f"An unexpected error occurred: {e}")
+        # Return a generic but informative error to the frontend
+        raise HTTPException(status_code=500, detail=f"An internal error occurred in the backend: {e}")

app/api/translate.py

@@ -0,0 +1,55 @@
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+import os
+from google.generativeai import GenerativeModel
+
+# Define the request and response models for the translation endpoint
+class TranslationRequest(BaseModel):
+    text: str
+    target_language: str = "Urdu" # Default to Urdu as per the feature request
+
+class TranslationResponse(BaseModel):
+    translated_text: str
+
+# Initialize the router for the translation API
+router = APIRouter()
+
+# Configure Gemini API (ensure GEMINI_API_KEY is set in your environment)
+try:
+    gemini_api_key = os.getenv("GEMINI_API_KEY")
+    if not gemini_api_key:
+        raise ValueError("GEMINI_API_KEY environment variable not set for Python backend.")
+    # No direct 'configure' needed for this library version, key is passed to model
+except ValueError as e:
+    print(f"Configuration Error: {e}")
+    # This will cause an error when the model is initialized if the key is missing
+
+# Define the model to be used for translation
+GEMINI_TRANSLATION_MODEL = 'gemini-2.5-flash' # gemini-pro is excellent for translation tasks
+
+@router.post("/translate", response_model=TranslationResponse)
+async def translate_text(request: TranslationRequest):
+    """
+    Translates the given text to the target language using the Gemini API.
+    """
+    if not gemini_api_key:
+        raise HTTPException(status_code=500, detail="Server is not configured for translation (missing API key).")
+
+    model = GenerativeModel(GEMINI_TRANSLATION_MODEL)
+    
+    # Construct a clear and direct prompt for the translation task
+    prompt = f"Translate the following text to {request.target_language}:\n\n---\n{request.text}\n---"
+    
+    try:
+        print(f"Sending translation request to Gemini for target language: {request.target_language}")
+        response = await model.generate_content_async(prompt)
+        
+        # Extract the translated text from the response
+        translated_text = response.text.strip()
+        
+        print("Successfully received translation from Gemini.")
+        return TranslationResponse(translated_text=translated_text)
+
+    except Exception as e:
+        print(f"An unexpected error occurred during translation with Gemini: {e}")
+        raise HTTPException(status_code=500, detail=f"An internal error occurred during translation: {e}")

app/main.py

@@ -0,0 +1,17 @@
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from .api import query, translate  # Import the new translate router
+
+app = FastAPI()
+
+# Add CORS middleware to allow requests from the frontend
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # Allows all origins
+    allow_credentials=True,
+    allow_methods=["*"],  # Allows all methods
+    allow_headers=["*"],  # Allows all headers
+)
+
+app.include_router(query.router, prefix="/api")
+app.include_router(translate.router, prefix="/api") # Include the new translate router

app/schemas.py

@@ -0,0 +1,10 @@
+from typing import List, Optional
+from pydantic import BaseModel
+
+class QueryRequest(BaseModel):
+    message: str
+    selected_text: Optional[str] = None
+
+class QueryResponse(BaseModel):
+    response: str
+    sources: List[str]

app/services/embedding_service.py

@@ -0,0 +1,23 @@
+from sentence_transformers import SentenceTransformer
+from typing import List
+
+class EmbeddingService:
+    def __init__(self):
+        # Load the sentence-transformers model (all-MiniLM-L6-v2)
+        self.model = SentenceTransformer('all-MiniLM-L6-v2')
+
+    def encode(self, texts: List[str]) -> List[List[float]]:
+        """
+        Encodes a list of texts into embeddings.
+
+        Args:
+            texts: A list of strings to encode.
+            
+        Returns:
+            A list of embedding vectors.
+        """
+        if isinstance(texts, str):
+            texts = [texts] # Ensure texts is a list for batch processing
+        embeddings = self.model.encode(texts).tolist()
+        return embeddings
+

app/services/qdrant_service.py

@@ -0,0 +1,83 @@
+import os
+from qdrant_client import QdrantClient, models
+from typing import List, Dict, Any
+
+class QdrantService:
+    def __init__(self):
+        """
+        Initializes the QdrantService, setting up the client and ensuring the collection exists.
+        """
+        self.qdrant_url = os.getenv("QDRANT_URL")
+        self.qdrant_api_key = os.getenv("QDRANT_API_KEY")
+        self.collection_name = "textbook_chunks"
+        self.vector_size = 384  # Based on the all-MiniLM-L6-v2 model
+
+        if not self.qdrant_url:
+            raise ValueError("QDRANT_URL must be set in environment variables.")
+
+        # The QdrantClient can be initialized with or without an API key.
+        # If the key is None, it will connect to a local or unsecured Qdrant instance.
+        self.client = QdrantClient(
+            url=self.qdrant_url,
+            api_key=self.qdrant_api_key,
+        )
+        self.ensure_collection()
+
+    def ensure_collection(self):
+        """
+        Checks if the required collection exists in Qdrant and creates it if it doesn't.
+        """
+        try:
+            self.client.get_collection(collection_name=self.collection_name)
+            print(f"Collection '{self.collection_name}' already exists.")
+        except Exception:
+            print(f"Collection '{self.collection_name}' not found, creating it...")
+            self.client.recreate_collection(
+                collection_name=self.collection_name,
+                vectors_config=models.VectorParams(size=self.vector_size, distance=models.Distance.COSINE),
+            )
+            print(f"Collection '{self.collection_name}' created successfully.")
+
+    def upsert_chunks(self, ids: List[str], vectors: List[List[float]], payloads: List[Dict[str, Any]]):
+        if not (len(ids) == len(vectors) == len(payloads)):
+            raise ValueError("ids, vectors, and payloads must have the same length")
+
+        points = [
+            models.PointStruct(id=id_, vector=vector, payload=payload)
+            for id_, vector, payload in zip(ids, vectors, payloads)
+        ]
+
+        self.client.upsert(
+            collection_name=self.collection_name,
+            points=points,
+            wait=True
+        )
+        print(f"Upserted {len(points)} chunks successfully.")
+
+    def search(self, query_vector: List[float], limit: int = 5) -> List[Dict[str, Any]]:
+        """
+        Performs a vector search in the Qdrant collection.
+        
+        Args:
+            query_vector: The vector representation of the query.
+            limit: The maximum number of results to return.
+            
+        Returns:
+            A list of search results, each containing the payload and score.
+        """
+        print(f"Searching Qdrant with a vector...")
+        search_results = self.client.search(
+            collection_name=self.collection_name,
+            query_vector=query_vector,
+            limit=limit,
+            with_payload=True,  # Ensure the payload is returned with the results
+        )
+        
+        # The modern client returns ScoredPoint objects
+        results = [
+            {"payload": hit.payload, "score": hit.score}
+            for hit in search_results
+        ]
+        
+        print(f"Qdrant search completed. Found {len(results)} results.")
+        return results

app/services/rag_service.py

@@ -0,0 +1,78 @@
+import os
+from google.generativeai import GenerativeModel, configure
+from .embedding_service import EmbeddingService
+from .qdrant_service import QdrantService
+
+embedding_service = EmbeddingService()
+qdrant_service = QdrantService()
+
+# Configure Gemini API
+gemini_api_key = os.getenv("GEMINI_API_KEY")
+if not gemini_api_key:
+    raise ValueError("GEMINI_API_KEY environment variable not set for Python backend.")
+configure(api_key=gemini_api_key)
+GEMINI_GENERATIVE_MODEL = 'gemini-2.5-flash'
+
+async def get_rag_response(message: str, selected_text: str | None = None):
+    # The user's question is the primary query for search
+    query_text = message
+
+    # If text is selected, we use that to refine the search query
+    if selected_text:
+        query_text = f"User's question: '{message}' --- Context from selected text: '{selected_text}'"
+    
+    query_embedding = embedding_service.encode([query_text])[0]
+    search_results = qdrant_service.search(query_embedding)
+
+    # --- ENHANCED PROMPT CONSTRUCTION ---
+    prompt_parts = [
+        "You are a helpful expert assistant for the \"Physical AI & Humanoid Robotics\" textbook.",
+        "Your task is to answer the user's question. Use the provided context to form your answer.",
+        "Be concise, professional, and helpful. If the context does not contain the answer, say that you couldn't find the specific information in the provided materials, but try to answer based on your general knowledge of the topic if appropriate.",
+        "\n--- CONTEXT ---"
+    ]
+
+    # **CRITICAL FIX**: Prioritize the user's selected text by adding it to the context first.
+    if selected_text:
+        prompt_parts.append("\n**User-Selected Text:**\n")
+        prompt_parts.append(selected_text)
+        prompt_parts.append("\n---")
+    
+    # Add supplementary context from the vector search
+    context_chunks = [
+        hit["payload"].get("content") 
+        for hit in search_results 
+        if hit.get("payload") and hit["payload"].get("content")
+    ]
+    if context_chunks:
+        prompt_parts.append("\n**Relevant Excerpts from the Book:**\n")
+        prompt_parts.append("\n---\n".join(context_chunks))
+
+    # Handle the case where no context is found at all
+    if not selected_text and not context_chunks:
+        prompt_parts.append("\nNo specific context was provided or found.")
+
+    prompt_parts.append("\n--- END OF CONTEXT ---\n")
+    prompt_parts.append(f"**User's Question:**\n{message}\n\n**Answer:**\n")
+    
+    full_prompt = "\n".join(prompt_parts)
+
+    # Make LLM call to Gemini
+    model = GenerativeModel(GEMINI_GENERATIVE_MODEL)
+    try:
+        response = await model.generate_content_async(full_prompt)
+        response_text = response.text
+    except Exception as e:
+        print(f"Error calling Gemini API: {e}")
+        response_text = "An error occurred while generating the response."
+        
+    # Format sources for the frontend
+    sources = [
+        hit["payload"].get("source") 
+        for hit in search_results 
+        if hit.get("payload") and hit["payload"].get("source")
+    ]
+    unique_sources = list(set(sources))
+    formatted_sources = [f"{source}" for source in unique_sources]
+
+    return response_text, formatted_sources

app/utils/chunking.py

@@ -0,0 +1,52 @@
+import markdown
+import re
+from typing import List, Dict, Any
+
+def semantic_chunking(markdown_content: str, min_tokens: int = 100, max_tokens: int = 512, overlap_tokens: int = 50) -> List[Dict[str, Any]]:
+    """
+    Splits markdown content into semantic chunks, respecting heading boundaries.
+
+    Args:
+        markdown_content: The full markdown content of a document.
+        min_tokens: Minimum token count for a chunk.
+        max_tokens: Maximum token count for a chunk.
+        overlap_tokens: Number of tokens to overlap between chunks.
+
+    Returns:
+        A list of dictionaries, where each dictionary represents a chunk
+        and contains 'content' and 'metadata' (e.g., 'source', 'heading').
+    """
+    chunks = []
+    # This is a placeholder. A real implementation would involve tokenization
+    # and more sophisticated logic to respect headings and token limits.
+    # For now, we'll split by paragraphs as a simple approximation.
+    paragraphs = markdown_content.split('\n\n')
+
+    current_chunk_content = ""
+    current_heading = "Introduction" # Default heading
+
+    for paragraph in paragraphs:
+        if paragraph.strip().startswith('#'): # Detect a new heading
+            current_heading = paragraph.strip().lstrip('# ').strip()
+
+        # Simple token count approximation (word count)
+        paragraph_tokens = len(paragraph.split())
+
+        if len(current_chunk_content.split()) + paragraph_tokens > max_tokens:
+            if current_chunk_content.strip():
+                chunks.append({
+                    "content": current_chunk_content.strip(),
+                    "metadata": {"source": "unknown", "heading": current_heading}
+                })
+            current_chunk_content = paragraph
+        else:
+            current_chunk_content += "\n\n" + paragraph
+
+    if current_chunk_content.strip():
+        chunks.append({
+            "content": current_chunk_content.strip(),
+            "metadata": {"source": "unknown", "heading": current_heading}
+        })
+
+    return chunks
+

scripts/index_chapters.py

@@ -0,0 +1,49 @@
+import os
+import glob
+import uuid
+from dotenv import load_dotenv
+
+from backend.app.utils.chunking import semantic_chunking
+from backend.app.services.embedding_service import EmbeddingService
+from backend.app.services.qdrant_service import QdrantService
+
+load_dotenv()
+
+def index_chapters():
+    print("Starting chapter indexing...")
+
+    # Initialize services (assuming they can be initialized without FastAPI app context for script use)
+    embedding_service = EmbeddingService() # Assuming default constructor
+    qdrant_service = QdrantService()       # Assuming default constructor
+
+    chapter_files = glob.glob("frontend/docs/chapter-*.md")
+    if not chapter_files:
+        print("No chapter files found in website/docs/. Please ensure chapters exist.")
+        return
+
+    for file_path in chapter_files:
+        print(f"Processing {file_path}...")
+        with open(file_path, 'r', encoding='utf-8') as f:
+            markdown_content = f.read()
+
+        chunks = semantic_chunking(markdown_content)
+
+        for i, chunk in enumerate(chunks):
+            chunk_content = chunk["content"]
+            metadata = chunk["metadata"]
+            metadata["source"] = file_path # Update source to actual file path
+            metadata["chunk_number"] = i
+            
+            # Generate a unique UUID for the Qdrant point
+            point_id = str(uuid.uuid4())
+
+            # Generate embedding
+            embedding = embedding_service.encode([chunk_content])[0] # Pass as list and take first element
+
+            # Store in Qdrant
+            qdrant_service.upsert_chunks(ids=[point_id], vectors=[embedding], payloads=[metadata])
+
+    print("Chapter indexing completed.")
+
+if __name__ == "__main__":
+    index_chapters()