Add application file

DockerFile

@@ -0,0 +1,18 @@
+# Base image
+FROM python:3.11-slim
+
+# Set work directory
+WORKDIR /app
+
+# Install dependencies
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy project files
+COPY . .
+
+# Expose the port Hugging Face expects
+EXPOSE 7860
+
+# Command to run FastAPI with uvicorn
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860"]

app/config.py

@@ -0,0 +1,20 @@
+
+import os
+from pydantic_settings import BaseSettings
+from typing import Optional
+
+class Settings(BaseSettings):
+    OPENAI_API_KEY: Optional[str] = os.getenv("OPENAI_API_KEY", "")
+    DATABASE_URL: str = os.getenv("DATABASE_URL", "")
+    NEON_DATABASE_URL: str = os.getenv("NEON_DATABASE_URL", "")
+    QDRANT_URL: str = os.getenv("QDRANT_URL", "http://localhost:6333")
+    QDRANT_API_KEY: str = os.getenv("QDRANT_API_KEY", "")
+    OPENAI_MODEL_CHAT: str = "gpt-4o-mini"
+    OPENAI_MODEL_EMBEDDING: str = "text-embedding-3-small"
+    
+    class Config:
+        env_file = ".env"
+        env_file_encoding = "utf-8"
+        extra = "ignore"
+
+settings = Settings()

app/database.py

@@ -0,0 +1,30 @@
+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker
+from sqlalchemy.ext.declarative import declarative_base
+from app.config import settings
+
+# Use NEON_DATABASE_URL if available, otherwise fall back to DATABASE_URL or SQLite
+SQLALCHEMY_DATABASE_URL = settings.NEON_DATABASE_URL or settings.DATABASE_URL
+
+# If no database URL is provided or it's a placeholder, use SQLite as fallback
+if (not SQLALCHEMY_DATABASE_URL or 
+    SQLALCHEMY_DATABASE_URL.strip() == "" or 
+    "your_" in SQLALCHEMY_DATABASE_URL or
+    SQLALCHEMY_DATABASE_URL.startswith("postgresql://your") or
+    SQLALCHEMY_DATABASE_URL.startswith("postgres://your")):
+    SQLALCHEMY_DATABASE_URL = "sqlite:///./chat_database.db"
+    print("⚠️  No database URL configured, using SQLite as fallback")
+
+engine = create_engine(
+    SQLALCHEMY_DATABASE_URL, 
+    connect_args={"check_same_thread": False} if "sqlite" in SQLALCHEMY_DATABASE_URL else {}
+)
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+Base = declarative_base()
+
+def get_db():
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()

app/main.py

@@ -0,0 +1,43 @@
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from app.routes import chat
+from app.database import engine, Base
+from app.qdrant_client import init_qdrant_collection
+
+app = FastAPI(title="RAG Chatbot API")
+
+# CORS Configuration - Allow frontend to connect
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Include routers
+app.include_router(chat.router)
+
+@app.on_event("startup")
+async def startup_event():
+    # Create database tables
+    try:
+        Base.metadata.create_all(bind=engine)
+        print("✅ Database tables created successfully")
+    except Exception as e:
+        print(f"⚠️ Warning: Database initialization failed: {e}")
+    
+    # Initialize Qdrant collection
+    try:
+        init_qdrant_collection()
+    except Exception as e:
+        print(f"⚠️ Warning: Qdrant initialization failed: {e}")
+        print("   The API will still work but RAG features may be limited")
+
+@app.get("/")
+async def root():
+    return {"message": "RAG Chatbot API"}
+
+@app.get("/api/health")
+async def health():
+    return {"status": "ok"}

app/models/chat.py

@@ -0,0 +1,14 @@
+from sqlalchemy import Column, Integer, String, ForeignKey, DateTime, func
+from sqlalchemy.orm import relationship
+from app.database import Base
+
+class ChatHistory(Base):
+    __tablename__ = "chat_history"
+
+    id = Column(Integer, primary_key=True, index=True)
+    user_id = Column(Integer, ForeignKey("users.id"))
+    message = Column(String)
+    response = Column(String)
+    timestamp = Column(DateTime, default=func.now())
+
+    user = relationship("User")

app/models/user.py

@@ -0,0 +1,9 @@
+from sqlalchemy import Column, Integer, String
+from app.database import Base
+
+class User(Base):
+    __tablename__ = "users"
+
+    id = Column(Integer, primary_key=True, index=True)
+    username = Column(String, unique=True, index=True)
+    email = Column(String, unique=True, index=True)

app/qdrant_client.py

@@ -0,0 +1,40 @@
+import os
+from qdrant_client import QdrantClient
+from qdrant_client.models import Distance, VectorParams
+from app.config import settings
+
+# Initialize Qdrant client
+# Only pass api_key if it's actually set to avoid warning
+qdrant_kwargs = {"url": settings.QDRANT_URL}
+if settings.QDRANT_API_KEY and settings.QDRANT_API_KEY.strip():
+    qdrant_kwargs["api_key"] = settings.QDRANT_API_KEY
+
+qdrant_client = QdrantClient(**qdrant_kwargs)
+
+COLLECTION_NAME = "book_embeddings"
+
+def init_qdrant_collection():
+    """Initialize Qdrant collection if it doesn't exist"""
+    try:
+        # Check if collection exists
+        collections = qdrant_client.get_collections().collections
+        collection_names = [col.name for col in collections]
+        
+        if COLLECTION_NAME not in collection_names:
+            # Create collection with vector configuration
+            qdrant_client.create_collection(
+                collection_name=COLLECTION_NAME,
+                vectors_config=VectorParams(
+                    size=1536,  # OpenAI text-embedding-3-small dimension
+                    distance=Distance.COSINE
+                )
+            )
+            print(f"✅ Created Qdrant collection: {COLLECTION_NAME}")
+        else:
+            print(f"✅ Qdrant collection already exists: {COLLECTION_NAME}")
+    except Exception as e:
+        print(f"⚠️ Warning: Could not initialize Qdrant collection: {e}")
+
+def get_qdrant_client():
+    """Dependency to get Qdrant client"""
+    return qdrant_client

app/routes/chat.py

@@ -0,0 +1,60 @@
+
+
+
+
+from fastapi import APIRouter, Depends, HTTPException
+from qdrant_client import QdrantClient
+from app.qdrant_client import get_qdrant_client
+from app.schemas.chat import ChatRequest, ChatResponse, ChatSelectionRequest
+from app.services.rag_service import RAGService
+from app.services.embeddings_service import EmbeddingsService
+from app.services.openai_service import OpenAIService
+import logging
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(prefix="/api", tags=["chat"])
+
+def get_rag_service(
+    qdrant_client: QdrantClient = Depends(get_qdrant_client)
+):
+    embeddings_service = EmbeddingsService()
+    openai_service = OpenAIService()
+    return RAGService(qdrant_client, embeddings_service, openai_service)
+
+@router.post("/chat", response_model=ChatResponse)
+async def chat(
+    request: ChatRequest,
+    rag_service: RAGService = Depends(get_rag_service)
+):
+    try:
+        # Retrieve context from vector database
+        context = await rag_service.retrieve_context(request.question, top_k=3)
+        
+        # Generate response using OpenAI
+        answer = await rag_service.generate_response(request.question, context)
+        
+        # Extract sources from context
+        sources = [f"Source {i+1}" for i in range(len(context))]
+        
+        return ChatResponse(answer=answer, sources=sources)
+    except Exception as e:
+        logger.error(f"Error in chat endpoint: {str(e)}", exc_info=True)
+        raise HTTPException(status_code=500, detail=str(e))
+
+@router.post("/chat-selection", response_model=ChatResponse)
+async def chat_selection(
+    request: ChatSelectionRequest,
+    rag_service: RAGService = Depends(get_rag_service)
+):
+    try:
+        # Use selected text as primary context
+        context = [request.selected_text]
+        
+        # Generate response
+        answer = await rag_service.generate_response(request.question, context)
+        
+        return ChatResponse(answer=answer, sources=["Selected Text"])
+    except Exception as e:
+        logger.error(f"Error in chat_selection endpoint: {str(e)}", exc_info=True)
+        raise HTTPException(status_code=500, detail=str(e))

app/schemas/chat.py

@@ -0,0 +1,23 @@
+from pydantic import BaseModel
+from typing import List, Optional
+from datetime import datetime
+
+class Message(BaseModel):
+    content: str
+    role: str
+
+class ChatRequest(BaseModel):
+    question: str
+    user_id: Optional[int] = None
+
+class ChatResponse(BaseModel):
+    answer: str
+    sources: List[str] = []
+
+class ChatSelectionRequest(BaseModel):
+    question: str
+    selected_text: str
+    user_id: Optional[int] = None
+
+class ChatSelectionResponse(BaseModel):
+    response: str

app/services/embeddings_service.py

@@ -0,0 +1,21 @@
+from openai import OpenAI
+from app.config import settings
+import httpx
+import asyncio
+
+class EmbeddingsService:
+    def __init__(self):
+        # Use httpx client without problematic kwargs
+        http_client = httpx.Client()
+        self.client = OpenAI(api_key=settings.OPENAI_API_KEY, http_client=http_client)
+        self.model = "text-embedding-3-small"
+
+    async def create_embedding(self, text: str):
+        text = text.replace("\n", " ")
+        # Run the blocking OpenAI call in a thread pool
+        response = await asyncio.to_thread(
+            self.client.embeddings.create,
+            input=[text],
+            model=self.model
+        )
+        return response.data[0].embedding

app/services/openai_service.py

@@ -0,0 +1,26 @@
+from openai import OpenAI
+from app.config import settings
+from typing import List
+import httpx
+import asyncio
+
+class OpenAIService:
+    def __init__(self):
+        # Use httpx client without problematic kwargs
+        http_client = httpx.Client()
+        self.client = OpenAI(api_key=settings.OPENAI_API_KEY, http_client=http_client)
+        self.model = "gpt-4o-mini"
+
+    async def get_chat_response(self, prompt: str, history: List[dict] = None) -> str:
+        messages = []
+        if history:
+            messages.extend(history)
+        messages.append({"role": "user", "content": prompt})
+
+        # Run the blocking OpenAI call in a thread pool
+        response = await asyncio.to_thread(
+            self.client.chat.completions.create,
+            model=self.model,
+            messages=messages
+        )
+        return response.choices[0].message.content

app/services/rag_service.py

@@ -0,0 +1,40 @@
+
+import os
+import asyncio
+from qdrant_client import QdrantClient
+from qdrant_client.models import NamedVector
+from typing import List
+
+from app.services.openai_service import OpenAIService
+from app.services.embeddings_service import EmbeddingsService
+
+class RAGService:
+    def __init__(self, qdrant_client: QdrantClient, embeddings_service: EmbeddingsService, openai_service: OpenAIService):
+        self.qdrant_client = qdrant_client
+        self.embeddings_service = embeddings_service
+        self.openai_service = openai_service
+        self.collection_name = os.getenv("QDRANT_COLLECTION_NAME", "book_embeddings")
+
+    async def retrieve_context(self, query: str, top_k: int = 3) -> List[str]:
+        query_vector = await self.embeddings_service.create_embedding(query)
+        
+        # Run synchronous Qdrant query in thread pool
+        search_result = await asyncio.to_thread(
+            self.qdrant_client.query_points,
+            collection_name=self.collection_name,
+            query=query_vector,
+            limit=top_k,
+            with_payload=True
+        )
+
+        context = [point.payload.get("content", "") for point in search_result.points if point.payload]
+        return context
+
+    async def generate_response(self, query: str, context: List[str]) -> str:
+        full_prompt = f"""Context: {' '.join(context)}
+
+Question: {query}
+
+Answer:"""
+        response = await self.openai_service.get_chat_response(full_prompt)
+        return response

requirements.txt

@@ -0,0 +1,12 @@
+fastapi==0.111.0
+uvicorn==0.30.1
+openai==1.35.13
+qdrant-client==1.9.0
+psycopg2-binary==2.9.9
+sqlalchemy==2.0.31
+python-dotenv==1.0.1
+pydantic==2.8.2
+pydantic-settings==2.3.4
+asyncpg==0.29.0
+markdown==3.6
+beautifulsoup4==4.12.3

run.bat

@@ -0,0 +1,15 @@
+@echo off
+setlocal
+
+REM Navigate to the backend directory
+cd backend
+
+REM Activate virtual environment
+echo Activating virtual environment...
+call venv\Scripts\activate
+
+REM Start the uvicorn server
+echo Starting FastAPI application with uvicorn...
+uvicorn app.main:app --host 0.0.0.0 --port 8000 --reload
+
+endlocal

scripts/ingest_content.py

@@ -0,0 +1,104 @@
+import os
+import argparse
+from pathlib import Path
+import markdown
+from bs4 import BeautifulSoup
+from qdrant_client import QdrantClient
+from qdrant_client.models import Distance, VectorParams, PointStruct
+from dotenv import load_dotenv
+
+# Add these to enable relative imports
+import sys
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+
+from app.services.embeddings_service import EmbeddingsService
+from app.qdrant_client import get_qdrant_client
+
+load_dotenv(dotenv_path=Path(__file__).resolve().parent.parent / ".env")
+
+QDRANT_COLLECTION_NAME = os.getenv("QDRANT_COLLECTION_NAME", "docs_collection")
+
+def load_mdx_content(filepath: Path) -> str:
+    with open(filepath, 'r', encoding='utf-8') as f:
+        content = f.read()
+    # MDX is essentially Markdown, so we can convert to HTML then extract text
+    html = markdown.markdown(content)
+    soup = BeautifulSoup(html, 'html.parser')
+    return soup.get_text()
+
+def chunk_text(text: str, chunk_size: int = 1000, overlap: int = 200) -> list[str]:
+    chunks = []
+    for i in range(0, len(text), chunk_size - overlap):
+        chunks.append(text[i:i + chunk_size])
+    return chunks
+
+async def ingest_content(
+    docs_path: Path,
+    qdrant_client: QdrantClient,
+    embeddings_service: EmbeddingsService,
+    collection_name: str,
+):
+    qdrant_client.recreate_collection(
+        collection_name=collection_name,
+        vectors_config=VectorParams(size=1536, distance=Distance.COSINE),  # OpenAI embeddings size
+    )
+
+    points = []
+    point_id = 0
+    for mdx_file in docs_path.rglob("*.mdx"):
+        print(f"Processing {mdx_file}")
+        content = load_mdx_content(mdx_file)
+        chunks = chunk_text(content)
+
+        for chunk in chunks:
+            embedding = embeddings_service.create_embedding(chunk)
+            points.append(
+                PointStruct(
+                    id=point_id,
+                    vector=embedding,
+                    payload={
+                        "content": chunk,
+                        "source": str(mdx_file.relative_to(docs_path))
+                    }
+                )
+            )
+            point_id += 1
+
+            if len(points) >= 100:  # Batch upsert
+                qdrant_client.upsert(
+                    collection_name=collection_name,
+                    points=points,
+                    wait=True,
+                )
+                points = []
+
+    if points: # Upsert remaining points
+        qdrant_client.upsert(
+            collection_name=collection_name,
+            points=points,
+            wait=True,
+        )
+
+    print(f"Ingestion complete. Total points: {point_id}")
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Ingest MDX content into Qdrant.")
+    parser.add_argument(
+        "--docs_path",
+        type=str,
+        default="../physical-ai-humanoid-robotics/docs/",
+        help="Path to the directory containing MDX documentation files."
+    )
+    args = parser.parse_args()
+
+    qdrant_client = get_qdrant_client()
+    embeddings_service = EmbeddingsService()
+
+    # Run the async ingestion
+    import asyncio
+    asyncio.run(ingest_content(
+        docs_path=Path(args.docs_path),
+        qdrant_client=qdrant_client,
+        embeddings_service=embeddings_service,
+        collection_name=QDRANT_COLLECTION_NAME
+    ))

setup.bat

@@ -0,0 +1,29 @@
+@echo off
+setlocal
+
+REM Navigate to the backend directory
+cd backend
+
+REM Check if virtual environment exists, if not, create it
+if not exist venv (
+    echo Creating virtual environment...
+    python -m venv venv
+)
+
+REM Activate virtual environment
+echo Activating virtual environment...
+call venv\Scripts\activate
+
+REM Install dependencies
+echo Installing dependencies from requirements.txt...
+pip install -r requirements.txt
+
+REM Check if .env file exists, if not, create it from .env.example
+if not exist .env (
+    echo Creating .env from .env.example...
+    copy .env.example .env
+)
+
+echo Setup complete.
+endlocal
+pause

test_request.json

@@ -0,0 +1,4 @@
+{
+  "question": "What is RAG?",
+  "user_id": 1
+}

test_request2.json

@@ -0,0 +1,4 @@
+{
+  "question": "Explain ROS2 in simple terms",
+  "user_id": 1
+}

test_setup.py

@@ -0,0 +1,132 @@
+"""
+Quick setup verification script
+Run this to check if your environment is configured correctly
+"""
+
+import sys
+import os
+from pathlib import Path
+
+def check_env_file():
+    """Check if .env file exists and has required variables"""
+    env_path = Path(__file__).parent / ".env"
+    
+    if not env_path.exists():
+        print("❌ .env file not found!")
+        print("   Create it by copying .env.example and adding your credentials")
+        return False
+    
+    print("✅ .env file exists")
+    
+    # Read and check for required variables
+    with open(env_path) as f:
+        content = f.read()
+    
+    required_vars = {
+        'OPENAI_API_KEY': 'OpenAI API key',
+    }
+    
+    missing = []
+    for var, description in required_vars.items():
+        if var not in content:
+            missing.append(f"   - {var} ({description})")
+        elif f"{var}=your_" in content or f"{var}=" in content and len(content.split(f"{var}=")[1].split('\n')[0].strip()) < 10:
+            print(f"⚠️  {var} appears to be a placeholder - please set your actual {description}")
+            missing.append(f"   - {var} needs to be set")
+    
+    if missing:
+        print("❌ Missing or invalid environment variables:")
+        for m in missing:
+            print(m)
+        return False
+    
+    print("✅ Required environment variables are set")
+    return True
+
+def check_dependencies():
+    """Check if required packages are installed"""
+    required_packages = [
+        'fastapi',
+        'uvicorn',
+        'openai',
+        'qdrant_client',
+        'sqlalchemy',
+        'pydantic',
+        'pydantic_settings'
+    ]
+    
+    missing = []
+    for package in required_packages:
+        try:
+            __import__(package.replace('-', '_'))
+            print(f"✅ {package} installed")
+        except ImportError:
+            missing.append(package)
+            print(f"❌ {package} not installed")
+    
+    if missing:
+        print("\n❌ Missing packages. Install them with:")
+        print("   pip install -r requirements.txt")
+        return False
+    
+    return True
+
+def check_openai_key():
+    """Test if OpenAI API key is valid"""
+    try:
+        from app.config import settings
+        
+        if not settings.OPENAI_API_KEY or settings.OPENAI_API_KEY.startswith('your_'):
+            print("❌ OPENAI_API_KEY is not set or is a placeholder")
+            print("   Please set your actual OpenAI API key in .env file")
+            return False
+        
+        print("✅ OPENAI_API_KEY is configured")
+        print(f"   Key starts with: {settings.OPENAI_API_KEY[:10]}...")
+        return True
+        
+    except Exception as e:
+        print(f"❌ Error loading config: {e}")
+        return False
+
+def main():
+    print("=" * 60)
+    print("Backend Setup Verification")
+    print("=" * 60)
+    print()
+    
+    checks = [
+        ("Environment File", check_env_file),
+        ("Dependencies", check_dependencies),
+        ("OpenAI Configuration", check_openai_key),
+    ]
+    
+    results = []
+    for name, check_func in checks:
+        print(f"\n📋 Checking: {name}")
+        print("-" * 60)
+        try:
+            result = check_func()
+            results.append(result)
+        except Exception as e:
+            print(f"❌ Error during check: {e}")
+            results.append(False)
+    
+    print("\n" + "=" * 60)
+    if all(results):
+        print("✅ All checks passed! You're ready to run the backend.")
+        print("\nStart the server with:")
+        print("   .\\run.bat")
+        print("\nOr manually:")
+        print("   .\\.venv\\Scripts\\activate")
+        print("   uvicorn app.main:app --reload --host 0.0.0.0 --port 8000")
+    else:
+        print("❌ Some checks failed. Please fix the issues above.")
+        print("\nQuick fixes:")
+        print("1. Make sure .env file exists with your OpenAI API key")
+        print("2. Install dependencies: pip install -r requirements.txt")
+        print("3. Check SETUP_GUIDE.md for detailed instructions")
+    print("=" * 60)
+
+if __name__ == "__main__":
+    main()