Upload 16 files

.env

@@ -0,0 +1,20 @@
+GEMINI_API_KEY="AIzaSyDIhHusksgq0-NDavuzEXw-GuumFNQeQLc"
+QDRANT_URL=https://9e93ef90-73bd-4888-9073-5d9306f63035.us-east4-0.gcp.cloud.qdrant.io
+QDRANT_API_KEY=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJhY2Nlc3MiOiJtIn0.-tM0TkZqigtSpE-GD4pPYpPWLhx2FKtxuBAHcnNnp8I
+
+# OpenRouter API Keys for rate limit rotation
+OPENROUTER_API_KEY_1="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"
+OPENROUTER_API_KEY_2="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"
+OPENROUTER_API_KEY_3="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"
+
+QDRANT_HOST=localhost
+QDRANT_PORT=6333
+QDRANT_COLLECTION_NAME=physical_ai_book
+
+# Main Model Configuration
+OPENROUTER_MODEL=nvidia/nemotron-nano-12b-v2-vl:free
+OPENROUTER_API_URL=https://openrouter.ai/api/v1/chat/completions
+
+# Translation Configuration
+TRANSLATION_API_KEY=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
+TRANSLATION_MODEL=nvidia/nemotron-nano-12b-v2-vl:free

app/core/database.py

@@ -0,0 +1,71 @@
+import os
+import requests
+from dotenv import load_dotenv
+
+load_dotenv()
+
+QDRANT_URL = os.getenv("QDRANT_URL")
+QDRANT_API_KEY = os.getenv("QDRANT_API_KEY")
+COLLECTION_NAME = "physical_ai_textbook"
+
+if not QDRANT_URL or not QDRANT_API_KEY:
+    raise ValueError("QDRANT_URL and QDRANT_API_KEY must be set in the .env file")
+
+# Ensure URL doesn't end with slash + handle if user put "https://" or not
+if not QDRANT_URL.startswith("http"):
+    QDRANT_URL = f"https://{QDRANT_URL}"
+QDRANT_URL = QDRANT_URL.rstrip("/")
+
+HEADERS = {
+    "api-key": QDRANT_API_KEY,
+    "Content-Type": "application/json"
+}
+
+def init_db():
+    """
+    Initializes the Qdrant collection via REST API.
+    """
+    # Check if collection exists
+    check_url = f"{QDRANT_URL}/collections/{COLLECTION_NAME}"
+    response = requests.get(check_url, headers=HEADERS)
+
+    if response.status_code == 200:
+        print(f"Collection {COLLECTION_NAME} already exists.")
+    else:
+        print(f"Creating collection: {COLLECTION_NAME}")
+        # Create collection
+        create_url = f"{QDRANT_URL}/collections/{COLLECTION_NAME}"
+        payload = {
+            "vectors": {
+                "size": 768,
+                "distance": "Cosine"
+            }
+        }
+        resp = requests.put(create_url, headers=HEADERS, json=payload)
+        if resp.status_code == 200:
+            print("Collection created successfully.")
+        else:
+            print(f"Error creating collection: {resp.text}")
+
+def search_points(vector, limit=5):
+    url = f"{QDRANT_URL}/collections/{COLLECTION_NAME}/points/search"
+    payload = {
+        "vector": vector,
+        "limit": limit,
+        "with_payload": True
+    }
+    response = requests.post(url, headers=HEADERS, json=payload)
+    if response.status_code == 200:
+        return response.json().get("result", [])
+    else:
+        print(f"Search Error: {response.text}")
+        return []
+
+def upsert_points(points):
+    url = f"{QDRANT_URL}/collections/{COLLECTION_NAME}/points?wait=true"
+    payload = {
+        "points": points
+    }
+    response = requests.put(url, headers=HEADERS, json=payload)
+    if response.status_code != 200:
+        print(f"Upsert Error: {response.text}")

app/main.py

@@ -0,0 +1,125 @@
+from contextlib import asynccontextmanager
+from fastapi import FastAPI, HTTPException, BackgroundTasks
+from pydantic import BaseModel
+from typing import Optional
+import os
+from app.core.database import init_db
+from app.services.document_processor import process_and_index_documents
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    # Startup
+    init_db()
+    yield
+    # Shutdown (if needed)
+
+app = FastAPI(title="Physical AI Textbook RAG Chatbot", version="1.0.0", lifespan=lifespan)
+
+from fastapi.middleware.cors import CORSMiddleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["http://localhost:3000", "http://localhost:3001", "http://localhost:3002", "http://localhost:8000", "*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+class AskRequest(BaseModel):
+    query: str
+    selected_text: Optional[str] = None
+    personalization_context: Optional[str] = None
+    translate_urdu: bool = False
+
+class AskResponse(BaseModel):
+    answer: str
+    chapter: str
+    section: str
+    personalization_applied: bool
+    translated_urdu: bool
+
+class TranslateRequest(BaseModel):
+    text: str
+
+class TranslateResponse(BaseModel):
+    translated_text: str
+
+@app.get("/")
+async def root():
+    return {"message": "Welcome to the Physical AI RAG Chatbot API. Visit /docs for documentation."}
+
+@app.get("/health")
+async def health_check():
+    return {"status": "ok", "service": "Physical AI RAG Chatbot"}
+
+class PersonalizeRequest(BaseModel):
+    text: str
+    software_background: str
+    hardware_experience: str
+
+class PersonalizeResponse(BaseModel):
+    personalized_text: str
+
+@app.post("/ask", response_model=AskResponse)
+async def ask_question(request: AskRequest):
+    from app.services.chat_service import process_user_query # Import here to avoid circular dep if any
+
+    result = await process_user_query(
+        query=request.query,
+        selected_text=request.selected_text,
+        personalization=request.personalization_context,
+        translate_urdu=request.translate_urdu
+    )
+
+    return AskResponse(
+        answer=result["answer"],
+        chapter=result.get("chapter", "N/A"),
+        section=result.get("section", "N/A"),
+        personalization_applied=result["personalization_applied"],
+        translated_urdu=result["translated_urdu"]
+    )
+
+@app.post("/translate", response_model=TranslateResponse)
+async def translate_content(request: TranslateRequest):
+    from app.services.chat_service import translate_text
+    print(f"DEBUG: Received translation request with text length: {len(request.text)}")
+    print(f"DEBUG: First 100 chars: {request.text[:100]}...")
+    translated = await translate_text(request.text)
+    print(f"DEBUG: Translation result length: {len(translated)}")
+    print(f"DEBUG: Translation result preview: {translated[:100]}...")
+    return TranslateResponse(translated_text=translated)
+
+@app.post("/personalize", response_model=PersonalizeResponse)
+async def personalize(request: PersonalizeRequest):
+    from app.services.chat_service import personalize_content
+    result = await personalize_content(
+        text=request.text,
+        software_bg=request.software_background,
+        hardware_exp=request.hardware_experience
+    )
+    return PersonalizeResponse(personalized_text=result)
+
+
+
+@app.post("/reload-documents")
+async def reload_documents(background_tasks: BackgroundTasks):
+    # Path to book docs relative to this file
+    # current file is app/main.py. Working dir when running is usually backend/
+    # Docs are at ../book-docs/docs
+
+    # Robust path finding
+    base_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) # backend/
+    # Need to go up from backend -> rag-chatbot -> physical_ai_book -> book-docs
+    docs_path = os.path.join(base_dir, "..", "..", "book-docs", "docs")
+    docs_path = os.path.abspath(docs_path)
+
+    if not os.path.exists(docs_path):
+        raise HTTPException(status_code=404, detail=f"Docs directory not found at {docs_path}")
+
+    # Trigger processing in background
+    background_tasks.add_task(process_and_index_documents, docs_path)
+    return {"status": "Indexing started in background. The chatbot will be fully ready in a few minutes."}
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run("app.main:app", host="0.0.0.0", port=8000, reload=True)

app/services/chat_service.py

@@ -0,0 +1,286 @@
+import os
+import requests
+import time
+import re
+from typing import Dict, Any, Optional, List
+from app.core.database import search_points
+from app.services.document_processor import get_embedding
+
+# OpenRouter Configuration
+OPENROUTER_API_KEY = os.getenv("OPENROUTER_API_KEY", "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")
+OPENROUTER_API_URL = "https://openrouter.ai/api/v1/chat/completions"
+
+# Primary chatbot model
+OPENROUTER_MODEL = "nvidia/nemotron-nano-12b-v2-vl:free"
+
+# Add simple in-memory cache for search results
+search_cache = {}
+
+def search_documents(query: str, limit: int = 5) -> str:
+    # Create cache key from query and limit
+    cache_key = f"{query[:100]}_{limit}"
+
+    # Check if result is already cached
+    if cache_key in search_cache:
+        return search_cache[cache_key]
+
+    try:
+        query_vector = get_embedding(query)
+        hits = search_points(query_vector, limit)
+        context_text = ""
+        for hit in hits:
+            payload = hit.get("payload", {})
+            source = payload.get("source", "Unknown")
+            text = payload.get("text", "")
+            context_text += f"\n[Source: {source}]\n{text}\n"
+
+        # Cache the result
+        search_cache[cache_key] = context_text
+
+        return context_text
+    except Exception as e:
+        print(f"SEARCH ERROR: {e}")
+        return ""
+
+# Add cache for answer generation
+answer_cache = {}
+
+def generate_answer(query: str, context: str, personalization: Optional[str] = None, translate_urdu: bool = False) -> Dict[str, Any]:
+    # Create cache key
+    cache_key = f"{query[:50]}_{len(context)}_{bool(personalization)}_{translate_urdu}"
+
+    # Check if result is already cached
+    if cache_key in answer_cache:
+        print(f"DEBUG: Using cached answer for query: {query[:50]}...")
+        return answer_cache[cache_key]
+
+    print(f"DEBUG: Generating answer for query: {query[:50]}...")
+
+    system_instruction = """
+    You are an AI assistant for the 'Physical AI & Humanoid Robotics' textbook.
+
+    Identity Rules:
+    - If anyone asks 'Who created you?', 'Who is your developer?', or about your origin, ALWAYS answer: "Mujhe Fiza ❤️ ne banaya hai, jo ek nihayat hi talented programmer, Full-Stack Web Developer, aur AI Automation Specialist hain. Unho ne mujhe bari mehnat aur lagan se develop kiya hai taake main aapki behtar rehnumai kar sakoon."
+
+    Guidance Rules:
+    1. Answer using ONLY the provided context from the book.
+    2. Tell the user: "Main sirf is book mein se aapki guide karungi." if they ask generic questions.
+    3. If the user asks in English, answer in English.
+    4. If the user asks in Roman Urdu (like 'kya haal hai', 'robot kya hai'), answer in Roman Urdu.
+    5. Mention the chapter/section if available.
+    6. If not in context, say: "Ye information book mein nahi hai."
+    """
+    
+    # CRITICAL: If Urdu Mode is ON, strictly use Urdu Script (Rasm-ul-Khat)
+    if translate_urdu:
+        system_instruction += "\n\nCRITICAL: Urdu Mode is ON. You MUST provide the final response in beautiful Urdu Script (Rasm-ul-Khat), not Roman Urdu."
+    
+    if personalization:
+        system_instruction += f"\n\nUser Context: {personalization}"
+
+    payload = {
+        "model": OPENROUTER_MODEL,
+        "messages": [
+            {"role": "system", "content": system_instruction},
+            {"role": "user", "content": f"Context: {context}\n\nQuestion: {query}"}
+        ],
+        "temperature": 0.4 # Slightly lower for more factual technical answers
+    }
+
+    headers = {
+        "Authorization": f"Bearer {OPENROUTER_API_KEY}",
+        "Content-Type": "application/json",
+        "HTTP-Referer": "http://localhost:8000",
+        "X-Title": "Physical AI Book"
+    }
+
+    # Standard retry for 429 or connection issues
+    for attempt in range(3):  # Reduced attempts for faster response
+        try:
+            print(f"DEBUG: Attempting AI Request {attempt + 1}")
+            response = requests.post(OPENROUTER_API_URL, json=payload, headers=headers, timeout=30)  # Reduced timeout
+
+            if response.status_code == 200:
+                data = response.json()
+                if "choices" in data and len(data["choices"]) > 0:
+                    answer_text = data["choices"][0]["message"]["content"]
+                    print("DEBUG: AI Success")
+
+                    result = {
+                        "answer": answer_text,
+                        "chapter": "Textbook",
+                        "section": "Relevant Section",
+                        "personalization_applied": bool(personalization),
+                        "translated_urdu": translate_urdu
+                    }
+
+                    # Cache the result
+                    answer_cache[cache_key] = result
+                    return result
+                else:
+                    print(f"DEBUG: Unexpected Response Format: {data}")
+
+            elif response.status_code == 429:
+                print(f"DEBUG: 429 Rate Limit. Waiting {3 * (attempt + 1)}s...")  # Reduced wait time
+                time.sleep(3 * (attempt + 1))
+                continue
+            else:
+                print(f"DEBUG: API Error {response.status_code}: {response.text}")
+                time.sleep(1)  # Reduced wait time
+        except Exception as e:
+            print(f"DEBUG: Request Exception: {str(e)}")
+            time.sleep(1)  # Reduced wait time
+            continue
+
+    return {
+        "answer": "🤖 The AI is currently busy or reaching its limit. Please try again in 10-15 seconds.",
+        "chapter": "N/A", "section": "N/A", "personalization_applied": False, "translated_urdu": False
+    }
+
+async def process_user_query(query: str, selected_text: Optional[str], personalization: Optional[str], translate_urdu: bool):
+    # Greeting logic
+    query_lower = query.lower().strip()
+    greetings = ['hello', 'hi', 'salam', 'hey', 'aoa', 'hy', 'helo']
+    creator_queries = ['who created you', 'who is your creator', 'who developed you', 'aapko kis ne banaya', 'tumhe kis ne banaya', 'creator']
+
+    if any(q in query_lower for q in creator_queries):
+        return {
+            "answer": "**Fiza ❤️** is a highly skilled and talented professional with expertise in:\n\n• **Senior Full-Stack Web Developer** - Specialized in modern web technologies\n• **AI Automation Specialist** - Creating intelligent systems and chatbots\n• **Machine Learning Engineer** - Developing AI solutions for complex problems\n• **Software Architect** - Designing scalable and efficient systems\n\nShe has dedicated considerable time and effort to create me, ensuring I can provide you with the best guidance for learning Physical AI & Humanoid Robotics. Her passion for technology and education shines through in every interaction I have with you! 🌟",
+            "chapter": "Identity", "section": "Creator", "personalization_applied": False, "translated_urdu": False
+        }
+
+    if any(g == query_lower or query_lower.startswith(g + " ") for g in greetings) and not selected_text:
+        return {
+            "answer": "👋 **السلام علیکم!** Welcome to the Physical AI & Humanoid Robotics Learning Assistant. I'm here to guide you through this comprehensive textbook on robotics, AI, and humanoid systems. You can ask me anything about:\n\n• ROS 2 and robotic control systems\n• Gazebo & Unity simulation\n• NVIDIA Isaac platform\n• Vision-Language-Action (VLA) systems\n• Humanoid robotics fundamentals\n\nWhat would you like to explore today? 🚀",
+            "chapter": "Intro", "section": "Welcome", "personalization_applied": False, "translated_urdu": False
+        }
+
+    if selected_text:
+        context = f"Selected Text from Book: {selected_text}"
+    else:
+        context = search_documents(query)
+        if not context.strip():
+            return {
+                "answer": "Maazrat, ye information is book mein cover nahi hai. Please robotics ya Physical AI se mutaliq sawal poochein.",
+                "chapter": "N/A", "section": "N/A", "personalization_applied": False, "translated_urdu": False
+            }
+
+    return generate_answer(query, context, personalization, translate_urdu)
+
+async def translate_text(text: str) -> str:
+    """
+    Instantly translate full chapter text
+    Uses the specified model and API key for translation
+    """
+    import time
+    start_time = time.time()
+
+    # Back to the model you preferred
+    model = "nvidia/nemotron-nano-12b-v2-vl:free"
+    api_key = os.getenv("TRANSLATION_API_KEY", "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")
+    api_url = "https://openrouter.ai/api/v1/chat/completions"
+
+    # SIGNIFICANTLY INCREASED LENGTH as requested
+    max_length = 15000  # Increased to 15000 for full chapters
+    text_to_translate = text[:max_length]
+
+    prompt = f"""
+    Translate the following technical textbook content into professional Urdu script (Rasm-ul-Khat).
+    Maintain HTML tags and formatting. Respond with ONLY the translated Urdu HTML.
+    Keep the same structure and formatting as the original.
+
+    Content to translate:
+    {text_to_translate}
+    """
+
+    payload = {
+        "model": model,
+        "messages": [{"role": "user", "content": prompt}],
+        "temperature": 0.2,
+        "max_tokens": 8000, # Increased tokens for longer output
+    }
+
+    try:
+        headers = {
+            "Authorization": f"Bearer {api_key}",
+            "Content-Type": "application/json",
+            "HTTP-Referer": "http://localhost:8000",
+            "X-Title": "Physical AI Book Translation"
+        }
+
+        response = requests.post(api_url, json=payload, headers=headers, timeout=60)
+
+        if response.status_code == 200:
+            data = response.json()
+            if "choices" in data and len(data["choices"]) > 0:
+                content = data["choices"][0]["message"]["content"]
+                result = content.replace("```html", "").replace("```", "").strip()
+
+                end_time = time.time()
+                print(f"DEBUG: Translation completed in {end_time - start_time:.2f} seconds")
+
+                return result
+            else:
+                return "Translation failed: No response content"
+        elif response.status_code == 429:
+            return "Maazrat, OpenRouter ki limit khatam ho chuki hai."
+        else:
+            return "Translation failed due to API error."
+
+    except Exception as e:
+        print(f"DEBUG: Translation error: {str(e)}")
+        return f"Translation failed: {str(e)}"
+async def personalize_content(text: str, software_bg: str, hardware_exp: str) -> str:
+    # Use the same model and API key as translation for consistency
+    p_model = os.getenv("OPENROUTER_MODEL", "nvidia/nemotron-nano-12b-v2-vl:free")
+    api_key = os.getenv("OPENROUTER_API_KEY_1", "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")
+    api_url = os.getenv("OPENROUTER_API_URL", "https://openrouter.ai/api/v1/chat/completions")
+
+    prompt = f"""
+    Personalize the following technical textbook content for a student with this profile:
+    - Software Background: {software_bg}
+    - Hardware Experience: {hardware_exp}
+
+    Guidelines:
+    1. If they are Beginners, simplify technical jargon and add relatable analogies.
+    2. If they are Experts, keep it concise and focus on advanced integration/ROS nodes.
+    3. Maintain the original HTML structure and tags.
+    4. Keep the output in English (unless the input is Urdu).
+
+    Content to Personalize:
+    {text[:4000]}
+    """
+
+    payload = {
+        "model": p_model,
+        "messages": [{"role": "user", "content": prompt}],
+        "temperature": 0.5,
+        "max_tokens": 2000,
+        "top_p": 0.9
+    }
+
+    try:
+        headers = {
+            "Authorization": f"Bearer {api_key}",
+            "Content-Type": "application/json",
+            "HTTP-Referer": "http://localhost:8000",
+            "X-Title": "Physical AI Book Personalization"
+        }
+
+        response = requests.post(api_url, json=payload, headers=headers, timeout=45)
+        if response.status_code == 200:
+            content = response.json()["choices"][0]["message"]["content"]
+            return content.replace("```html", "").replace("```", "").strip()
+        elif response.status_code == 429:
+            print("DEBUG: Personalization rate limited")
+            return "Personalization is temporarily unavailable due to rate limits. Displaying standard content."
+        else:
+            print(f"Personalization API Error: {response.status_code}")
+            return "Personalization failed. Displaying standard content."
+
+    except requests.exceptions.Timeout:
+        print("Personalization request timed out")
+        return "Personalization is taking longer than expected. Displaying standard content."
+    except Exception as e:
+        print(f"Personalization Error: {e}")
+        return "Personalization failed. Displaying standard content."

app/services/document_processor.py

@@ -0,0 +1,138 @@
+import os
+import glob
+import time
+from typing import List
+import requests
+import uuid
+import json
+from app.core.database import upsert_points
+
+# Configure Gemini
+GOOGLE_API_KEY = os.getenv("GEMINI_API_KEY") or os.getenv("GOOGLE_API_KEY")
+
+if not GOOGLE_API_KEY:
+    raise ValueError("GEMINI_API_KEY must be set in .env")
+
+# Using Gemini 1.5 Flash for Embeddings (REST API)
+# Official Endpoint: https://generativelanguage.googleapis.com/v1beta/models/text-embedding-004:embedContent
+EMBEDDING_API_URL = f"https://generativelanguage.googleapis.com/v1beta/models/text-embedding-004:embedContent?key={GOOGLE_API_KEY}"
+
+def get_embedding(text: str) -> List[float]:
+    """
+    Generates embedding using Gemini REST API with retry logic for rate limits.
+    """
+    payload = {
+        "model": "models/text-embedding-004",
+        "content": {
+            "parts": [{"text": text}]
+        }
+    }
+    
+    # Retry logic with exponential backoff
+    max_retries = 3
+    retry_delay = 1
+    
+    for attempt in range(max_retries):
+        try:
+            response = requests.post(EMBEDDING_API_URL, json=payload, headers={"Content-Type": "application/json"}, timeout=30)
+            
+            if response.status_code == 200:
+                data = response.json()
+                return data["embedding"]["values"]
+                
+            elif response.status_code == 429:
+                # Rate limit - retry with backoff
+                if attempt < max_retries - 1:
+                    print(f"Embedding rate limit. Retrying in {retry_delay}s...")
+                    time.sleep(retry_delay)
+                    retry_delay *= 2
+                    continue
+                else:
+                    raise Exception("Rate limit exceeded after retries")
+                    
+            else:
+                print(f"Embedding Error ({response.status_code}): {response.text}")
+                raise Exception(f"Failed to generate embedding: {response.status_code}")
+                
+        except requests.exceptions.Timeout:
+            if attempt < max_retries - 1:
+                print(f"Embedding timeout. Retrying in {retry_delay}s...")
+                time.sleep(retry_delay)
+                retry_delay *= 2
+                continue
+            else:
+                raise Exception("Embedding request timed out after retries")
+                
+        except Exception as e:
+            if attempt < max_retries - 1 and "rate limit" in str(e).lower():
+                time.sleep(retry_delay)
+                retry_delay *= 2
+                continue
+            raise
+
+def load_markdown_files(docs_path: str) -> List[dict]:
+    files = []
+    search_path = os.path.join(docs_path, "**/*.md")
+    for filepath in glob.glob(search_path, recursive=True):
+        with open(filepath, 'r', encoding='utf-8') as f:
+            content = f.read()
+            filename = os.path.basename(filepath)
+            files.append({
+                "content": content,
+                "source": filename,
+                "path": filepath
+            })
+    return files
+
+def chunk_text(text: str, chunk_size: int = 2000, overlap: int = 100) -> List[str]:
+    chunks = []
+    start = 0
+    while start < len(text):
+        end = start + chunk_size
+        chunk = text[start:end]
+        chunks.append(chunk)
+        start += (chunk_size - overlap)
+    return chunks
+
+def process_and_index_documents(docs_path: str):
+    print(f"Loading documents from: {docs_path}")
+    documents = load_markdown_files(docs_path)
+    print(f"Found {len(documents)} markdown files.")
+
+    points_batch = []
+    
+    for doc in documents:
+        chunks = chunk_text(doc["content"])
+        
+        for i, chunk in enumerate(chunks):
+            try:
+                embedding = get_embedding(chunk)
+                
+                # Create Point Structure for Qdrant REST API
+                point = {
+                    "id": str(uuid.uuid4()),
+                    "vector": embedding,
+                    "payload": {
+                        "text": chunk,
+                        "source": doc["source"],
+                        "path": doc["path"],
+                        "chunk_id": i
+                    }
+                }
+                points_batch.append(point)
+                
+                # Upload in batches of 50 to avoid big payloads
+                if len(points_batch) >= 50:
+                    upsert_points(points_batch)
+                    points_batch = []
+                    print(".", end="", flush=True)
+
+            except Exception as e:
+                print(f"Error processing chunk in {doc['source']}: {e}")
+
+    # Upload remaining
+    if points_batch:
+        upsert_points(points_batch)
+
+    print("\nUpload complete!")
+    return {"status": "success"}

debug_db.py

@@ -0,0 +1,41 @@
+import requests
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
+QDRANT_URL = os.getenv("QDRANT_URL")
+QDRANT_API_KEY = os.getenv("QDRANT_API_KEY")
+COLLECTION_NAME = "physical_ai_textbook"
+
+if not QDRANT_URL.startswith("http"):
+    QDRANT_URL = f"https://{QDRANT_URL}"
+QDRANT_URL = QDRANT_URL.rstrip("/")
+
+HEADERS = {
+    "api-key": QDRANT_API_KEY,
+    "Content-Type": "application/json"
+}
+
+def check_collection():
+    print(f"Checking collection: {COLLECTION_NAME} at {QDRANT_URL}")
+    url = f"{QDRANT_URL}/collections/{COLLECTION_NAME}"
+    response = requests.get(url, headers=HEADERS)
+    
+    if response.status_code == 200:
+        data = response.json()
+        print("Collection Info:")
+        print(f"Status: {data.get('status')}")
+        print(f"Points Count: {data.get('result', {}).get('points_count', 'Unknown')}")
+        print(f"Vectors Count: {data.get('result', {}).get('vectors_count', 'Unknown')}")
+    else:
+        print(f"Error accessing collection: {response.status_code} - {response.text}")
+
+def test_search(query_text="physical ai"):
+    print(f"\nTesting search for: '{query_text}'")
+    # We need to generate an embedding first, but we can't easily do that here without the full app setup.
+    # However, we can check if the collection *has* points first.
+    pass
+
+if __name__ == "__main__":
+    check_collection()

debug_search.py

@@ -0,0 +1,41 @@
+from app.services.document_processor import get_embedding
+from app.core.database import search_points
+import sys
+
+def debug_search(query):
+    print(f"--- Debugging Search for: '{query}' ---")
+    
+    # 1. Generate Embedding
+    print("Generating embedding...")
+    try:
+        vector = get_embedding(query)
+        print("Embedding generated successfully.")
+    except Exception as e:
+        print(f"FAILED to generate embedding: {e}")
+        return
+
+    # 2. Search Qdrant
+    print("Searching Qdrant...")
+    results = search_points(vector, limit=3)
+    
+    print(f"Found {len(results)} matches.")
+    
+    if not results:
+        print("NO MATCHES FOUND. Check Qdrant connection or data.")
+        return
+
+    for i, hit in enumerate(results):
+        score = hit.get("score", "N/A")
+        payload = hit.get("payload", {})
+        source = payload.get("source", "Unknown")
+        text = payload.get("text", "")[:200] # Show first 200 chars
+        
+        print(f"\nMatch #{i+1} (Score: {score}):")
+        print(f"Source: {source}")
+        print(f"Text Snippet: {text}...")
+
+if __name__ == "__main__":
+    query = "What is Physical AI?"
+    if len(sys.argv) > 1:
+        query = sys.argv[1]
+    debug_search(query)

list_models.py

@@ -0,0 +1,22 @@
+import os
+import requests
+from dotenv import load_dotenv
+
+load_dotenv()
+
+GOOGLE_API_KEY = os.getenv("GEMINI_API_KEY") or os.getenv("GOOGLE_API_KEY")
+
+def list_models():
+    url = f"https://generativelanguage.googleapis.com/v1beta/models?key={GOOGLE_API_KEY}"
+    response = requests.get(url)
+    if response.status_code == 200:
+        models = response.json().get('models', [])
+        print("Available models:")
+        for m in models:
+            if 'generateContent' in m['supportedGenerationMethods']:
+                print(f" - {m['name']}")
+    else:
+        print(f"Error listing models: {response.text}")
+
+if __name__ == "__main__":
+    list_models()

requirements.txt

@@ -0,0 +1,5 @@
+fastapi
+uvicorn
+python-dotenv
+requests
+pydantic

test_api.py

@@ -0,0 +1,44 @@
+import os
+import requests
+
+# Load the API key from environment
+api_key = os.getenv("TRANSLATION_API_KEY", "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")
+model = os.getenv("TRANSLATION_MODEL", "allenai/olmo-3.1-32b-think:free")
+
+print(f"Testing API key: {api_key[:10]}...")  # Only show first 10 chars for security
+print(f"Testing model: {model}")
+
+headers = {
+    "Authorization": f"Bearer {api_key}",
+    "Content-Type": "application/json",
+}
+
+payload = {
+    "model": model,
+    "messages": [
+        {"role": "user", "content": "Hello, how are you?"}
+    ]
+}
+
+try:
+    response = requests.post(
+        "https://openrouter.ai/api/v1/chat/completions",
+        json=payload,
+        headers=headers,
+        timeout=30
+    )
+    
+    print(f"Status Code: {response.status_code}")
+    print(f"Response: {response.text}")
+    
+    if response.status_code == 200:
+        print("\n✅ API key is working correctly!")
+    else:
+        print(f"\n❌ API returned error: {response.status_code}")
+        print("This might indicate:")
+        print("1. API key has reached daily limit")
+        print("2. Model is not available")
+        print("3. API key is invalid")
+        
+except Exception as e:
+    print(f"\n❌ Error making API request: {str(e)}")

test_rag.py

@@ -0,0 +1,58 @@
+import requests
+import time
+
+BASE_URL = "http://127.0.0.1:8000"
+
+def test_api():
+    print("--- Testing RAG Chatbot API ---")
+
+    # 1. Health Check
+    try:
+        response = requests.get(f"{BASE_URL}/health")
+        if response.status_code == 200:
+            print("[OK] Health Check Passed!")
+        else:
+            print(f"[FAIL] Health Check Failed: {response.text}")
+            return
+    except requests.exceptions.ConnectionError:
+        print("[FAIL] Could not connect to server. Is it running?")
+        return
+
+    # 2. Reload Documents (Indexing) - SKIPPING TO AVOID RE-TRIGGERING
+    print("\nSkipping Indexing for this test run...")
+    # try:
+    #     response = requests.post(f"{BASE_URL}/reload-documents")
+    #     if response.status_code == 200:
+    #         print(f"[OK] Indexing Response: {response.json()}")
+    #     else:
+    #         print(f"[FAIL] Indexing Failed: {response.text}")
+    # except Exception as e:
+    #     print(f"[FAIL] Error during indexing: {e}")
+
+    # 3. Ask a Question
+    print("\nAsking: 'What is Physical AI?'...")
+    payload = {
+        "query": "What is Physical AI?",
+        "translate_urdu": False
+    }
+    
+    try:
+        start_time = time.time()
+        response = requests.post(f"{BASE_URL}/ask", json=payload)
+        duration = time.time() - start_time
+        
+        if response.status_code == 200:
+            data = response.json()
+            print(f"[OK] Answer ({duration:.2f}s):")
+            print(f"Answer: {data['answer']}")
+            print(f"Sources: {data['chapter']} / {data['section']}")
+        else:
+            print(f"[FAIL] Ask Failed: {response.text}")
+
+    except Exception as e:
+        print(f"[FAIL] Error during asking: {e}")
+
+if __name__ == "__main__":
+    test_api()
+
+

test_translation.py

@@ -0,0 +1,48 @@
+import os
+import requests
+
+# Load the API key from environment
+api_key = os.getenv("TRANSLATION_API_KEY", "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")
+model = os.getenv("TRANSLATION_MODEL", "allenai/olmo-3.1-32b-think:free")
+
+print(f"Testing translation with API key: {api_key[:10]}...")  
+print(f"Testing model: {model}")
+
+headers = {
+    "Authorization": f"Bearer {api_key}",
+    "Content-Type": "application/json",
+}
+
+# Simple translation prompt
+payload = {
+    "model": model,
+    "messages": [
+        {"role": "user", "content": "Translate this to Urdu: Hello, how are you?"}
+    ],
+    "temperature": 0.3
+}
+
+try:
+    response = requests.post(
+        "https://openrouter.ai/api/v1/chat/completions",
+        json=payload,
+        headers=headers,
+        timeout=30
+    )
+    
+    print(f"Status Code: {response.status_code}")
+    
+    if response.status_code == 200:
+        data = response.json()
+        if "choices" in data and len(data["choices"]) > 0:
+            content = data["choices"][0]["message"]["content"]
+            print(f"Translation Response: {content}")
+            print("\n✅ Translation API call successful!")
+        else:
+            print(f"\n❌ No choices in response: {data}")
+    else:
+        print(f"Response: {response.text}")
+        print(f"\n❌ Translation API returned error: {response.status_code}")
+        
+except Exception as e:
+    print(f"\n❌ Error making translation request: {str(e)}")