'code'

.env

@@ -0,0 +1,4 @@
+OPENAI_API_KEY=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
+NEON_DATABASE_URL=postgresql://neondb_owner:npg_HUp8hzrBtK4M@ep-calm-bonus-a4wci2me-pooler.us-east-1.aws.neon.tech/neondb?sslmode=require&channel_binding=require
+QDRANT_URL=https://2758614b-500a-4a16-acf1-11c62603db81.us-east4-0.gcp.cloud.qdrant.io
+QDRANT_API_KEY=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJhY2Nlc3MiOiJtIn0.wQ2fPOoxaLGEl6ss0O4v6CqPcQoFwoFUUWJ7qwNvVQ4

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", "main:app", "--host", "0.0.0.0", "--port", "7860"]

app/config.py

@@ -0,0 +1,18 @@
+
+import os
+from pydantic_settings import BaseSettings
+
+class Settings(BaseSettings):
+    OPENAI_API_KEY: str
+    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"
+        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,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,37 @@
+
+import os
+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)
+        
+        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:"""
+        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

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
+    ))