'changes'

.env

@@ -0,0 +1,5 @@
+OPENAI_API_KEY=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
+NEON_DATABASE_URL=postgresql://neondb_owner:npg_Wm9euiPcsS6Q@ep-wispy-mountain-ah1rydmt-pooler.c-3.us-east-1.aws.neon.tech/neondb?sslmode=require&channel_binding=require
+QDRANT_URL=https://29508df2-9cd7-4a02-b7c8-a69aac0cbc10.us-east-1-1.aws.cloud.qdrant.io
+QDRANT_API_KEY=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJhY2Nlc3MiOiJtIn0.pOFSRAp6xMM69VgHnM0IGyqqKmWfSge1W2mrixWdcFg
+GEMINI_API_KEY=AIzaSyAK9HhquXdPHV01qLjYszI6j19n1yGP9Js

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,22 @@
+import os
+from pydantic_settings import BaseSettings
+
+class Settings(BaseSettings):
+    OPENAI_API_KEY: str
+    GEMINI_API_KEY: str
+    # Set to "openai" or "gemini" to choose the AI provider
+    AI_PROVIDER: str = "openai"
+    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"
+    GEMINI_MODEL_CHAT: str = "gemini-2.0-flash"
+    GEMINI_MODEL_EMBEDDING: str = "embedding-001"
+    
+    class Config:
+        env_file = ".env"
+        extra = "ignore"
+
+settings = Settings()

app/database.py

@@ -0,0 +1,17 @@
+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
+SQLALCHEMY_DATABASE_URL = settings.NEON_DATABASE_URL or settings.DATABASE_URL or "sqlite:///./test.db"
+engine = create_engine(SQLALCHEMY_DATABASE_URL)
+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,34 @@
+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=["http://localhost:3000", "http://127.0.0.1:3000"],
+    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
+    Base.metadata.create_all(bind=engine)
+    # Initialize Qdrant collection
+    init_qdrant_collection()
+
+@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,38 @@
+import os
+from qdrant_client import QdrantClient
+from qdrant_client.models import Distance, VectorParams
+from app.config import settings
+
+# Initialize Qdrant client
+qdrant_client = QdrantClient(
+    url=settings.QDRANT_URL,
+    api_key=settings.QDRANT_API_KEY,
+)
+
+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,63 @@
+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, GeminiEmbeddingsService
+from app.services.openai_service import OpenAIService, GeminiService
+from app.config import settings
+import logging
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(prefix="/api", tags=["chat"])
+
+def get_rag_service(
+    qdrant_client: QdrantClient = Depends(get_qdrant_client)
+):
+    # Choose the appropriate services based on AI_PROVIDER setting
+    if settings.AI_PROVIDER.lower() == "gemini":
+        embeddings_service = GeminiEmbeddingsService()
+        ai_service = GeminiService()
+    else:
+        embeddings_service = EmbeddingsService()
+        ai_service = OpenAIService()
+    
+    return RAGService(qdrant_client, embeddings_service, ai_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 the configured AI service
+        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,37 @@
+from openai import OpenAI
+from app.config import settings
+import httpx
+import asyncio
+import google.generativeai as genai
+
+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
+
+class GeminiEmbeddingsService:
+    def __init__(self):
+        genai.configure(api_key=settings.GEMINI_API_KEY)
+        self.model = "models/" + settings.GEMINI_MODEL_EMBEDDING
+
+    async def create_embedding(self, text: str):
+        text = text.replace("\n", " ")
+        # Run the blocking Gemini call in a thread pool
+        response = await asyncio.to_thread(
+            genai.embed_content,
+            model=self.model,
+            content=text
+        )
+        return response['embedding']

app/services/openai_service.py

@@ -0,0 +1,48 @@
+from openai import OpenAI
+from app.config import settings
+from typing import List
+import httpx
+import asyncio
+import google.generativeai as genai
+
+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
+
+class GeminiService:
+    def __init__(self):
+        genai.configure(api_key=settings.GEMINI_API_KEY)
+        self.model = genai.GenerativeModel(settings.GEMINI_MODEL_CHAT)
+
+    async def get_chat_response(self, prompt: str, history: List[dict] = None) -> str:
+        # Convert history to Gemini format
+        chat_history = []
+        if history:
+            for msg in history:
+                # Convert OpenAI roles to Gemini roles
+                role = "model" if msg["role"] == "assistant" else "user"
+                chat_history.append({"role": role, "parts": [msg["content"]]})
+        
+        # Create chat session with history
+        chat = self.model.start_chat(history=chat_history)
+        
+        # Get response
+        response = await asyncio.to_thread(chat.send_message, prompt)
+        return response.text

app/services/rag_service.py

@@ -0,0 +1,44 @@
+import os
+from qdrant_client import QdrantClient
+from qdrant_client.models import NamedVector
+from typing import List
+
+from app.services.openai_service import OpenAIService, GeminiService
+from app.services.embeddings_service import EmbeddingsService, GeminiEmbeddingsService
+
+class RAGService:
+    def __init__(self, qdrant_client: QdrantClient, embeddings_service: EmbeddingsService, ai_service: OpenAIService):
+        self.qdrant_client = qdrant_client
+        self.embeddings_service = embeddings_service
+        self.ai_service = ai_service
+        self.collection_name = os.getenv("QDRANT_COLLECTION_NAME", "book_embeddings")
+
+    async def retrieve_context(self, query: str, top_k: int = 3) -> List[str]:
+        # Handle both OpenAI and Gemini embeddings
+        if isinstance(self.embeddings_service, GeminiEmbeddingsService):
+            query_vector = await self.embeddings_service.create_embedding(query)
+        else:
+            query_vector = await self.embeddings_service.create_embedding(query)
+        
+        search_result = self.qdrant_client.search(
+            collection_name=self.collection_name,
+            query_vector=query_vector,
+            limit=top_k,
+            with_payload=True,
+        )
+
+        context = [point.payload.get("content", "") for point in search_result 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:"""
+        # Handle both OpenAI and Gemini services
+        if isinstance(self.ai_service, GeminiService):
+            response = await self.ai_service.get_chat_response(full_prompt)
+        else:
+            response = await self.ai_service.get_chat_response(full_prompt)
+        return response

requirements.txt

@@ -0,0 +1,13 @@
+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
+google-generativeai==0.8.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,116 @@
+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, GeminiEmbeddingsService
+from app.qdrant_client import get_qdrant_client
+from app.config import settings
+
+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,
+):
+    # Determine vector size based on the embedding service
+    if isinstance(embeddings_service, GeminiEmbeddingsService):
+        vector_size = 768  # Gemini embedding size
+    else:
+        vector_size = 1536  # OpenAI embedding size
+    
+    qdrant_client.recreate_collection(
+        collection_name=collection_name,
+        vectors_config=VectorParams(size=vector_size, distance=Distance.COSINE),
+    )
+
+    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 = await 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()
+    
+    # Choose the appropriate embedding service based on AI_PROVIDER setting
+    if settings.AI_PROVIDER.lower() == "gemini":
+        embeddings_service = GeminiEmbeddingsService()
+    else:
+        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