feat: add Agentic RAG OS — full-stack RL B2B RaaS platform

- Full backend API (FastAPI): auth, RAG pipeline, Rewards-as-a-Service
- Modern dark-theme SPA frontend with animations
- GitHub OAuth + username/password auth with JWT
- RAG pipeline: document upload → embedding → FAISS → retrieval
- Rewards-as-a-Service: GRPO, PPO, DPO, REINFORCE, Custom
- User management, API keys, dashboard
- Architecture documentation
- Google Cloud Run deployment config
- Updated README with links and Wild Card section

.gitignore

@@ -29,3 +29,5 @@ node_modules/
 # Training checkpoints (large files)
 checkpoints/
 .venv-1/
+*.db
+agentic_rag_os/data/

Dockerfile.ragos

@@ -0,0 +1,32 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends build-essential curl && \
+    rm -rf /var/lib/apt/lists/*
+
+COPY pyproject.toml README.md ./
+COPY rag_master/ rag_master/
+COPY server/ server/
+COPY domains/ domains/
+COPY agentic_rag_os/ agentic_rag_os/
+
+RUN pip install --no-cache-dir --upgrade pip && \
+    pip install --no-cache-dir ".[ragos]"
+
+# Pre-warm embedding model
+RUN python -c "from sentence_transformers import SentenceTransformer; SentenceTransformer('sentence-transformers/all-MiniLM-L6-v2')"
+
+RUN mkdir -p /app/agentic_rag_os/data
+
+ENV RAGOS_HOST=0.0.0.0
+ENV RAGOS_PORT=8080
+ENV PYTHONUNBUFFERED=1
+
+EXPOSE 8080
+
+HEALTHCHECK --interval=30s --timeout=10s --start-period=60s --retries=3 \
+    CMD curl -f http://localhost:8080/api/v1/health || exit 1
+
+CMD ["python", "-m", "agentic_rag_os.run"]

README.md

@@ -29,6 +29,8 @@ pinned: true
 |---|---|
 | **HF Space** | [huggingface.co/spaces/williyam/agentic-rag-gym](https://huggingface.co/spaces/williyam/agentic-rag-gym) |
 | **Fine-Tuned Model** | [huggingface.co/williyam/agentic-rag-aerospace-grpo](https://huggingface.co/williyam/agentic-rag-aerospace-grpo) |
+| **Agentic RAG OS** | [agentic-rag-os (Google Cloud)](https://agentic-rag-os-441459779686.us-central1.run.app) |
+| **Training Notebook** | [Google Colab — GRPO Fine-Tuning](https://colab.research.google.com/drive/14il2JQmy9-id_fSGpmYbssp-j975DSDo?usp=sharing) |
 
 > **We didn't just build another RAG pipeline — we redesigned the foundation of how agentic RAG systems learn, decide, and improve.**
 
@@ -60,7 +62,7 @@ Traditional RAG systems are static pipelines: retrieve → generate → done. Th
 | **#2 Long-Horizon Planning** | Tasks require 10-20 step trajectories with planning, iterative retrieval, reasoning, critique, and verification |
 | **#3.1 World Modeling (Professional)** | Dynamic RAG environment with FAISS vector store, LLM reasoning, and tool orchestration |
 | **#4 Self-Improvement** | Adversarial critique loops, iterative refinement, GRPO fine-tuning with real graders |
-| **#5 Wild Card** | **A new orchestrator/framework designed from scratch** — RAG Master represents a new revolution for agentic RAG. This RL gym helps the system make better decisions by improving the entire agentic RAG foundation with reinforcement learning. Implemented as a domain-agnostic framework extensible to any domain, with 2 production domains (Aerospace Research, Legal Research) and deterministic grading |
+| **#5 Wild Card** | **Agentic RAG OS** — An RL B2B Rewards-as-a-Service (RaaS) startup platform built as a full-stack operating system for agentic RAG. **RAG Master** — A new orchestrator/framework designed from scratch (like LangChain/LangGraph) as a domain-agnostic engine for multi-agent RAG with RL-driven process supervision. |
 
 ---
 

agentic_rag_os/__init__.py

@@ -0,0 +1,3 @@
+"""Agentic RAG OS — The Operating System for Agentic RAG."""
+
+__version__ = "1.0.0"

agentic_rag_os/api/__init__.py

@@ -0,0 +1 @@
+"""API package for Agentic RAG OS."""

agentic_rag_os/api/app.py

@@ -0,0 +1,91 @@
+"""Main FastAPI application for Agentic RAG OS."""
+
+from __future__ import annotations
+
+import os
+from contextlib import asynccontextmanager
+from pathlib import Path
+from typing import AsyncGenerator
+
+from fastapi import FastAPI, Request
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import FileResponse, HTMLResponse, JSONResponse
+from fastapi.staticfiles import StaticFiles
+
+from agentic_rag_os.config import get_settings
+from agentic_rag_os.models import close_db, get_db
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI) -> AsyncGenerator:
+    """Startup/shutdown lifecycle."""
+    await get_db()
+    yield
+    await close_db()
+
+
+app = FastAPI(
+    title="Agentic RAG OS",
+    description="The Operating System for Agentic RAG — RL B2B Rewards-as-a-Service",
+    version="1.0.0",
+    docs_url="/api/docs",
+    redoc_url="/api/redoc",
+    openapi_url="/api/openapi.json",
+    lifespan=lifespan,
+)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# --- Register API routers ---
+from agentic_rag_os.api.auth_routes import router as auth_router
+from agentic_rag_os.api.rag_routes import router as rag_router
+from agentic_rag_os.api.reward_routes import router as reward_router
+from agentic_rag_os.api.user_routes import router as user_router
+
+app.include_router(auth_router, prefix="/api/v1")
+app.include_router(rag_router, prefix="/api/v1")
+app.include_router(reward_router, prefix="/api/v1")
+app.include_router(user_router, prefix="/api/v1")
+
+
+# --- Health check ---
+@app.get("/api/v1/health")
+async def health():
+    return {"status": "healthy", "service": "agentic-rag-os", "version": "1.0.0"}
+
+
+# --- Serve static files ---
+_FRONTEND_DIR = Path(__file__).parent / "frontend"
+_STATIC_DIR = _FRONTEND_DIR / "static"
+
+if _STATIC_DIR.exists():
+    app.mount("/static", StaticFiles(directory=str(_STATIC_DIR)), name="static")
+
+
+# --- Serve SPA ---
+@app.get("/{full_path:path}")
+async def serve_spa(request: Request, full_path: str):
+    """Serve the single-page application for all non-API routes."""
+    # Don't intercept API paths
+    if full_path.startswith("api/"):
+        return JSONResponse({"detail": "Not found"}, status_code=404)
+
+    index = _FRONTEND_DIR / "index.html"
+    if index.exists():
+        return FileResponse(str(index), media_type="text/html")
+    return HTMLResponse("<h1>Agentic RAG OS</h1><p>Frontend not built yet.</p>")
+
+
+# --- Global error handler ---
+@app.exception_handler(Exception)
+async def global_exception_handler(request: Request, exc: Exception):
+    return JSONResponse(
+        status_code=500,
+        content={"detail": f"Internal server error: {str(exc)}"},
+    )

agentic_rag_os/api/auth_routes.py

@@ -0,0 +1,38 @@
+"""Authentication routes — register, login, GitHub OAuth."""
+
+from __future__ import annotations
+
+from fastapi import APIRouter, HTTPException, Query
+
+from agentic_rag_os.models.schemas import LoginRequest, RegisterRequest, TokenResponse
+from agentic_rag_os.services import github_oauth_callback, login_user, register_user
+
+router = APIRouter(prefix="/auth", tags=["Authentication"])
+
+
+@router.post("/register", response_model=TokenResponse)
+async def register(req: RegisterRequest):
+    try:
+        result = await register_user(req.username, req.email, req.password)
+        return result
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+
+@router.post("/login", response_model=TokenResponse)
+async def login(req: LoginRequest):
+    try:
+        result = await login_user(req.username, req.password)
+        return result
+    except ValueError as e:
+        raise HTTPException(status_code=401, detail=str(e))
+
+
+@router.get("/github/callback")
+async def github_callback(code: str = Query(...)):
+    """GitHub OAuth callback — exchange code for JWT."""
+    try:
+        result = await github_oauth_callback(code)
+        return result
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))

agentic_rag_os/api/deps.py

@@ -0,0 +1,51 @@
+"""Authentication dependency for FastAPI routes."""
+
+from __future__ import annotations
+
+from typing import Any, Dict, Optional
+
+from fastapi import Depends, HTTPException, Request, status
+from fastapi.security import HTTPAuthorizationCredentials, HTTPBearer
+
+from agentic_rag_os.services import decode_token, validate_api_key
+
+_bearer = HTTPBearer(auto_error=False)
+
+
+async def get_current_user(
+    request: Request,
+    credentials: Optional[HTTPAuthorizationCredentials] = Depends(_bearer),
+) -> Dict[str, Any]:
+    """Extract and validate the current user from JWT or API key."""
+
+    # Try Bearer token (JWT)
+    if credentials and credentials.credentials:
+        try:
+            payload = decode_token(credentials.credentials)
+            return {"user_id": payload["sub"], "username": payload["username"], "role": payload.get("role", "user")}
+        except Exception:
+            pass
+
+    # Try API key in X-API-Key header
+    api_key = request.headers.get("X-API-Key", "")
+    if api_key:
+        user_info = await validate_api_key(api_key)
+        if user_info:
+            return user_info
+
+    raise HTTPException(
+        status_code=status.HTTP_401_UNAUTHORIZED,
+        detail="Not authenticated. Provide a Bearer token or X-API-Key header.",
+        headers={"WWW-Authenticate": "Bearer"},
+    )
+
+
+async def get_optional_user(
+    request: Request,
+    credentials: Optional[HTTPAuthorizationCredentials] = Depends(_bearer),
+) -> Optional[Dict[str, Any]]:
+    """Optionally get the current user — returns None if not authenticated."""
+    try:
+        return await get_current_user(request, credentials)
+    except HTTPException:
+        return None

agentic_rag_os/api/rag_routes.py

@@ -0,0 +1,86 @@
+"""RAG pipeline routes — domains, documents, queries."""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List
+
+from fastapi import APIRouter, Depends, File, HTTPException, UploadFile
+
+from agentic_rag_os.api.deps import get_current_user
+from agentic_rag_os.models.schemas import (
+    DomainCreate,
+    DomainOut,
+    DocumentOut,
+    RAGQueryRequest,
+    RAGQueryResponse,
+)
+from agentic_rag_os.services.rag_service import (
+    create_domain,
+    delete_document,
+    delete_domain,
+    list_documents,
+    list_domains,
+    rag_query,
+    upload_document,
+)
+
+router = APIRouter(prefix="/rag", tags=["RAG Pipeline"])
+
+
+# --- Domains ---
+
+@router.post("/domains", response_model=DomainOut)
+async def create_domain_route(body: DomainCreate, user: Dict = Depends(get_current_user)):
+    return await create_domain(user["user_id"], body.name, body.description)
+
+
+@router.get("/domains", response_model=List[DomainOut])
+async def list_domains_route(user: Dict = Depends(get_current_user)):
+    return await list_domains(user["user_id"])
+
+
+@router.delete("/domains/{domain_id}")
+async def delete_domain_route(domain_id: str, user: Dict = Depends(get_current_user)):
+    ok = await delete_domain(user["user_id"], domain_id)
+    if not ok:
+        raise HTTPException(status_code=404, detail="Domain not found")
+    return {"ok": True}
+
+
+# --- Documents ---
+
+@router.get("/domains/{domain_id}/documents", response_model=List[DocumentOut])
+async def list_docs_route(domain_id: str, user: Dict = Depends(get_current_user)):
+    return await list_documents(user["user_id"], domain_id)
+
+
+@router.post("/domains/{domain_id}/documents", response_model=DocumentOut)
+async def upload_doc_route(domain_id: str, file: UploadFile = File(...), user: Dict = Depends(get_current_user)):
+    """Upload a text file to a domain. Free tier: max 2MB total."""
+    if not file.filename:
+        raise HTTPException(status_code=400, detail="Filename required")
+    content = (await file.read()).decode("utf-8", errors="replace")
+    if not content.strip():
+        raise HTTPException(status_code=400, detail="File is empty")
+    try:
+        return await upload_document(user["user_id"], domain_id, file.filename, content)
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+
+@router.delete("/domains/{domain_id}/documents/{doc_id}")
+async def delete_doc_route(domain_id: str, doc_id: str, user: Dict = Depends(get_current_user)):
+    ok = await delete_document(user["user_id"], domain_id, doc_id)
+    if not ok:
+        raise HTTPException(status_code=404, detail="Document not found")
+    return {"ok": True}
+
+
+# --- RAG Query ---
+
+@router.post("/domains/{domain_id}/query", response_model=RAGQueryResponse)
+async def query_route(domain_id: str, body: RAGQueryRequest, user: Dict = Depends(get_current_user)):
+    try:
+        return await rag_query(user["user_id"], domain_id, body.query, body.top_k)
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))

agentic_rag_os/api/reward_routes.py

@@ -0,0 +1,102 @@
+"""Rewards-as-a-Service routes."""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional
+
+from fastapi import APIRouter, Depends, HTTPException, Query
+
+from agentic_rag_os.api.deps import get_current_user
+from agentic_rag_os.models.schemas import (
+    RewardComputeRequest,
+    RewardComputeResponse,
+    RewardConfigCreate,
+    RewardConfigOut,
+    RewardJobCreate,
+    RewardJobOut,
+)
+from agentic_rag_os.services.reward_service import (
+    compute_reward,
+    create_reward_config,
+    create_reward_job,
+    delete_reward_config,
+    list_reward_configs,
+    list_reward_jobs,
+    get_reward_config,
+)
+
+router = APIRouter(prefix="/rewards", tags=["Rewards-as-a-Service"])
+
+
+# --- Reward Configs ---
+
+@router.post("/configs", response_model=RewardConfigOut)
+async def create_config_route(body: RewardConfigCreate, user: Dict = Depends(get_current_user)):
+    return await create_reward_config(user["user_id"], body.name, body.algorithm, body.domain_id, body.config)
+
+
+@router.get("/configs", response_model=List[RewardConfigOut])
+async def list_configs_route(user: Dict = Depends(get_current_user)):
+    return await list_reward_configs(user["user_id"])
+
+
+@router.get("/configs/{config_id}", response_model=RewardConfigOut)
+async def get_config_route(config_id: str, user: Dict = Depends(get_current_user)):
+    cfg = await get_reward_config(user["user_id"], config_id)
+    if not cfg:
+        raise HTTPException(status_code=404, detail="Config not found")
+    return cfg
+
+
+@router.delete("/configs/{config_id}")
+async def delete_config_route(config_id: str, user: Dict = Depends(get_current_user)):
+    ok = await delete_reward_config(user["user_id"], config_id)
+    if not ok:
+        raise HTTPException(status_code=404, detail="Config not found")
+    return {"ok": True}
+
+
+# --- On-the-fly reward computation ---
+
+@router.post("/compute", response_model=RewardComputeResponse)
+async def compute_reward_route(body: RewardComputeRequest, user: Dict = Depends(get_current_user)):
+    """Compute reward on-the-fly — no stored config needed."""
+    result = compute_reward(
+        algorithm=body.algorithm,
+        query=body.query,
+        answer=body.answer,
+        retrieved_docs=body.retrieved_docs,
+        config=body.config,
+    )
+    return result
+
+
+# --- Reward Jobs ---
+
+@router.post("/jobs", response_model=RewardJobOut)
+async def create_job_route(body: RewardJobCreate, user: Dict = Depends(get_current_user)):
+    try:
+        return await create_reward_job(user["user_id"], body.reward_config_id, body.input_data)
+    except ValueError as e:
+        raise HTTPException(status_code=400, detail=str(e))
+
+
+@router.get("/jobs", response_model=List[RewardJobOut])
+async def list_jobs_route(config_id: Optional[str] = Query(None), user: Dict = Depends(get_current_user)):
+    return await list_reward_jobs(user["user_id"], config_id)
+
+
+# --- Supported Algorithms ---
+
+@router.get("/algorithms")
+async def list_algorithms():
+    """List all supported reward algorithms."""
+    return {
+        "algorithms": [
+            {"id": "grpo", "name": "GRPO", "description": "Group Relative Policy Optimization — rewards are relative within groups for stable training"},
+            {"id": "ppo", "name": "PPO", "description": "Proximal Policy Optimization — clipped surrogate objective for monotonic improvement"},
+            {"id": "dpo", "name": "DPO", "description": "Direct Preference Optimization — reward from preference pairs, no reward model needed"},
+            {"id": "reinforce", "name": "REINFORCE", "description": "Vanilla policy gradient with baseline subtraction"},
+            {"id": "custom", "name": "Custom", "description": "Define your own reward weights and scoring rules"},
+        ]
+    }

agentic_rag_os/api/user_routes.py

@@ -0,0 +1,72 @@
+"""User management routes — profile, API keys, dashboard stats."""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List
+
+from fastapi import APIRouter, Depends, HTTPException
+
+from agentic_rag_os.api.deps import get_current_user
+from agentic_rag_os.models.schemas import APIKeyCreate, APIKeyCreated, APIKeyOut, DashboardStats, UserOut
+from agentic_rag_os.services import create_api_key, get_user_by_id, list_api_keys, revoke_api_key
+from agentic_rag_os.models import fetch_all, fetch_one
+from agentic_rag_os.config import get_settings
+
+router = APIRouter(prefix="/user", tags=["User Management"])
+
+
+@router.get("/me", response_model=UserOut)
+async def get_profile(user: Dict = Depends(get_current_user)):
+    u = await get_user_by_id(user["user_id"])
+    if not u:
+        raise HTTPException(status_code=404, detail="User not found")
+    return u
+
+
+@router.get("/dashboard", response_model=DashboardStats)
+async def dashboard_stats(user: Dict = Depends(get_current_user)):
+    uid = user["user_id"]
+    settings = get_settings()
+
+    domains = await fetch_all("SELECT id FROM domains WHERE user_id=?", (uid,))
+    domain_ids = [d["id"] for d in domains]
+
+    doc_count = 0
+    total_size = 0
+    if domain_ids:
+        placeholders = ",".join("?" for _ in domain_ids)
+        docs = await fetch_all(f"SELECT size_bytes FROM documents WHERE domain_id IN ({placeholders})", tuple(domain_ids))
+        doc_count = len(docs)
+        total_size = sum(d["size_bytes"] for d in docs)
+
+    queries = await fetch_all("SELECT id FROM rag_queries WHERE user_id=?", (uid,))
+    configs = await fetch_all("SELECT id FROM reward_configs WHERE user_id=?", (uid,))
+
+    return {
+        "total_domains": len(domains),
+        "total_documents": doc_count,
+        "total_queries": len(queries),
+        "total_reward_configs": len(configs),
+        "storage_used_bytes": total_size,
+        "storage_limit_bytes": int(settings.max_upload_mb * 1024 * 1024),
+    }
+
+
+# --- API Keys ---
+
+@router.post("/api-keys", response_model=APIKeyCreated)
+async def create_key_route(body: APIKeyCreate, user: Dict = Depends(get_current_user)):
+    return await create_api_key(user["user_id"], body.name)
+
+
+@router.get("/api-keys", response_model=List[APIKeyOut])
+async def list_keys_route(user: Dict = Depends(get_current_user)):
+    return await list_api_keys(user["user_id"])
+
+
+@router.delete("/api-keys/{key_id}")
+async def revoke_key_route(key_id: str, user: Dict = Depends(get_current_user)):
+    ok = await revoke_api_key(user["user_id"], key_id)
+    if not ok:
+        raise HTTPException(status_code=404, detail="API key not found")
+    return {"ok": True}

agentic_rag_os/config.py

@@ -0,0 +1,60 @@
+"""Configuration for Agentic RAG OS."""
+
+from __future__ import annotations
+
+import os
+import secrets
+from pathlib import Path
+from typing import Optional
+
+from pydantic import Field
+from pydantic_settings import BaseSettings
+
+_ROOT = Path(__file__).resolve().parent.parent
+
+
+class RagOSSettings(BaseSettings):
+    """Central settings for the Agentic RAG OS application."""
+
+    # --- Application ---
+    app_name: str = "Agentic RAG OS"
+    secret_key: str = Field(default_factory=lambda: os.getenv("RAGOS_SECRET_KEY", secrets.token_hex(32)))
+    debug: bool = False
+    base_url: str = os.getenv("RAGOS_BASE_URL", "http://localhost:8000")
+
+    # --- Auth ---
+    jwt_algorithm: str = "HS256"
+    jwt_expiry_minutes: int = 1440  # 24h
+    github_client_id: str = os.getenv("GITHUB_CLIENT_ID", "")
+    github_client_secret: str = os.getenv("GITHUB_CLIENT_SECRET", "")
+    github_redirect_uri: str = os.getenv("GITHUB_REDIRECT_URI", "")
+
+    # --- Database (SQLite for simplicity, file-based) ---
+    db_path: Path = _ROOT / "agentic_rag_os" / "data" / "ragos.db"
+
+    # --- Upload limits ---
+    max_upload_mb: float = 2.0  # Free tier
+    premium_upload_mb: float = 100.0
+
+    # --- RAG Master bridge ---
+    gym_base_url: str = os.getenv("GYM_BASE_URL", "http://localhost:7860")
+
+    # --- Embedding ---
+    embedding_model: str = "sentence-transformers/all-MiniLM-L6-v2"
+    faiss_dimension: int = 384
+
+    # --- Server ---
+    host: str = "0.0.0.0"
+    port: int = 8000
+
+    model_config = {"env_prefix": "RAGOS_", "env_file": ".env", "extra": "ignore"}
+
+
+_settings: Optional[RagOSSettings] = None
+
+
+def get_settings() -> RagOSSettings:
+    global _settings
+    if _settings is None:
+        _settings = RagOSSettings()
+    return _settings

agentic_rag_os/frontend/index.html

@@ -0,0 +1,1936 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Agentic RAG OS — The Operating System for Agentic RAG</title>
+    <link rel="icon" type="image/svg+xml" href="data:image/svg+xml,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 100 100'><text y='.9em' font-size='90'>⚡</text></svg>">
+    <style>
+        /* ============================================================
+           AGENTIC RAG OS — Dark Theme Premium UI
+           ============================================================ */
+        :root {
+            --bg-primary: #09090b;
+            --bg-secondary: #111113;
+            --bg-card: #16161a;
+            --bg-card-hover: #1c1c21;
+            --border: #27272a;
+            --border-light: #3f3f46;
+            --text-primary: #fafafa;
+            --text-secondary: #a1a1aa;
+            --text-muted: #71717a;
+            --accent: #6d28d9;
+            --accent-light: #8b5cf6;
+            --accent-glow: rgba(139, 92, 246, 0.15);
+            --accent-2: #06b6d4;
+            --accent-3: #10b981;
+            --gradient-1: linear-gradient(135deg, #6d28d9 0%, #06b6d4 100%);
+            --gradient-2: linear-gradient(135deg, #8b5cf6 0%, #06b6d4 50%, #10b981 100%);
+            --radius: 12px;
+            --radius-lg: 20px;
+            --shadow: 0 4px 6px -1px rgba(0,0,0,0.3);
+            --shadow-lg: 0 20px 40px -12px rgba(0,0,0,0.5);
+            --transition: all 0.3s cubic-bezier(0.4, 0, 0.2, 1);
+        }
+
+        * { margin: 0; padding: 0; box-sizing: border-box; }
+
+        html {
+            scroll-behavior: smooth;
+            font-size: 16px;
+        }
+
+        body {
+            font-family: -apple-system, BlinkMacSystemFont, 'Inter', 'Segoe UI', sans-serif;
+            background: var(--bg-primary);
+            color: var(--text-primary);
+            line-height: 1.6;
+            overflow-x: hidden;
+            -webkit-font-smoothing: antialiased;
+        }
+
+        /* ---- Scrollbar ---- */
+        ::-webkit-scrollbar { width: 6px; }
+        ::-webkit-scrollbar-track { background: transparent; }
+        ::-webkit-scrollbar-thumb { background: var(--border-light); border-radius: 3px; }
+
+        /* ---- Animations ---- */
+        @keyframes fadeInUp {
+            from { opacity: 0; transform: translateY(30px); }
+            to { opacity: 1; transform: translateY(0); }
+        }
+        @keyframes fadeIn {
+            from { opacity: 0; }
+            to { opacity: 1; }
+        }
+        @keyframes float {
+            0%, 100% { transform: translateY(0); }
+            50% { transform: translateY(-10px); }
+        }
+        @keyframes pulse-glow {
+            0%, 100% { box-shadow: 0 0 20px rgba(139, 92, 246, 0.1); }
+            50% { box-shadow: 0 0 40px rgba(139, 92, 246, 0.3); }
+        }
+        @keyframes gradient-shift {
+            0% { background-position: 0% 50%; }
+            50% { background-position: 100% 50%; }
+            100% { background-position: 0% 50%; }
+        }
+        @keyframes slide-in-right {
+            from { opacity: 0; transform: translateX(40px); }
+            to { opacity: 1; transform: translateX(0); }
+        }
+        @keyframes orbit {
+            from { transform: rotate(0deg) translateX(120px) rotate(0deg); }
+            to { transform: rotate(360deg) translateX(120px) rotate(-360deg); }
+        }
+        @keyframes typewriter {
+            from { width: 0; }
+            to { width: 100%; }
+        }
+        @keyframes blink {
+            50% { border-color: transparent; }
+        }
+        @keyframes count-up {
+            from { opacity: 0; transform: scale(0.5); }
+            to { opacity: 1; transform: scale(1); }
+        }
+        @keyframes shimmer {
+            0% { background-position: -200% 0; }
+            100% { background-position: 200% 0; }
+        }
+
+        .animate-in { animation: fadeInUp 0.7s ease-out forwards; opacity: 0; }
+        .animate-in:nth-child(2) { animation-delay: 0.1s; }
+        .animate-in:nth-child(3) { animation-delay: 0.2s; }
+        .animate-in:nth-child(4) { animation-delay: 0.3s; }
+
+        /* ---- Grid Background ---- */
+        .grid-bg {
+            position: fixed;
+            inset: 0;
+            background-image:
+                linear-gradient(rgba(139,92,246,0.03) 1px, transparent 1px),
+                linear-gradient(90deg, rgba(139,92,246,0.03) 1px, transparent 1px);
+            background-size: 60px 60px;
+            pointer-events: none;
+            z-index: 0;
+        }
+
+        /* ---- Glow Orbs ---- */
+        .glow-orb {
+            position: absolute;
+            border-radius: 50%;
+            filter: blur(80px);
+            pointer-events: none;
+            z-index: 0;
+        }
+        .glow-orb-1 { width: 400px; height: 400px; background: rgba(109,40,217,0.15); top: -100px; left: -100px; }
+        .glow-orb-2 { width: 300px; height: 300px; background: rgba(6,182,212,0.1); top: 200px; right: -80px; }
+        .glow-orb-3 { width: 350px; height: 350px; background: rgba(16,185,129,0.08); bottom: -100px; left: 30%; }
+
+        /* ---- Container ---- */
+        .container {
+            max-width: 1200px;
+            margin: 0 auto;
+            padding: 0 24px;
+            position: relative;
+            z-index: 1;
+        }
+
+        /* ============ NAVBAR ============ */
+        .navbar {
+            position: fixed;
+            top: 0;
+            left: 0;
+            right: 0;
+            z-index: 100;
+            background: rgba(9,9,11,0.8);
+            backdrop-filter: blur(20px);
+            border-bottom: 1px solid var(--border);
+            transition: var(--transition);
+        }
+        .navbar .container {
+            display: flex;
+            align-items: center;
+            justify-content: space-between;
+            height: 64px;
+        }
+        .nav-brand {
+            display: flex;
+            align-items: center;
+            gap: 10px;
+            font-size: 1.2rem;
+            font-weight: 700;
+            text-decoration: none;
+            color: var(--text-primary);
+        }
+        .nav-brand .logo {
+            width: 32px;
+            height: 32px;
+            background: var(--gradient-1);
+            border-radius: 8px;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            font-size: 18px;
+        }
+        .nav-links {
+            display: flex;
+            align-items: center;
+            gap: 32px;
+            list-style: none;
+        }
+        .nav-links a {
+            color: var(--text-secondary);
+            text-decoration: none;
+            font-size: 0.9rem;
+            font-weight: 500;
+            transition: var(--transition);
+        }
+        .nav-links a:hover { color: var(--text-primary); }
+        .nav-actions { display: flex; gap: 12px; align-items: center; }
+
+        /* ---- Buttons ---- */
+        .btn {
+            display: inline-flex;
+            align-items: center;
+            gap: 8px;
+            padding: 10px 20px;
+            border-radius: var(--radius);
+            font-size: 0.9rem;
+            font-weight: 600;
+            cursor: pointer;
+            border: none;
+            transition: var(--transition);
+            text-decoration: none;
+        }
+        .btn-primary {
+            background: var(--gradient-1);
+            color: white;
+            box-shadow: 0 4px 15px rgba(109,40,217,0.3);
+        }
+        .btn-primary:hover {
+            transform: translateY(-2px);
+            box-shadow: 0 8px 25px rgba(109,40,217,0.4);
+        }
+        .btn-secondary {
+            background: transparent;
+            color: var(--text-primary);
+            border: 1px solid var(--border-light);
+        }
+        .btn-secondary:hover {
+            background: var(--bg-card);
+            border-color: var(--accent-light);
+        }
+        .btn-ghost {
+            background: transparent;
+            color: var(--text-secondary);
+            padding: 8px 16px;
+        }
+        .btn-ghost:hover { color: var(--text-primary); }
+        .btn-lg { padding: 14px 32px; font-size: 1rem; border-radius: 14px; }
+        .btn-sm { padding: 6px 14px; font-size: 0.8rem; }
+        .btn-icon { padding: 8px; border-radius: 8px; }
+
+        /* ============ HERO ============ */
+        .hero {
+            padding: 160px 0 100px;
+            position: relative;
+            overflow: hidden;
+            text-align: center;
+        }
+        .hero-badge {
+            display: inline-flex;
+            align-items: center;
+            gap: 8px;
+            padding: 6px 16px;
+            background: var(--accent-glow);
+            border: 1px solid rgba(139,92,246,0.2);
+            border-radius: 100px;
+            font-size: 0.8rem;
+            color: var(--accent-light);
+            margin-bottom: 28px;
+            animation: fadeIn 0.8s ease-out;
+        }
+        .hero-badge .dot {
+            width: 6px;
+            height: 6px;
+            background: var(--accent-light);
+            border-radius: 50%;
+            animation: pulse-glow 2s ease-in-out infinite;
+        }
+        .hero h1 {
+            font-size: clamp(2.5rem, 6vw, 4.5rem);
+            font-weight: 800;
+            line-height: 1.1;
+            letter-spacing: -0.03em;
+            margin-bottom: 24px;
+            animation: fadeInUp 0.8s ease-out;
+        }
+        .hero h1 .gradient-text {
+            background: var(--gradient-2);
+            background-size: 200% auto;
+            -webkit-background-clip: text;
+            -webkit-text-fill-color: transparent;
+            animation: gradient-shift 4s ease infinite;
+        }
+        .hero-subtitle {
+            font-size: 1.25rem;
+            color: var(--text-secondary);
+            max-width: 640px;
+            margin: 0 auto 40px;
+            animation: fadeInUp 0.8s ease-out 0.2s forwards;
+            opacity: 0;
+        }
+        .hero-actions {
+            display: flex;
+            gap: 16px;
+            justify-content: center;
+            animation: fadeInUp 0.8s ease-out 0.4s forwards;
+            opacity: 0;
+        }
+
+        /* Hero visual */
+        .hero-visual {
+            margin-top: 80px;
+            position: relative;
+            animation: fadeInUp 1s ease-out 0.6s forwards;
+            opacity: 0;
+        }
+        .hero-terminal {
+            background: var(--bg-card);
+            border: 1px solid var(--border);
+            border-radius: var(--radius-lg);
+            padding: 0;
+            max-width: 800px;
+            margin: 0 auto;
+            overflow: hidden;
+            box-shadow: var(--shadow-lg);
+        }
+        .terminal-header {
+            display: flex;
+            align-items: center;
+            gap: 8px;
+            padding: 12px 16px;
+            background: rgba(255,255,255,0.02);
+            border-bottom: 1px solid var(--border);
+        }
+        .terminal-dot {
+            width: 12px;
+            height: 12px;
+            border-radius: 50%;
+        }
+        .terminal-dot.red { background: #ff5f56; }
+        .terminal-dot.yellow { background: #ffbd2e; }
+        .terminal-dot.green { background: #27c93f; }
+        .terminal-title {
+            flex: 1;
+            text-align: center;
+            font-size: 0.8rem;
+            color: var(--text-muted);
+        }
+        .terminal-body {
+            padding: 24px;
+            font-family: 'SF Mono', 'Fira Code', monospace;
+            font-size: 0.85rem;
+            line-height: 1.8;
+            color: var(--text-secondary);
+        }
+        .terminal-body .cmd { color: var(--accent-2); }
+        .terminal-body .str { color: var(--accent-3); }
+        .terminal-body .comment { color: var(--text-muted); }
+        .terminal-body .num { color: #f59e0b; }
+
+        /* ============ LOGOS BAR ============ */
+        .logos-bar {
+            padding: 60px 0;
+            border-top: 1px solid var(--border);
+            border-bottom: 1px solid var(--border);
+        }
+        .logos-bar p {
+            text-align: center;
+            font-size: 0.8rem;
+            color: var(--text-muted);
+            text-transform: uppercase;
+            letter-spacing: 0.1em;
+            margin-bottom: 30px;
+        }
+        .logos-grid {
+            display: flex;
+            justify-content: center;
+            align-items: center;
+            gap: 48px;
+            flex-wrap: wrap;
+        }
+        .logo-item {
+            font-size: 1rem;
+            font-weight: 600;
+            color: var(--text-muted);
+            transition: var(--transition);
+            display: flex;
+            align-items: center;
+            gap: 8px;
+        }
+        .logo-item:hover { color: var(--text-secondary); }
+        .logo-item span { font-size: 1.3rem; }
+
+        /* ============ SECTION BASE ============ */
+        section {
+            padding: 100px 0;
+            position: relative;
+        }
+        .section-label {
+            font-size: 0.8rem;
+            text-transform: uppercase;
+            letter-spacing: 0.15em;
+            color: var(--accent-light);
+            font-weight: 600;
+            margin-bottom: 12px;
+        }
+        .section-title {
+            font-size: clamp(1.8rem, 4vw, 2.8rem);
+            font-weight: 800;
+            letter-spacing: -0.02em;
+            margin-bottom: 16px;
+        }
+        .section-desc {
+            font-size: 1.1rem;
+            color: var(--text-secondary);
+            max-width: 600px;
+            margin-bottom: 60px;
+        }
+
+        /* ============ FEATURES ============ */
+        .features-grid {
+            display: grid;
+            grid-template-columns: repeat(3, 1fr);
+            gap: 24px;
+        }
+        .feature-card {
+            background: var(--bg-card);
+            border: 1px solid var(--border);
+            border-radius: var(--radius-lg);
+            padding: 32px;
+            transition: var(--transition);
+            position: relative;
+            overflow: hidden;
+        }
+        .feature-card::before {
+            content: '';
+            position: absolute;
+            top: 0;
+            left: 0;
+            right: 0;
+            height: 2px;
+            background: var(--gradient-1);
+            opacity: 0;
+            transition: var(--transition);
+        }
+        .feature-card:hover {
+            border-color: var(--border-light);
+            transform: translateY(-4px);
+            box-shadow: var(--shadow-lg);
+        }
+        .feature-card:hover::before { opacity: 1; }
+        .feature-icon {
+            width: 48px;
+            height: 48px;
+            border-radius: 12px;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            font-size: 24px;
+            margin-bottom: 20px;
+            background: var(--accent-glow);
+        }
+        .feature-card h3 {
+            font-size: 1.1rem;
+            font-weight: 700;
+            margin-bottom: 8px;
+        }
+        .feature-card p {
+            color: var(--text-secondary);
+            font-size: 0.9rem;
+        }
+
+        /* ============ HOW IT WORKS ============ */
+        .steps-container {
+            display: grid;
+            grid-template-columns: repeat(4, 1fr);
+            gap: 24px;
+            position: relative;
+        }
+        .steps-container::before {
+            content: '';
+            position: absolute;
+            top: 36px;
+            left: 60px;
+            right: 60px;
+            height: 2px;
+            background: linear-gradient(90deg, var(--accent) 0%, var(--accent-2) 50%, var(--accent-3) 100%);
+            opacity: 0.3;
+        }
+        .step-item {
+            text-align: center;
+            position: relative;
+        }
+        .step-number {
+            width: 72px;
+            height: 72px;
+            border-radius: 50%;
+            background: var(--bg-card);
+            border: 2px solid var(--border);
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            margin: 0 auto 20px;
+            font-size: 1.5rem;
+            font-weight: 800;
+            color: var(--accent-light);
+            transition: var(--transition);
+            position: relative;
+            z-index: 1;
+        }
+        .step-item:hover .step-number {
+            border-color: var(--accent-light);
+            box-shadow: 0 0 30px rgba(139,92,246,0.2);
+        }
+        .step-item h3 {
+            font-size: 1rem;
+            font-weight: 700;
+            margin-bottom: 8px;
+        }
+        .step-item p {
+            font-size: 0.85rem;
+            color: var(--text-secondary);
+        }
+
+        /* ============ PRICING ============ */
+        .pricing-grid {
+            display: grid;
+            grid-template-columns: repeat(2, 1fr);
+            gap: 24px;
+            max-width: 800px;
+            margin: 0 auto;
+        }
+        .price-card {
+            background: var(--bg-card);
+            border: 1px solid var(--border);
+            border-radius: var(--radius-lg);
+            padding: 40px;
+            transition: var(--transition);
+        }
+        .price-card.featured {
+            border-color: var(--accent);
+            box-shadow: 0 0 40px rgba(109,40,217,0.15);
+            position: relative;
+        }
+        .price-card.featured::before {
+            content: 'POPULAR';
+            position: absolute;
+            top: -12px;
+            right: 24px;
+            background: var(--gradient-1);
+            color: white;
+            font-size: 0.7rem;
+            font-weight: 700;
+            padding: 4px 12px;
+            border-radius: 100px;
+        }
+        .price-card h3 {
+            font-size: 1.2rem;
+            font-weight: 700;
+            margin-bottom: 8px;
+        }
+        .price-card .price {
+            font-size: 2.5rem;
+            font-weight: 800;
+            margin: 16px 0;
+        }
+        .price-card .price span { font-size: 1rem; color: var(--text-muted); font-weight: 400; }
+        .price-card ul {
+            list-style: none;
+            margin: 24px 0;
+        }
+        .price-card li {
+            padding: 8px 0;
+            font-size: 0.9rem;
+            color: var(--text-secondary);
+            display: flex;
+            align-items: center;
+            gap: 8px;
+        }
+        .price-card li::before {
+            content: '✓';
+            color: var(--accent-3);
+            font-weight: 700;
+        }
+
+        /* ============ API DOCS ============ */
+        .api-section { background: var(--bg-secondary); border-radius: var(--radius-lg); padding: 60px; margin-top: 40px; }
+        .api-grid { display: grid; grid-template-columns: repeat(2, 1fr); gap: 20px; }
+        .api-card {
+            background: var(--bg-primary);
+            border: 1px solid var(--border);
+            border-radius: var(--radius);
+            padding: 20px;
+            transition: var(--transition);
+        }
+        .api-card:hover {
+            border-color: var(--border-light);
+        }
+        .api-method {
+            display: inline-block;
+            padding: 2px 8px;
+            border-radius: 4px;
+            font-size: 0.7rem;
+            font-weight: 700;
+            font-family: monospace;
+            margin-right: 8px;
+        }
+        .api-method.get { background: rgba(16,185,129,0.15); color: #10b981; }
+        .api-method.post { background: rgba(59,130,246,0.15); color: #3b82f6; }
+        .api-method.delete { background: rgba(239,68,68,0.15); color: #ef4444; }
+        .api-path {
+            font-family: 'SF Mono', monospace;
+            font-size: 0.85rem;
+            color: var(--text-primary);
+        }
+        .api-desc {
+            font-size: 0.8rem;
+            color: var(--text-muted);
+            margin-top: 8px;
+        }
+
+        /* ============ CTA ============ */
+        .cta-section {
+            text-align: center;
+            padding: 120px 0;
+            position: relative;
+        }
+        .cta-section::before {
+            content: '';
+            position: absolute;
+            inset: 0;
+            background: radial-gradient(ellipse at center, rgba(109,40,217,0.08) 0%, transparent 70%);
+            pointer-events: none;
+        }
+        .cta-section h2 {
+            font-size: clamp(2rem, 4vw, 3rem);
+            font-weight: 800;
+            margin-bottom: 16px;
+        }
+        .cta-section p {
+            font-size: 1.1rem;
+            color: var(--text-secondary);
+            margin-bottom: 40px;
+        }
+
+        /* ============ FOOTER ============ */
+        .footer {
+            padding: 60px 0 30px;
+            border-top: 1px solid var(--border);
+        }
+        .footer-grid {
+            display: grid;
+            grid-template-columns: 2fr 1fr 1fr 1fr;
+            gap: 40px;
+            margin-bottom: 40px;
+        }
+        .footer-brand h3 { font-size: 1.1rem; font-weight: 700; margin-bottom: 8px; }
+        .footer-brand p { color: var(--text-muted); font-size: 0.85rem; }
+        .footer h4 { font-size: 0.85rem; font-weight: 600; margin-bottom: 16px; color: var(--text-secondary); }
+        .footer ul { list-style: none; }
+        .footer li { margin-bottom: 8px; }
+        .footer a { color: var(--text-muted); text-decoration: none; font-size: 0.85rem; transition: var(--transition); }
+        .footer a:hover { color: var(--text-primary); }
+        .footer-bottom {
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            padding-top: 24px;
+            border-top: 1px solid var(--border);
+            font-size: 0.8rem;
+            color: var(--text-muted);
+        }
+
+        /* ============ DASHBOARD (SPA views) ============ */
+        .app-view { display: none; min-height: 100vh; padding-top: 80px; }
+        .app-view.active { display: block; }
+
+        .dashboard-header {
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            margin-bottom: 32px;
+        }
+        .dashboard-header h1 { font-size: 1.8rem; font-weight: 700; }
+
+        .stats-grid {
+            display: grid;
+            grid-template-columns: repeat(4, 1fr);
+            gap: 20px;
+            margin-bottom: 40px;
+        }
+        .stat-card {
+            background: var(--bg-card);
+            border: 1px solid var(--border);
+            border-radius: var(--radius);
+            padding: 24px;
+            transition: var(--transition);
+        }
+        .stat-card:hover { border-color: var(--border-light); }
+        .stat-label { font-size: 0.8rem; color: var(--text-muted); margin-bottom: 8px; }
+        .stat-value { font-size: 2rem; font-weight: 800; }
+        .stat-value.accent { color: var(--accent-light); }
+
+        .card {
+            background: var(--bg-card);
+            border: 1px solid var(--border);
+            border-radius: var(--radius-lg);
+            padding: 32px;
+            margin-bottom: 24px;
+        }
+        .card h2 { font-size: 1.3rem; font-weight: 700; margin-bottom: 20px; }
+
+        /* Tables */
+        .data-table { width: 100%; border-collapse: collapse; }
+        .data-table th {
+            text-align: left;
+            padding: 12px 16px;
+            font-size: 0.8rem;
+            font-weight: 600;
+            color: var(--text-muted);
+            text-transform: uppercase;
+            letter-spacing: 0.05em;
+            border-bottom: 1px solid var(--border);
+        }
+        .data-table td {
+            padding: 12px 16px;
+            font-size: 0.9rem;
+            border-bottom: 1px solid var(--border);
+            color: var(--text-secondary);
+        }
+        .data-table tr:hover td { background: rgba(255,255,255,0.02); }
+
+        /* Forms */
+        .form-group { margin-bottom: 20px; }
+        .form-group label {
+            display: block;
+            font-size: 0.85rem;
+            font-weight: 600;
+            margin-bottom: 6px;
+            color: var(--text-secondary);
+        }
+        .form-input {
+            width: 100%;
+            padding: 10px 14px;
+            background: var(--bg-primary);
+            border: 1px solid var(--border);
+            border-radius: 8px;
+            color: var(--text-primary);
+            font-size: 0.9rem;
+            transition: var(--transition);
+        }
+        .form-input:focus {
+            outline: none;
+            border-color: var(--accent-light);
+            box-shadow: 0 0 0 3px var(--accent-glow);
+        }
+        .form-select {
+            appearance: none;
+            width: 100%;
+            padding: 10px 14px;
+            background: var(--bg-primary) url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='12' height='8' fill='%2371717a'%3E%3Cpath d='M6 8L0 0h12z'/%3E%3C/svg%3E") no-repeat right 14px center;
+            border: 1px solid var(--border);
+            border-radius: 8px;
+            color: var(--text-primary);
+            font-size: 0.9rem;
+            cursor: pointer;
+        }
+        textarea.form-input {
+            resize: vertical;
+            min-height: 100px;
+            font-family: 'SF Mono', monospace;
+            font-size: 0.85rem;
+        }
+
+        /* Tags */
+        .tag {
+            display: inline-block;
+            padding: 2px 10px;
+            border-radius: 100px;
+            font-size: 0.75rem;
+            font-weight: 600;
+        }
+        .tag-success { background: rgba(16,185,129,0.15); color: #10b981; }
+        .tag-info { background: rgba(59,130,246,0.15); color: #3b82f6; }
+        .tag-warning { background: rgba(245,158,11,0.15); color: #f59e0b; }
+
+        /* Modal */
+        .modal-overlay {
+            display: none;
+            position: fixed;
+            inset: 0;
+            background: rgba(0,0,0,0.6);
+            backdrop-filter: blur(4px);
+            z-index: 200;
+            align-items: center;
+            justify-content: center;
+        }
+        .modal-overlay.active { display: flex; }
+        .modal {
+            background: var(--bg-card);
+            border: 1px solid var(--border);
+            border-radius: var(--radius-lg);
+            padding: 32px;
+            width: 90%;
+            max-width: 500px;
+            animation: fadeInUp 0.3s ease-out;
+        }
+        .modal h2 { font-size: 1.3rem; margin-bottom: 20px; }
+        .modal-actions { display: flex; gap: 12px; justify-content: flex-end; margin-top: 24px; }
+
+        /* Toast */
+        .toast-container {
+            position: fixed;
+            top: 80px;
+            right: 24px;
+            z-index: 300;
+            display: flex;
+            flex-direction: column;
+            gap: 8px;
+        }
+        .toast {
+            background: var(--bg-card);
+            border: 1px solid var(--border);
+            border-radius: var(--radius);
+            padding: 12px 20px;
+            font-size: 0.85rem;
+            animation: slide-in-right 0.3s ease-out;
+            box-shadow: var(--shadow-lg);
+            max-width: 360px;
+        }
+        .toast.success { border-left: 3px solid var(--accent-3); }
+        .toast.error { border-left: 3px solid #ef4444; }
+        .toast.info { border-left: 3px solid var(--accent-2); }
+
+        /* Auth Modal */
+        .auth-tabs { display: flex; gap: 0; margin-bottom: 24px; }
+        .auth-tab {
+            flex: 1;
+            padding: 12px;
+            text-align: center;
+            cursor: pointer;
+            font-weight: 600;
+            font-size: 0.9rem;
+            color: var(--text-muted);
+            border-bottom: 2px solid var(--border);
+            transition: var(--transition);
+            background: none;
+            border-top: none;
+            border-left: none;
+            border-right: none;
+        }
+        .auth-tab.active { color: var(--accent-light); border-bottom-color: var(--accent-light); }
+        .auth-divider {
+            display: flex;
+            align-items: center;
+            gap: 16px;
+            margin: 20px 0;
+            color: var(--text-muted);
+            font-size: 0.8rem;
+        }
+        .auth-divider::before, .auth-divider::after {
+            content: '';
+            flex: 1;
+            height: 1px;
+            background: var(--border);
+        }
+        .github-btn {
+            width: 100%;
+            padding: 12px;
+            background: #24292e;
+            color: white;
+            border: 1px solid #444;
+            border-radius: 8px;
+            font-size: 0.9rem;
+            font-weight: 600;
+            cursor: pointer;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            gap: 10px;
+            transition: var(--transition);
+        }
+        .github-btn:hover { background: #2d333b; }
+        .github-btn svg { width: 20px; height: 20px; fill: white; }
+
+        /* Reward playground */
+        .reward-playground {
+            background: var(--bg-secondary);
+            border: 1px solid var(--border);
+            border-radius: var(--radius-lg);
+            padding: 32px;
+        }
+        .reward-result {
+            margin-top: 24px;
+            padding: 24px;
+            background: var(--bg-primary);
+            border: 1px solid var(--border);
+            border-radius: var(--radius);
+        }
+        .reward-score {
+            font-size: 3rem;
+            font-weight: 800;
+            text-align: center;
+            margin: 16px 0;
+        }
+        .reward-breakdown {
+            display: grid;
+            grid-template-columns: repeat(auto-fit, minmax(150px, 1fr));
+            gap: 12px;
+        }
+        .reward-bar {
+            background: var(--bg-card);
+            border-radius: 8px;
+            padding: 12px;
+        }
+        .reward-bar-label {
+            font-size: 0.75rem;
+            color: var(--text-muted);
+            margin-bottom: 8px;
+        }
+        .reward-bar-track {
+            width: 100%;
+            height: 6px;
+            background: var(--border);
+            border-radius: 3px;
+            overflow: hidden;
+        }
+        .reward-bar-fill {
+            height: 100%;
+            border-radius: 3px;
+            transition: width 0.5s ease;
+        }
+
+        /* Mobile sidebar for dashboard */
+        .sidebar { display: none; }
+
+        /* ============ RESPONSIVE ============ */
+        @media (max-width: 1024px) {
+            .features-grid { grid-template-columns: repeat(2, 1fr); }
+            .steps-container { grid-template-columns: repeat(2, 1fr); }
+            .steps-container::before { display: none; }
+            .footer-grid { grid-template-columns: repeat(2, 1fr); }
+            .stats-grid { grid-template-columns: repeat(2, 1fr); }
+            .api-grid { grid-template-columns: 1fr; }
+        }
+        @media (max-width: 768px) {
+            .nav-links { display: none; }
+            .features-grid { grid-template-columns: 1fr; }
+            .pricing-grid { grid-template-columns: 1fr; }
+            .steps-container { grid-template-columns: 1fr; }
+            .footer-grid { grid-template-columns: 1fr; }
+            .hero h1 { font-size: 2.2rem; }
+            .stats-grid { grid-template-columns: 1fr 1fr; }
+        }
+    </style>
+</head>
+<body>
+    <div class="grid-bg"></div>
+    <div class="toast-container" id="toastContainer"></div>
+
+    <!-- ============ NAVBAR ============ -->
+    <nav class="navbar" id="navbar">
+        <div class="container">
+            <a href="#" class="nav-brand" onclick="showView('landing')">
+                <div class="logo">⚡</div>
+                <span>Agentic RAG OS</span>
+            </a>
+            <ul class="nav-links" id="navLinks">
+                <li><a href="#features" onclick="showView('landing')">Features</a></li>
+                <li><a href="#how-it-works" onclick="showView('landing')">How It Works</a></li>
+                <li><a href="#pricing" onclick="showView('landing')">Pricing</a></li>
+                <li><a href="#api-reference" onclick="showView('landing')">API</a></li>
+                <li><a href="/api/docs" target="_blank">Docs</a></li>
+            </ul>
+            <div class="nav-actions" id="navActions">
+                <button class="btn btn-ghost" id="navLoginBtn" onclick="showAuthModal()">Log In</button>
+                <button class="btn btn-primary" id="navSignupBtn" onclick="showAuthModal('register')">Get Started</button>
+                <div style="display:none" id="navUserMenu">
+                    <button class="btn btn-secondary btn-sm" onclick="showView('dashboard')">Dashboard</button>
+                    <button class="btn btn-ghost btn-sm" onclick="logout()">Logout</button>
+                </div>
+            </div>
+        </div>
+    </nav>
+
+    <!-- ============ AUTH MODAL ============ -->
+    <div class="modal-overlay" id="authModal">
+        <div class="modal">
+            <div class="auth-tabs">
+                <button class="auth-tab active" id="tabLogin" onclick="switchAuthTab('login')">Sign In</button>
+                <button class="auth-tab" id="tabRegister" onclick="switchAuthTab('register')">Create Account</button>
+            </div>
+
+            <button class="github-btn" onclick="githubLogin()">
+                <svg viewBox="0 0 24 24"><path d="M12 0C5.37 0 0 5.37 0 12c0 5.31 3.435 9.795 8.205 11.385.6.105.825-.255.825-.57 0-.285-.015-1.23-.015-2.235-3.015.555-3.795-.735-4.035-1.41-.135-.345-.72-1.41-1.23-1.695-.42-.225-1.02-.78-.015-.795.945-.015 1.62.87 1.845 1.23 1.08 1.815 2.805 1.305 3.495.99.105-.78.42-1.305.765-1.605-2.67-.3-5.46-1.335-5.46-5.925 0-1.305.465-2.385 1.23-3.225-.12-.3-.54-1.53.12-3.18 0 0 1.005-.315 3.3 1.23.96-.27 1.98-.405 3-.405s2.04.135 3 .405c2.295-1.56 3.3-1.23 3.3-1.23.66 1.65.24 2.88.12 3.18.765.84 1.23 1.905 1.23 3.225 0 4.605-2.805 5.625-5.475 5.925.435.375.81 1.095.81 2.22 0 1.605-.015 2.895-.015 3.3 0 .315.225.69.825.57A12.02 12.02 0 0024 12c0-6.63-5.37-12-12-12z"/></svg>
+                Continue with GitHub
+            </button>
+
+            <div class="auth-divider">or</div>
+
+            <form id="authForm" onsubmit="handleAuth(event)">
+                <div class="form-group" id="usernameGroup">
+                    <label>Username</label>
+                    <input type="text" class="form-input" id="authUsername" placeholder="your_username" required>
+                </div>
+                <div class="form-group" id="emailGroup" style="display:none">
+                    <label>Email</label>
+                    <input type="email" class="form-input" id="authEmail" placeholder="you@company.com">
+                </div>
+                <div class="form-group">
+                    <label>Password</label>
+                    <input type="password" class="form-input" id="authPassword" placeholder="••••••••" required minlength="8">
+                </div>
+                <button type="submit" class="btn btn-primary" style="width:100%; justify-content:center; margin-top:8px;" id="authSubmitBtn">Sign In</button>
+            </form>
+
+            <div style="text-align:center; margin-top:16px">
+                <button class="btn btn-ghost btn-sm" onclick="closeAuthModal()">Cancel</button>
+            </div>
+        </div>
+    </div>
+
+    <!-- ============ LANDING PAGE ============ -->
+    <div class="app-view active" id="viewLanding">
+        <!-- HERO -->
+        <section class="hero">
+            <div class="glow-orb glow-orb-1"></div>
+            <div class="glow-orb glow-orb-2"></div>
+            <div class="container">
+                <div class="hero-badge">
+                    <span class="dot"></span>
+                    RL B2B Rewards-as-a-Service
+                </div>
+                <h1>
+                    The Operating System<br>
+                    for <span class="gradient-text">Agentic RAG</span>
+                </h1>
+                <p class="hero-subtitle">
+                    Transform your data into intelligent retrieval pipelines and generate production-ready reward signals for LLM fine-tuning — all from one platform.
+                </p>
+                <div class="hero-actions">
+                    <button class="btn btn-primary btn-lg" onclick="showAuthModal('register')">Start Building Free →</button>
+                    <a href="/api/docs" target="_blank" class="btn btn-secondary btn-lg">View API Docs</a>
+                </div>
+
+                <div class="hero-visual">
+                    <div class="hero-terminal">
+                        <div class="terminal-header">
+                            <span class="terminal-dot red"></span>
+                            <span class="terminal-dot yellow"></span>
+                            <span class="terminal-dot green"></span>
+                            <span class="terminal-title">agentic-rag-os — rewards-as-a-service</span>
+                        </div>
+                        <div class="terminal-body">
+                            <div><span class="comment"># Upload your data, generate rewards in seconds</span></div>
+                            <div><span class="cmd">POST</span> /api/v1/rag/domains/my-app/documents &nbsp;<span class="str">← upload</span></div>
+                            <div><span class="cmd">POST</span> /api/v1/rag/domains/my-app/query &nbsp;<span class="str">← retrieve</span></div>
+                            <div><span class="cmd">POST</span> /api/v1/rewards/compute &nbsp;<span class="str">← generate reward</span></div>
+                            <div style="margin-top:12px"><span class="comment"># Response</span></div>
+                            <div>{ <span class="str">"total_reward"</span>: <span class="num">0.847</span>, <span class="str">"algorithm"</span>: <span class="str">"grpo"</span>,</div>
+                            <div>&nbsp;&nbsp;<span class="str">"breakdown"</span>: { <span class="str">"retrieval"</span>: <span class="num">0.92</span>, <span class="str">"reasoning"</span>: <span class="num">0.78</span>, <span class="str">"completeness"</span>: <span class="num">0.85</span> }}</div>
+                        </div>
+                    </div>
+                </div>
+            </div>
+        </section>
+
+        <!-- LOGOS BAR -->
+        <section class="logos-bar">
+            <div class="container">
+                <p>Built with industry-leading technologies</p>
+                <div class="logos-grid">
+                    <div class="logo-item"><span>🤗</span> HuggingFace</div>
+                    <div class="logo-item"><span>🔥</span> PyTorch</div>
+                    <div class="logo-item"><span>⚡</span> FastAPI</div>
+                    <div class="logo-item"><span>🔍</span> FAISS</div>
+                    <div class="logo-item"><span>🧠</span> Sentence Transformers</div>
+                    <div class="logo-item"><span>☁️</span> Google Cloud</div>
+                </div>
+            </div>
+        </section>
+
+        <!-- FEATURES -->
+        <section id="features">
+            <div class="container">
+                <div class="section-label">Platform</div>
+                <h2 class="section-title">Everything you need to build<br>intelligent RAG systems</h2>
+                <p class="section-desc">From data ingestion to reward generation — a complete operating system for agentic retrieval-augmented generation.</p>
+
+                <div class="features-grid">
+                    <div class="feature-card animate-in">
+                        <div class="feature-icon">📄</div>
+                        <h3>Data → Embeddings Pipeline</h3>
+                        <p>Upload text documents, automatically generate embeddings with sentence-transformers, and store them in high-performance FAISS indices.</p>
+                    </div>
+                    <div class="feature-card animate-in">
+                        <div class="feature-icon">🎯</div>
+                        <h3>Rewards-as-a-Service</h3>
+                        <p>Generate production-ready reward signals for GRPO, PPO, DPO, REINFORCE — choose your algorithm, define your rules, get rewards via API.</p>
+                    </div>
+                    <div class="feature-card animate-in">
+                        <div class="feature-icon">🤖</div>
+                        <h3>Multi-Agent Orchestrator</h3>
+                        <p>Five specialized agents — Retriever, Reasoner, Critic, Planner, Verifier — collaborate through structured message-passing.</p>
+                    </div>
+                    <div class="feature-card animate-in">
+                        <div class="feature-icon">🛡️</div>
+                        <h3>Anti-Reward Hacking</h3>
+                        <p>Built-in adversarial guards detect and penalize repetition, keyword stuffing, degenerate content, and copy-paste exploitation.</p>
+                    </div>
+                    <div class="feature-card animate-in">
+                        <div class="feature-icon">🔌</div>
+                        <h3>API-First Design</h3>
+                        <p>Every capability is an API endpoint. Integrate with any LLM training pipeline — compatible with TRL, OpenRLHF, and custom stacks.</p>
+                    </div>
+                    <div class="feature-card animate-in">
+                        <div class="feature-icon">🌐</div>
+                        <h3>Domain Agnostic</h3>
+                        <p>Works with any knowledge domain. Built-in support for Aerospace Research and Legal Research with extensible adapter pattern.</p>
+                    </div>
+                </div>
+            </div>
+        </section>
+
+        <!-- HOW IT WORKS -->
+        <section id="how-it-works">
+            <div class="container">
+                <div class="section-label">Workflow</div>
+                <h2 class="section-title">From raw data to reward signals<br>in four steps</h2>
+                <p class="section-desc">The simplest path from your proprietary data to RL-ready reward functions for LLM fine-tuning.</p>
+
+                <div class="steps-container">
+                    <div class="step-item animate-in">
+                        <div class="step-number">1</div>
+                        <h3>Create Domain</h3>
+                        <p>Define your knowledge domain — aerospace, legal, medical, finance, or anything custom.</p>
+                    </div>
+                    <div class="step-item animate-in">
+                        <div class="step-number">2</div>
+                        <h3>Upload Documents</h3>
+                        <p>Feed your text data. We embed, index, and store it in high-performance FAISS vector stores.</p>
+                    </div>
+                    <div class="step-item animate-in">
+                        <div class="step-number">3</div>
+                        <h3>Configure Rewards</h3>
+                        <p>Choose algorithm (GRPO/PPO/DPO), set weights, define rules. Your reward function, your way.</p>
+                    </div>
+                    <div class="step-item animate-in">
+                        <div class="step-number">4</div>
+                        <h3>Generate & Train</h3>
+                        <p>Call our API to compute rewards at scale. Use them in your RL training loop to fine-tune any LLM.</p>
+                    </div>
+                </div>
+            </div>
+        </section>
+
+        <!-- PRICING -->
+        <section id="pricing">
+            <div class="container">
+                <div style="text-align:center">
+                    <div class="section-label">Pricing</div>
+                    <h2 class="section-title">Start free. Scale when ready.</h2>
+                    <p class="section-desc" style="margin:0 auto 60px">Simple, transparent pricing that grows with your team.</p>
+                </div>
+
+                <div class="pricing-grid">
+                    <div class="price-card featured">
+                        <h3>Free</h3>
+                        <p style="color:var(--text-muted);font-size:0.9rem">Perfect for experiments & prototypes</p>
+                        <div class="price">$0<span>/month</span></div>
+                        <ul>
+                            <li>2 MB document storage per domain</li>
+                            <li>Unlimited reward computations</li>
+                            <li>All 5 RL algorithms (GRPO, PPO, DPO, ...)</li>
+                            <li>Full API access</li>
+                            <li>Community support</li>
+                        </ul>
+                        <button class="btn btn-primary" style="width:100%;justify-content:center" onclick="showAuthModal('register')">Get Started Free</button>
+                    </div>
+                    <div class="price-card">
+                        <h3>Premium</h3>
+                        <p style="color:var(--text-muted);font-size:0.9rem">For teams building production RAG systems</p>
+                        <div class="price" style="color:var(--text-muted)">Coming Soon</div>
+                        <ul>
+                            <li>100 MB+ document storage</li>
+                            <li>Custom embedding models</li>
+                            <li>Priority reward compute</li>
+                            <li>Team collaboration</li>
+                            <li>Dedicated support</li>
+                            <li>Custom domain graders</li>
+                            <li>SSO & advanced auth</li>
+                        </ul>
+                        <button class="btn btn-secondary" style="width:100%;justify-content:center; opacity:0.6" disabled>Coming Soon</button>
+                    </div>
+                </div>
+            </div>
+        </section>
+
+        <!-- API REFERENCE -->
+        <section id="api-reference">
+            <div class="container">
+                <div class="section-label">Developer</div>
+                <h2 class="section-title">API Reference</h2>
+                <p class="section-desc">RESTful API with full OpenAPI documentation. Integrate in minutes.</p>
+
+                <div class="api-section">
+                    <div style="display:flex; justify-content:space-between; align-items:center; margin-bottom:24px">
+                        <h3 style="font-size:1.1rem">Core Endpoints</h3>
+                        <a href="/api/docs" target="_blank" class="btn btn-secondary btn-sm">Full Docs →</a>
+                    </div>
+                    <div class="api-grid">
+                        <div class="api-card">
+                            <span class="api-method post">POST</span>
+                            <span class="api-path">/api/v1/auth/register</span>
+                            <p class="api-desc">Create account with username/password</p>
+                        </div>
+                        <div class="api-card">
+                            <span class="api-method post">POST</span>
+                            <span class="api-path">/api/v1/auth/login</span>
+                            <p class="api-desc">Authenticate and receive JWT token</p>
+                        </div>
+                        <div class="api-card">
+                            <span class="api-method post">POST</span>
+                            <span class="api-path">/api/v1/rag/domains</span>
+                            <p class="api-desc">Create a new knowledge domain</p>
+                        </div>
+                        <div class="api-card">
+                            <span class="api-method post">POST</span>
+                            <span class="api-path">/api/v1/rag/domains/:id/documents</span>
+                            <p class="api-desc">Upload document to domain (2MB free limit)</p>
+                        </div>
+                        <div class="api-card">
+                            <span class="api-method post">POST</span>
+                            <span class="api-path">/api/v1/rag/domains/:id/query</span>
+                            <p class="api-desc">Run RAG query against domain docs</p>
+                        </div>
+                        <div class="api-card">
+                            <span class="api-method post">POST</span>
+                            <span class="api-path">/api/v1/rewards/compute</span>
+                            <p class="api-desc">Compute reward on-the-fly</p>
+                        </div>
+                        <div class="api-card">
+                            <span class="api-method post">POST</span>
+                            <span class="api-path">/api/v1/rewards/configs</span>
+                            <p class="api-desc">Create reusable reward configuration</p>
+                        </div>
+                        <div class="api-card">
+                            <span class="api-method get">GET</span>
+                            <span class="api-path">/api/v1/rewards/algorithms</span>
+                            <p class="api-desc">List supported RL algorithms</p>
+                        </div>
+                        <div class="api-card">
+                            <span class="api-method get">GET</span>
+                            <span class="api-path">/api/v1/user/dashboard</span>
+                            <p class="api-desc">Get dashboard statistics</p>
+                        </div>
+                        <div class="api-card">
+                            <span class="api-method post">POST</span>
+                            <span class="api-path">/api/v1/user/api-keys</span>
+                            <p class="api-desc">Generate API key for programmatic access</p>
+                        </div>
+                        <div class="api-card">
+                            <span class="api-method get">GET</span>
+                            <span class="api-path">/api/v1/health</span>
+                            <p class="api-desc">Service health check</p>
+                        </div>
+                        <div class="api-card">
+                            <span class="api-method delete">DELETE</span>
+                            <span class="api-path">/api/v1/rag/domains/:id</span>
+                            <p class="api-desc">Delete domain and all associated data</p>
+                        </div>
+                    </div>
+                </div>
+            </div>
+        </section>
+
+        <!-- CTA -->
+        <section class="cta-section">
+            <div class="container">
+                <h2>Ready to build the future of RAG?</h2>
+                <p>Join the next generation of AI companies using Rewards-as-a-Service.</p>
+                <div style="display:flex; gap:16px; justify-content:center">
+                    <button class="btn btn-primary btn-lg" onclick="showAuthModal('register')">Create Free Account</button>
+                    <a href="/api/docs" target="_blank" class="btn btn-secondary btn-lg">Explore API →</a>
+                </div>
+            </div>
+        </section>
+
+        <!-- FOOTER -->
+        <footer class="footer">
+            <div class="container">
+                <div class="footer-grid">
+                    <div class="footer-brand">
+                        <h3>⚡ Agentic RAG OS</h3>
+                        <p>The Operating System for Agentic RAG. RL B2B Rewards-as-a-Service platform for building intelligent retrieval systems.</p>
+                    </div>
+                    <div>
+                        <h4>Product</h4>
+                        <ul>
+                            <li><a href="#features">Features</a></li>
+                            <li><a href="#pricing">Pricing</a></li>
+                            <li><a href="/api/docs" target="_blank">API Docs</a></li>
+                            <li><a href="#api-reference">Endpoints</a></li>
+                        </ul>
+                    </div>
+                    <div>
+                        <h4>Resources</h4>
+                        <ul>
+                            <li><a href="https://github.com/williyam-m/agentic-rag-gym" target="_blank">GitHub</a></li>
+                            <li><a href="https://huggingface.co/spaces/williyam/agentic-rag-gym" target="_blank">HF Space</a></li>
+                            <li><a href="https://huggingface.co/williyam/agentic-rag-aerospace-grpo" target="_blank">Models</a></li>
+                        </ul>
+                    </div>
+                    <div>
+                        <h4>Company</h4>
+                        <ul>
+                            <li><a href="#">About</a></li>
+                            <li><a href="#">Blog</a></li>
+                            <li><a href="#">Careers</a></li>
+                            <li><a href="#">Contact</a></li>
+                        </ul>
+                    </div>
+                </div>
+                <div class="footer-bottom">
+                    <span>© 2025 Agentic RAG OS. All rights reserved.</span>
+                    <span>Built with ❤️ for the AI community</span>
+                </div>
+            </div>
+        </footer>
+    </div>
+
+    <!-- ============ DASHBOARD VIEW ============ -->
+    <div class="app-view" id="viewDashboard">
+        <div class="container" style="padding-top:20px">
+            <div class="dashboard-header">
+                <h1>Dashboard</h1>
+                <div style="display:flex;gap:12px">
+                    <button class="btn btn-secondary btn-sm" onclick="showView('domains')">Domains</button>
+                    <button class="btn btn-secondary btn-sm" onclick="showView('rewards')">Rewards</button>
+                    <button class="btn btn-secondary btn-sm" onclick="showView('apikeys')">API Keys</button>
+                </div>
+            </div>
+
+            <div class="stats-grid" id="dashStats">
+                <div class="stat-card"><div class="stat-label">Domains</div><div class="stat-value accent" id="statDomains">0</div></div>
+                <div class="stat-card"><div class="stat-label">Documents</div><div class="stat-value" id="statDocs">0</div></div>
+                <div class="stat-card"><div class="stat-label">RAG Queries</div><div class="stat-value" id="statQueries">0</div></div>
+                <div class="stat-card"><div class="stat-label">Storage Used</div><div class="stat-value" id="statStorage">0 KB</div></div>
+            </div>
+
+            <div class="card">
+                <h2>Quick Start</h2>
+                <div class="terminal-body" style="background:var(--bg-primary);border-radius:8px;padding:20px;margin-top:12px">
+                    <div><span class="comment"># 1. Get your API token</span></div>
+                    <div><span class="cmd">curl</span> -X POST /api/v1/auth/login -d '{"username":"you","password":"pw"}'</div>
+                    <div style="margin-top:12px"><span class="comment"># 2. Create a domain</span></div>
+                    <div><span class="cmd">curl</span> -X POST /api/v1/rag/domains -H "Authorization: Bearer $TOKEN" \</div>
+                    <div>&nbsp;&nbsp;-d '{"name":"my-project","description":"My RAG domain"}'</div>
+                    <div style="margin-top:12px"><span class="comment"># 3. Upload documents</span></div>
+                    <div><span class="cmd">curl</span> -X POST /api/v1/rag/domains/$ID/documents -F "file=@data.txt"</div>
+                    <div style="margin-top:12px"><span class="comment"># 4. Generate rewards</span></div>
+                    <div><span class="cmd">curl</span> -X POST /api/v1/rewards/compute \</div>
+                    <div>&nbsp;&nbsp;-d '{"algorithm":"grpo","query":"...","answer":"...","retrieved_docs":[...]}'</div>
+                </div>
+            </div>
+        </div>
+    </div>
+
+    <!-- ============ DOMAINS VIEW ============ -->
+    <div class="app-view" id="viewDomains">
+        <div class="container" style="padding-top:20px">
+            <div class="dashboard-header">
+                <h1>RAG Domains</h1>
+                <button class="btn btn-primary btn-sm" onclick="showCreateDomain()">+ New Domain</button>
+            </div>
+            <div class="card" id="domainsList">
+                <p style="color:var(--text-muted)">Loading domains...</p>
+            </div>
+
+            <!-- Domain Detail -->
+            <div id="domainDetail" style="display:none">
+                <div class="card">
+                    <div style="display:flex;justify-content:space-between;align-items:center">
+                        <h2 id="domainDetailName">Domain</h2>
+                        <button class="btn btn-ghost btn-sm" onclick="closeDomainDetail()">← Back</button>
+                    </div>
+
+                    <!-- Upload -->
+                    <div style="margin:20px 0;padding:20px;border:2px dashed var(--border);border-radius:12px;text-align:center">
+                        <p style="color:var(--text-muted);margin-bottom:12px">Upload text files (max 2MB total · Premium for more storage)</p>
+                        <input type="file" id="fileInput" accept=".txt,.md,.csv,.json" style="display:none" onchange="handleFileUpload(event)">
+                        <button class="btn btn-secondary btn-sm" onclick="document.getElementById('fileInput').click()">Choose File</button>
+                    </div>
+
+                    <!-- Documents table -->
+                    <div id="documentsList"></div>
+
+                    <!-- RAG Query -->
+                    <div style="margin-top:24px">
+                        <h3 style="font-size:1rem;margin-bottom:12px">Query Documents</h3>
+                        <div style="display:flex;gap:12px">
+                            <input type="text" class="form-input" id="ragQueryInput" placeholder="Enter your search query..." style="flex:1">
+                            <button class="btn btn-primary btn-sm" onclick="runRAGQuery()">Search</button>
+                        </div>
+                        <div id="ragResults" style="margin-top:16px"></div>
+                    </div>
+                </div>
+            </div>
+        </div>
+    </div>
+
+    <!-- ============ REWARDS VIEW ============ -->
+    <div class="app-view" id="viewRewards">
+        <div class="container" style="padding-top:20px">
+            <div class="dashboard-header">
+                <h1>Rewards-as-a-Service</h1>
+                <button class="btn btn-primary btn-sm" onclick="showCreateRewardConfig()">+ New Config</button>
+            </div>
+
+            <!-- Reward Playground -->
+            <div class="reward-playground" style="margin-bottom:24px">
+                <h3 style="margin-bottom:16px">⚡ Reward Playground</h3>
+                <p style="color:var(--text-secondary);margin-bottom:20px;font-size:0.9rem">Compute rewards on-the-fly. Choose your algorithm, provide input, and see the reward breakdown instantly.</p>
+
+                <div style="display:grid;grid-template-columns:1fr 1fr;gap:20px">
+                    <div>
+                        <div class="form-group">
+                            <label>Algorithm</label>
+                            <select class="form-select" id="playAlgorithm">
+                                <option value="grpo">GRPO — Group Relative Policy Optimization</option>
+                                <option value="ppo">PPO — Proximal Policy Optimization</option>
+                                <option value="dpo">DPO — Direct Preference Optimization</option>
+                                <option value="reinforce">REINFORCE — Policy Gradient</option>
+                                <option value="custom">Custom</option>
+                            </select>
+                        </div>
+                        <div class="form-group">
+                            <label>Query</label>
+                            <input type="text" class="form-input" id="playQuery" placeholder="What is the specific impulse of ion propulsion?">
+                        </div>
+                        <div class="form-group">
+                            <label>Answer</label>
+                            <textarea class="form-input" id="playAnswer" placeholder="Ion propulsion systems achieve specific impulse values of 3000-5000 seconds, significantly higher than chemical propulsion..."></textarea>
+                        </div>
+                        <div class="form-group">
+                            <label>Retrieved Documents (one per line)</label>
+                            <textarea class="form-input" id="playDocs" placeholder="Ion engines produce low thrust but extremely high specific impulse...&#10;Nuclear thermal propulsion offers thrust-to-weight ratios..."></textarea>
+                        </div>
+                        <button class="btn btn-primary" style="width:100%;justify-content:center" onclick="computePlaygroundReward()">Compute Reward →</button>
+                    </div>
+                    <div id="playgroundResult" style="display:flex;align-items:center;justify-content:center">
+                        <p style="color:var(--text-muted)">Configure inputs and click compute to see reward breakdown</p>
+                    </div>
+                </div>
+            </div>
+
+            <!-- Reward Configs List -->
+            <div class="card" id="rewardConfigsList">
+                <h2>Saved Configurations</h2>
+                <p style="color:var(--text-muted)">Loading...</p>
+            </div>
+        </div>
+    </div>
+
+    <!-- ============ API KEYS VIEW ============ -->
+    <div class="app-view" id="viewApikeys">
+        <div class="container" style="padding-top:20px">
+            <div class="dashboard-header">
+                <h1>API Keys</h1>
+                <button class="btn btn-primary btn-sm" onclick="createNewAPIKey()">+ Generate Key</button>
+            </div>
+            <div class="card" id="apiKeysList">
+                <p style="color:var(--text-muted)">Loading...</p>
+            </div>
+        </div>
+    </div>
+
+    <!-- ============ CREATE DOMAIN MODAL ============ -->
+    <div class="modal-overlay" id="createDomainModal">
+        <div class="modal">
+            <h2>Create Domain</h2>
+            <form onsubmit="createDomain(event)">
+                <div class="form-group">
+                    <label>Domain Name</label>
+                    <input type="text" class="form-input" id="newDomainName" placeholder="e.g., aerospace-research" required>
+                </div>
+                <div class="form-group">
+                    <label>Description</label>
+                    <input type="text" class="form-input" id="newDomainDesc" placeholder="Knowledge base for aerospace research">
+                </div>
+                <div class="modal-actions">
+                    <button type="button" class="btn btn-ghost" onclick="closeModal('createDomainModal')">Cancel</button>
+                    <button type="submit" class="btn btn-primary">Create</button>
+                </div>
+            </form>
+        </div>
+    </div>
+
+    <!-- ============ CREATE REWARD CONFIG MODAL ============ -->
+    <div class="modal-overlay" id="createRewardModal">
+        <div class="modal">
+            <h2>Create Reward Config</h2>
+            <form onsubmit="createRewardConfig(event)">
+                <div class="form-group">
+                    <label>Config Name</label>
+                    <input type="text" class="form-input" id="newRewardName" placeholder="e.g., my-grpo-config" required>
+                </div>
+                <div class="form-group">
+                    <label>Algorithm</label>
+                    <select class="form-select" id="newRewardAlgo">
+                        <option value="grpo">GRPO</option>
+                        <option value="ppo">PPO</option>
+                        <option value="dpo">DPO</option>
+                        <option value="reinforce">REINFORCE</option>
+                        <option value="custom">Custom</option>
+                    </select>
+                </div>
+                <div class="form-group">
+                    <label>Retrieval Weight</label>
+                    <input type="number" class="form-input" id="rwRetrieval" value="0.25" step="0.05" min="0" max="1">
+                </div>
+                <div class="form-group">
+                    <label>Reasoning Weight</label>
+                    <input type="number" class="form-input" id="rwReasoning" value="0.20" step="0.05" min="0" max="1">
+                </div>
+                <div class="form-group">
+                    <label>Completeness Weight</label>
+                    <input type="number" class="form-input" id="rwCompleteness" value="0.30" step="0.05" min="0" max="1">
+                </div>
+                <div class="modal-actions">
+                    <button type="button" class="btn btn-ghost" onclick="closeModal('createRewardModal')">Cancel</button>
+                    <button type="submit" class="btn btn-primary">Create</button>
+                </div>
+            </form>
+        </div>
+    </div>
+
+    <!-- ============ JAVASCRIPT ============ -->
+    <script>
+        // ==== State ====
+        const API = '/api/v1';
+        let token = localStorage.getItem('ragos_token') || '';
+        let currentUser = null;
+        let currentDomainId = null;
+        let authMode = 'login';
+
+        // ==== Init ====
+        document.addEventListener('DOMContentLoaded', () => {
+            if (token) {
+                loadUser();
+            }
+            initScrollAnimations();
+        });
+
+        // ==== Scroll animations ====
+        function initScrollAnimations() {
+            const obs = new IntersectionObserver((entries) => {
+                entries.forEach(e => {
+                    if (e.isIntersecting) {
+                        e.target.classList.add('animate-in');
+                        obs.unobserve(e.target);
+                    }
+                });
+            }, { threshold: 0.1 });
+            document.querySelectorAll('.feature-card, .step-item').forEach(el => obs.observe(el));
+        }
+
+        // ==== Auth ====
+        function showAuthModal(mode = 'login') {
+            switchAuthTab(mode);
+            document.getElementById('authModal').classList.add('active');
+        }
+        function closeAuthModal() {
+            document.getElementById('authModal').classList.remove('active');
+        }
+        function switchAuthTab(mode) {
+            authMode = mode;
+            document.getElementById('tabLogin').classList.toggle('active', mode === 'login');
+            document.getElementById('tabRegister').classList.toggle('active', mode === 'register');
+            document.getElementById('emailGroup').style.display = mode === 'register' ? 'block' : 'none';
+            document.getElementById('authSubmitBtn').textContent = mode === 'login' ? 'Sign In' : 'Create Account';
+        }
+        async function handleAuth(e) {
+            e.preventDefault();
+            const username = document.getElementById('authUsername').value;
+            const password = document.getElementById('authPassword').value;
+            const email = document.getElementById('authEmail').value;
+
+            try {
+                const endpoint = authMode === 'login' ? '/auth/login' : '/auth/register';
+                const body = authMode === 'login'
+                    ? { username, password }
+                    : { username, email, password };
+                const resp = await apiFetch(endpoint, 'POST', body, false);
+                token = resp.access_token;
+                localStorage.setItem('ragos_token', token);
+                currentUser = resp.user;
+                closeAuthModal();
+                updateNavForUser();
+                showView('dashboard');
+                loadDashboard();
+                toast('Welcome, ' + currentUser.username + '!', 'success');
+            } catch (err) {
+                toast(err.message || 'Authentication failed', 'error');
+            }
+        }
+        function githubLogin() {
+            const clientId = ''; // Will be populated from env
+            if (!clientId) {
+                toast('GitHub OAuth is configured on the deployed version', 'info');
+                return;
+            }
+            window.location.href = `https://github.com/login/oauth/authorize?client_id=${clientId}&scope=user:email`;
+        }
+        function logout() {
+            token = '';
+            currentUser = null;
+            localStorage.removeItem('ragos_token');
+            updateNavForUser();
+            showView('landing');
+            toast('Logged out', 'info');
+        }
+        async function loadUser() {
+            try {
+                currentUser = await apiFetch('/user/me');
+                updateNavForUser();
+            } catch {
+                token = '';
+                localStorage.removeItem('ragos_token');
+            }
+        }
+        function updateNavForUser() {
+            const loggedIn = !!currentUser;
+            document.getElementById('navLoginBtn').style.display = loggedIn ? 'none' : '';
+            document.getElementById('navSignupBtn').style.display = loggedIn ? 'none' : '';
+            document.getElementById('navUserMenu').style.display = loggedIn ? 'flex' : 'none';
+        }
+
+        // ==== View Switching ====
+        function showView(view) {
+            document.querySelectorAll('.app-view').forEach(v => v.classList.remove('active'));
+            const el = document.getElementById('view' + view.charAt(0).toUpperCase() + view.slice(1));
+            if (el) el.classList.add('active');
+
+            if (view === 'dashboard') loadDashboard();
+            if (view === 'domains') loadDomains();
+            if (view === 'rewards') loadRewards();
+            if (view === 'apikeys') loadAPIKeys();
+        }
+
+        // ==== Dashboard ====
+        async function loadDashboard() {
+            try {
+                const stats = await apiFetch('/user/dashboard');
+                document.getElementById('statDomains').textContent = stats.total_domains;
+                document.getElementById('statDocs').textContent = stats.total_documents;
+                document.getElementById('statQueries').textContent = stats.total_queries;
+                const kb = Math.round(stats.storage_used_bytes / 1024);
+                document.getElementById('statStorage').textContent = kb > 1024 ? (kb / 1024).toFixed(1) + ' MB' : kb + ' KB';
+            } catch {}
+        }
+
+        // ==== Domains ====
+        async function loadDomains() {
+            try {
+                const domains = await apiFetch('/rag/domains');
+                const el = document.getElementById('domainsList');
+                if (domains.length === 0) {
+                    el.innerHTML = '<p style="color:var(--text-muted)">No domains yet. Create one to get started.</p>';
+                    return;
+                }
+                el.innerHTML = `<table class="data-table"><thead><tr><th>Name</th><th>Documents</th><th>Size</th><th>Created</th><th></th></tr></thead><tbody>` +
+                    domains.map(d => `<tr>
+                        <td><strong style="color:var(--text-primary)">${esc(d.name)}</strong><br><span style="font-size:0.8rem;color:var(--text-muted)">${esc(d.description)}</span></td>
+                        <td>${d.document_count}</td>
+                        <td>${formatBytes(d.total_size_bytes)}</td>
+                        <td>${new Date(d.created_at).toLocaleDateString()}</td>
+                        <td><button class="btn btn-ghost btn-sm" onclick="openDomain('${d.id}','${esc(d.name)}')">Open →</button></td>
+                    </tr>`).join('') +
+                    '</tbody></table>';
+            } catch (err) {
+                toast(err.message, 'error');
+            }
+        }
+        function showCreateDomain() { document.getElementById('createDomainModal').classList.add('active'); }
+        async function createDomain(e) {
+            e.preventDefault();
+            try {
+                await apiFetch('/rag/domains', 'POST', {
+                    name: document.getElementById('newDomainName').value,
+                    description: document.getElementById('newDomainDesc').value
+                });
+                closeModal('createDomainModal');
+                loadDomains();
+                toast('Domain created', 'success');
+            } catch (err) { toast(err.message, 'error'); }
+        }
+        async function openDomain(id, name) {
+            currentDomainId = id;
+            document.getElementById('domainDetailName').textContent = name;
+            document.getElementById('domainDetail').style.display = 'block';
+            document.getElementById('domainsList').style.display = 'none';
+            await loadDocuments();
+        }
+        function closeDomainDetail() {
+            document.getElementById('domainDetail').style.display = 'none';
+            document.getElementById('domainsList').style.display = 'block';
+            currentDomainId = null;
+        }
+        async function loadDocuments() {
+            if (!currentDomainId) return;
+            try {
+                const docs = await apiFetch(`/rag/domains/${currentDomainId}/documents`);
+                const el = document.getElementById('documentsList');
+                if (docs.length === 0) {
+                    el.innerHTML = '<p style="color:var(--text-muted)">No documents yet. Upload a text file above.</p>';
+                    return;
+                }
+                el.innerHTML = `<table class="data-table"><thead><tr><th>Filename</th><th>Size</th><th>Uploaded</th><th></th></tr></thead><tbody>` +
+                    docs.map(d => `<tr>
+                        <td>${esc(d.filename)}</td>
+                        <td>${formatBytes(d.size_bytes)}</td>
+                        <td>${new Date(d.created_at).toLocaleDateString()}</td>
+                        <td><button class="btn btn-ghost btn-sm" onclick="deleteDoc('${d.id}')" style="color:#ef4444">Delete</button></td>
+                    </tr>`).join('') +
+                    '</tbody></table>';
+            } catch (err) { toast(err.message, 'error'); }
+        }
+        async function handleFileUpload(e) {
+            const file = e.target.files[0];
+            if (!file) return;
+            const form = new FormData();
+            form.append('file', file);
+            try {
+                const resp = await fetch(`${API}/rag/domains/${currentDomainId}/documents`, {
+                    method: 'POST',
+                    headers: { 'Authorization': `Bearer ${token}` },
+                    body: form,
+                });
+                if (!resp.ok) {
+                    const err = await resp.json();
+                    throw new Error(err.detail || 'Upload failed');
+                }
+                toast('Document uploaded', 'success');
+                await loadDocuments();
+            } catch (err) { toast(err.message, 'error'); }
+            e.target.value = '';
+        }
+        async function deleteDoc(docId) {
+            if (!confirm('Delete this document?')) return;
+            try {
+                await apiFetch(`/rag/domains/${currentDomainId}/documents/${docId}`, 'DELETE');
+                toast('Document deleted', 'success');
+                await loadDocuments();
+            } catch (err) { toast(err.message, 'error'); }
+        }
+        async function runRAGQuery() {
+            const query = document.getElementById('ragQueryInput').value.trim();
+            if (!query) return;
+            try {
+                const result = await apiFetch(`/rag/domains/${currentDomainId}/query`, 'POST', { query, top_k: 5 });
+                const el = document.getElementById('ragResults');
+                if (result.results.length === 0) {
+                    el.innerHTML = '<p style="color:var(--text-muted)">No results found.</p>';
+                    return;
+                }
+                el.innerHTML = result.results.map((r, i) => `
+                    <div style="padding:12px;background:var(--bg-primary);border:1px solid var(--border);border-radius:8px;margin-bottom:8px">
+                        <div style="display:flex;justify-content:space-between;margin-bottom:4px">
+                            <span style="font-weight:600;font-size:0.85rem">Result ${i + 1}</span>
+                            <span class="tag tag-info">Score: ${r.score.toFixed(4)}</span>
+                        </div>
+                        <p style="font-size:0.85rem;color:var(--text-secondary)">${esc(r.content.substring(0, 300))}${r.content.length > 300 ? '...' : ''}</p>
+                    </div>
+                `).join('');
+            } catch (err) { toast(err.message, 'error'); }
+        }
+
+        // ==== Rewards ====
+        async function loadRewards() {
+            try {
+                const configs = await apiFetch('/rewards/configs');
+                const el = document.getElementById('rewardConfigsList');
+                if (configs.length === 0) {
+                    el.innerHTML = '<h2>Saved Configurations</h2><p style="color:var(--text-muted)">No reward configs yet. Create one or use the playground above.</p>';
+                    return;
+                }
+                el.innerHTML = '<h2>Saved Configurations</h2>' +
+                    `<table class="data-table"><thead><tr><th>Name</th><th>Algorithm</th><th>Created</th><th></th></tr></thead><tbody>` +
+                    configs.map(c => `<tr>
+                        <td><strong style="color:var(--text-primary)">${esc(c.name)}</strong></td>
+                        <td><span class="tag tag-info">${c.algorithm.toUpperCase()}</span></td>
+                        <td>${new Date(c.created_at).toLocaleDateString()}</td>
+                        <td><button class="btn btn-ghost btn-sm" onclick="deleteRewardConfig('${c.id}')" style="color:#ef4444">Delete</button></td>
+                    </tr>`).join('') +
+                    '</tbody></table>';
+            } catch (err) { toast(err.message, 'error'); }
+        }
+        function showCreateRewardConfig() { document.getElementById('createRewardModal').classList.add('active'); }
+        async function createRewardConfig(e) {
+            e.preventDefault();
+            try {
+                await apiFetch('/rewards/configs', 'POST', {
+                    name: document.getElementById('newRewardName').value,
+                    algorithm: document.getElementById('newRewardAlgo').value,
+                    config: {
+                        retrieval_relevance_weight: parseFloat(document.getElementById('rwRetrieval').value),
+                        reasoning_quality_weight: parseFloat(document.getElementById('rwReasoning').value),
+                        answer_completeness_weight: parseFloat(document.getElementById('rwCompleteness').value),
+                        efficiency_weight: 0.15,
+                        anti_hack_weight: 0.10,
+                    }
+                });
+                closeModal('createRewardModal');
+                loadRewards();
+                toast('Reward config created', 'success');
+            } catch (err) { toast(err.message, 'error'); }
+        }
+        async function deleteRewardConfig(id) {
+            if (!confirm('Delete this reward config?')) return;
+            try {
+                await apiFetch(`/rewards/configs/${id}`, 'DELETE');
+                loadRewards();
+                toast('Config deleted', 'success');
+            } catch (err) { toast(err.message, 'error'); }
+        }
+        async function computePlaygroundReward() {
+            const algo = document.getElementById('playAlgorithm').value;
+            const query = document.getElementById('playQuery').value;
+            const answer = document.getElementById('playAnswer').value;
+            const docsText = document.getElementById('playDocs').value;
+            const docs = docsText.split('\n').filter(l => l.trim());
+
+            try {
+                const result = await apiFetch('/rewards/compute', 'POST', {
+                    algorithm: algo,
+                    query, answer,
+                    retrieved_docs: docs,
+                    config: {}
+                });
+                const el = document.getElementById('playgroundResult');
+                const score = result.total_reward;
+                const color = score > 0.7 ? '#10b981' : score > 0.4 ? '#f59e0b' : '#ef4444';
+                el.innerHTML = `
+                    <div style="width:100%">
+                        <div class="reward-result">
+                            <div style="text-align:center;font-size:0.8rem;color:var(--text-muted);text-transform:uppercase;letter-spacing:0.1em">Total Reward</div>
+                            <div class="reward-score" style="color:${color}">${score.toFixed(4)}</div>
+                            <div style="text-align:center;margin-bottom:20px"><span class="tag tag-info">${result.algorithm.toUpperCase()}</span></div>
+                            <div class="reward-breakdown">
+                                ${Object.entries(result.breakdown).map(([k, v]) => {
+                                    const barColor = k === 'anti_hack_penalty' ? '#ef4444' : 'var(--accent-light)';
+                                    return `<div class="reward-bar">
+                                        <div class="reward-bar-label">${k.replace(/_/g, ' ')}</div>
+                                        <div style="display:flex;justify-content:space-between;font-size:0.85rem;margin-bottom:4px">
+                                            <span>${v.toFixed(4)}</span>
+                                        </div>
+                                        <div class="reward-bar-track">
+                                            <div class="reward-bar-fill" style="width:${Math.min(v * 100, 100)}%;background:${barColor}"></div>
+                                        </div>
+                                    </div>`;
+                                }).join('')}
+                            </div>
+                            ${result.metadata.description ? `<p style="margin-top:16px;font-size:0.8rem;color:var(--text-muted);text-align:center">${result.metadata.description}</p>` : ''}
+                        </div>
+                    </div>`;
+            } catch (err) { toast(err.message, 'error'); }
+        }
+
+        // ==== API Keys ====
+        async function loadAPIKeys() {
+            try {
+                const keys = await apiFetch('/user/api-keys');
+                const el = document.getElementById('apiKeysList');
+                if (keys.length === 0) {
+                    el.innerHTML = '<p style="color:var(--text-muted)">No API keys. Generate one for programmatic access.</p>';
+                    return;
+                }
+                el.innerHTML = `<table class="data-table"><thead><tr><th>Name</th><th>Key</th><th>Created</th><th>Last Used</th><th></th></tr></thead><tbody>` +
+                    keys.map(k => `<tr>
+                        <td>${esc(k.name)}</td>
+                        <td><code style="color:var(--accent-2)">${k.key_prefix}</code></td>
+                        <td>${new Date(k.created_at).toLocaleDateString()}</td>
+                        <td>${k.last_used ? new Date(k.last_used).toLocaleDateString() : 'Never'}</td>
+                        <td><button class="btn btn-ghost btn-sm" onclick="revokeKey('${k.id}')" style="color:#ef4444">Revoke</button></td>
+                    </tr>`).join('') +
+                    '</tbody></table>';
+            } catch (err) { toast(err.message, 'error'); }
+        }
+        async function createNewAPIKey() {
+            const name = prompt('API key name:');
+            if (!name) return;
+            try {
+                const result = await apiFetch('/user/api-keys', 'POST', { name });
+                alert('Your API key (shown only once):\n\n' + result.key + '\n\nSave it now!');
+                loadAPIKeys();
+                toast('API key created', 'success');
+            } catch (err) { toast(err.message, 'error'); }
+        }
+        async function revokeKey(id) {
+            if (!confirm('Revoke this key?')) return;
+            try {
+                await apiFetch(`/user/api-keys/${id}`, 'DELETE');
+                loadAPIKeys();
+                toast('Key revoked', 'success');
+            } catch (err) { toast(err.message, 'error'); }
+        }
+
+        // ==== API Fetch Helper ====
+        async function apiFetch(path, method = 'GET', body = null, auth = true) {
+            const headers = { 'Content-Type': 'application/json' };
+            if (auth && token) headers['Authorization'] = `Bearer ${token}`;
+            const opts = { method, headers };
+            if (body) opts.body = JSON.stringify(body);
+            const resp = await fetch(API + path, opts);
+            const data = await resp.json();
+            if (!resp.ok) throw new Error(data.detail || 'Request failed');
+            return data;
+        }
+
+        // ==== Utilities ====
+        function closeModal(id) { document.getElementById(id).classList.remove('active'); }
+        function esc(s) { const d = document.createElement('div'); d.textContent = s; return d.innerHTML; }
+        function formatBytes(b) { if (b === 0) return '0 B'; const k = 1024; const s = ['B','KB','MB']; const i = Math.floor(Math.log(b)/Math.log(k)); return (b/Math.pow(k,i)).toFixed(1)+' '+s[i]; }
+        function toast(msg, type = 'info') {
+            const el = document.createElement('div');
+            el.className = `toast ${type}`;
+            el.textContent = msg;
+            document.getElementById('toastContainer').appendChild(el);
+            setTimeout(() => el.remove(), 4000);
+        }
+
+        // Handle GitHub callback
+        const urlParams = new URLSearchParams(window.location.search);
+        if (urlParams.has('code')) {
+            (async () => {
+                try {
+                    const resp = await apiFetch(`/auth/github/callback?code=${urlParams.get('code')}`, 'GET', null, false);
+                    token = resp.access_token;
+                    localStorage.setItem('ragos_token', token);
+                    currentUser = resp.user;
+                    updateNavForUser();
+                    showView('dashboard');
+                    loadDashboard();
+                    toast('Signed in with GitHub!', 'success');
+                    window.history.replaceState({}, '', '/');
+                } catch (err) { toast('GitHub auth failed: ' + err.message, 'error'); }
+            })();
+        }
+    </script>
+</body>
+</html>

agentic_rag_os/models/__init__.py

@@ -0,0 +1,142 @@
+"""Database models and helpers — SQLite via aiosqlite."""
+
+from __future__ import annotations
+
+import aiosqlite
+import json
+import uuid
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from agentic_rag_os.config import get_settings
+
+_DB: Optional[aiosqlite.Connection] = None
+
+SCHEMA = """
+CREATE TABLE IF NOT EXISTS users (
+    id TEXT PRIMARY KEY,
+    username TEXT UNIQUE NOT NULL,
+    email TEXT UNIQUE,
+    password_hash TEXT,
+    github_id TEXT UNIQUE,
+    avatar_url TEXT DEFAULT '',
+    role TEXT DEFAULT 'user',
+    tier TEXT DEFAULT 'free',
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS api_keys (
+    id TEXT PRIMARY KEY,
+    user_id TEXT NOT NULL REFERENCES users(id),
+    key_hash TEXT UNIQUE NOT NULL,
+    name TEXT NOT NULL,
+    created_at TEXT NOT NULL,
+    last_used TEXT,
+    is_active INTEGER DEFAULT 1
+);
+
+CREATE TABLE IF NOT EXISTS domains (
+    id TEXT PRIMARY KEY,
+    user_id TEXT NOT NULL REFERENCES users(id),
+    name TEXT NOT NULL,
+    description TEXT DEFAULT '',
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL,
+    UNIQUE(user_id, name)
+);
+
+CREATE TABLE IF NOT EXISTS documents (
+    id TEXT PRIMARY KEY,
+    domain_id TEXT NOT NULL REFERENCES domains(id),
+    filename TEXT NOT NULL,
+    content TEXT NOT NULL,
+    size_bytes INTEGER NOT NULL,
+    metadata TEXT DEFAULT '{}',
+    created_at TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS reward_configs (
+    id TEXT PRIMARY KEY,
+    user_id TEXT NOT NULL REFERENCES users(id),
+    domain_id TEXT REFERENCES domains(id),
+    name TEXT NOT NULL,
+    algorithm TEXT NOT NULL DEFAULT 'grpo',
+    config TEXT NOT NULL DEFAULT '{}',
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS reward_jobs (
+    id TEXT PRIMARY KEY,
+    user_id TEXT NOT NULL REFERENCES users(id),
+    reward_config_id TEXT NOT NULL REFERENCES reward_configs(id),
+    status TEXT NOT NULL DEFAULT 'pending',
+    result TEXT DEFAULT '{}',
+    created_at TEXT NOT NULL,
+    completed_at TEXT
+);
+
+CREATE TABLE IF NOT EXISTS rag_queries (
+    id TEXT PRIMARY KEY,
+    user_id TEXT NOT NULL REFERENCES users(id),
+    domain_id TEXT NOT NULL REFERENCES domains(id),
+    query TEXT NOT NULL,
+    results TEXT DEFAULT '[]',
+    reward_score REAL,
+    created_at TEXT NOT NULL
+);
+"""
+
+
+async def get_db() -> aiosqlite.Connection:
+    """Get or create the database connection."""
+    global _DB
+    if _DB is None:
+        settings = get_settings()
+        settings.db_path.parent.mkdir(parents=True, exist_ok=True)
+        _DB = await aiosqlite.connect(str(settings.db_path))
+        _DB.row_factory = aiosqlite.Row
+        await _DB.executescript(SCHEMA)
+        await _DB.commit()
+    return _DB
+
+
+async def close_db() -> None:
+    global _DB
+    if _DB is not None:
+        await _DB.close()
+        _DB = None
+
+
+# --- Helper functions ---
+
+def new_id() -> str:
+    return str(uuid.uuid4())
+
+
+def now_iso() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+async def fetch_one(query: str, params: tuple = ()) -> Optional[Dict[str, Any]]:
+    db = await get_db()
+    cursor = await db.execute(query, params)
+    row = await cursor.fetchone()
+    if row is None:
+        return None
+    return dict(row)
+
+
+async def fetch_all(query: str, params: tuple = ()) -> List[Dict[str, Any]]:
+    db = await get_db()
+    cursor = await db.execute(query, params)
+    rows = await cursor.fetchall()
+    return [dict(r) for r in rows]
+
+
+async def execute(query: str, params: tuple = ()) -> None:
+    db = await get_db()
+    await db.execute(query, params)
+    await db.commit()

agentic_rag_os/models/schemas.py

@@ -0,0 +1,172 @@
+"""Pydantic schemas for API request/response models."""
+
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Any, Dict, List, Optional
+
+from pydantic import BaseModel, Field
+
+
+# --- Auth ---
+
+class RegisterRequest(BaseModel):
+    username: str = Field(..., min_length=3, max_length=50)
+    email: str
+    password: str = Field(..., min_length=8)
+
+
+class LoginRequest(BaseModel):
+    username: str
+    password: str
+
+
+class TokenResponse(BaseModel):
+    access_token: str
+    token_type: str = "bearer"
+    user: "UserOut"
+
+
+class UserOut(BaseModel):
+    id: str
+    username: str
+    email: Optional[str] = None
+    avatar_url: str = ""
+    role: str = "user"
+    tier: str = "free"
+    created_at: str
+
+
+# --- Domain ---
+
+class DomainCreate(BaseModel):
+    name: str = Field(..., min_length=1, max_length=100)
+    description: str = ""
+
+
+class DomainOut(BaseModel):
+    id: str
+    name: str
+    description: str
+    document_count: int = 0
+    total_size_bytes: int = 0
+    created_at: str
+
+
+# --- Document ---
+
+class DocumentOut(BaseModel):
+    id: str
+    filename: str
+    size_bytes: int
+    metadata: Dict[str, Any] = {}
+    created_at: str
+
+
+# --- RAG ---
+
+class RAGQueryRequest(BaseModel):
+    query: str = Field(..., min_length=1)
+    top_k: int = Field(default=5, ge=1, le=20)
+
+
+class RAGResult(BaseModel):
+    content: str
+    score: float
+    metadata: Dict[str, Any] = {}
+
+
+class RAGQueryResponse(BaseModel):
+    query: str
+    results: List[RAGResult]
+    domain: str
+
+
+# --- Rewards-as-a-Service ---
+
+class RewardConfigCreate(BaseModel):
+    name: str
+    algorithm: str = Field(default="grpo", pattern="^(grpo|ppo|dpo|reinforce|custom)$")
+    domain_id: Optional[str] = None
+    config: Dict[str, Any] = Field(default_factory=lambda: {
+        "retrieval_relevance_weight": 0.25,
+        "reasoning_quality_weight": 0.20,
+        "answer_completeness_weight": 0.30,
+        "efficiency_weight": 0.15,
+        "anti_hack_weight": 0.10,
+    })
+
+
+class RewardConfigOut(BaseModel):
+    id: str
+    name: str
+    algorithm: str
+    domain_id: Optional[str] = None
+    config: Dict[str, Any]
+    created_at: str
+
+
+class RewardJobCreate(BaseModel):
+    reward_config_id: str
+    input_data: Dict[str, Any] = {}
+
+
+class RewardJobOut(BaseModel):
+    id: str
+    reward_config_id: str
+    status: str
+    result: Dict[str, Any] = {}
+    created_at: str
+    completed_at: Optional[str] = None
+
+
+class RewardComputeRequest(BaseModel):
+    """Compute reward on-the-fly without creating a job."""
+    algorithm: str = "grpo"
+    query: str = ""
+    answer: str = ""
+    retrieved_docs: List[str] = []
+    config: Dict[str, Any] = {}
+
+
+class RewardComputeResponse(BaseModel):
+    total_reward: float
+    breakdown: Dict[str, float] = {}
+    algorithm: str
+    metadata: Dict[str, Any] = {}
+
+
+# --- API Key ---
+
+class APIKeyCreate(BaseModel):
+    name: str = Field(..., min_length=1, max_length=100)
+
+
+class APIKeyOut(BaseModel):
+    id: str
+    name: str
+    key_prefix: str
+    created_at: str
+    last_used: Optional[str] = None
+    is_active: bool = True
+
+
+class APIKeyCreated(BaseModel):
+    id: str
+    name: str
+    key: str  # Full key, shown only once
+    created_at: str
+
+
+# --- Dashboard Stats ---
+
+class DashboardStats(BaseModel):
+    total_domains: int = 0
+    total_documents: int = 0
+    total_queries: int = 0
+    total_reward_configs: int = 0
+    storage_used_bytes: int = 0
+    storage_limit_bytes: int = 0
+
+
+TokenResponse.model_rebuild()

agentic_rag_os/run.py

@@ -0,0 +1,21 @@
+"""Entry point for Agentic RAG OS application."""
+
+from __future__ import annotations
+
+import uvicorn
+
+from agentic_rag_os.config import get_settings
+
+
+def main() -> None:
+    settings = get_settings()
+    uvicorn.run(
+        "agentic_rag_os.api.app:app",
+        host=settings.host,
+        port=settings.port,
+        log_level="info",
+    )
+
+
+if __name__ == "__main__":
+    main()

agentic_rag_os/services/__init__.py

@@ -0,0 +1,195 @@
+"""Authentication service — JWT + password hashing + GitHub OAuth."""
+
+from __future__ import annotations
+
+import hashlib
+import hmac
+import secrets
+from datetime import datetime, timedelta, timezone
+from typing import Optional, Dict, Any
+
+import httpx
+import jwt
+
+from agentic_rag_os.config import get_settings
+from agentic_rag_os.models import fetch_one, execute, new_id, now_iso
+
+
+def _hash_password(password: str) -> str:
+    salt = secrets.token_hex(16)
+    h = hashlib.pbkdf2_hmac("sha256", password.encode(), salt.encode(), 310_000)
+    return f"{salt}${h.hex()}"
+
+
+def _verify_password(password: str, stored: str) -> bool:
+    salt, h = stored.split("$", 1)
+    candidate = hashlib.pbkdf2_hmac("sha256", password.encode(), salt.encode(), 310_000)
+    return hmac.compare_digest(candidate.hex(), h)
+
+
+def _create_token(user_id: str, username: str, role: str = "user") -> str:
+    settings = get_settings()
+    payload = {
+        "sub": user_id,
+        "username": username,
+        "role": role,
+        "exp": datetime.now(timezone.utc) + timedelta(minutes=settings.jwt_expiry_minutes),
+        "iat": datetime.now(timezone.utc),
+    }
+    return jwt.encode(payload, settings.secret_key, algorithm=settings.jwt_algorithm)
+
+
+def decode_token(token: str) -> Dict[str, Any]:
+    settings = get_settings()
+    return jwt.decode(token, settings.secret_key, algorithms=[settings.jwt_algorithm])
+
+
+async def register_user(username: str, email: str, password: str) -> Dict[str, Any]:
+    existing = await fetch_one("SELECT id FROM users WHERE username=? OR email=?", (username, email))
+    if existing:
+        raise ValueError("Username or email already exists")
+
+    uid = new_id()
+    ts = now_iso()
+    pw_hash = _hash_password(password)
+    await execute(
+        "INSERT INTO users (id, username, email, password_hash, created_at, updated_at) VALUES (?,?,?,?,?,?)",
+        (uid, username, email, pw_hash, ts, ts),
+    )
+    user = await fetch_one("SELECT * FROM users WHERE id=?", (uid,))
+    token = _create_token(uid, username)
+    return {"access_token": token, "token_type": "bearer", "user": _user_out(user)}
+
+
+async def login_user(username: str, password: str) -> Dict[str, Any]:
+    user = await fetch_one("SELECT * FROM users WHERE username=?", (username,))
+    if not user or not user.get("password_hash"):
+        raise ValueError("Invalid credentials")
+    if not _verify_password(password, user["password_hash"]):
+        raise ValueError("Invalid credentials")
+    token = _create_token(user["id"], user["username"], user.get("role", "user"))
+    return {"access_token": token, "token_type": "bearer", "user": _user_out(user)}
+
+
+async def github_oauth_callback(code: str) -> Dict[str, Any]:
+    """Exchange GitHub OAuth code for user info and create/login user."""
+    settings = get_settings()
+    async with httpx.AsyncClient() as client:
+        # Exchange code for access token
+        resp = await client.post(
+            "https://github.com/login/oauth/access_token",
+            json={
+                "client_id": settings.github_client_id,
+                "client_secret": settings.github_client_secret,
+                "code": code,
+            },
+            headers={"Accept": "application/json"},
+        )
+        data = resp.json()
+        gh_token = data.get("access_token")
+        if not gh_token:
+            raise ValueError("GitHub OAuth failed: " + data.get("error_description", "unknown"))
+
+        # Get user info
+        resp = await client.get(
+            "https://api.github.com/user",
+            headers={"Authorization": f"Bearer {gh_token}", "Accept": "application/json"},
+        )
+        gh_user = resp.json()
+
+    gh_id = str(gh_user["id"])
+    username = gh_user.get("login", f"gh_{gh_id}")
+    email = gh_user.get("email", "")
+    avatar = gh_user.get("avatar_url", "")
+
+    # Check if user exists by github_id
+    user = await fetch_one("SELECT * FROM users WHERE github_id=?", (gh_id,))
+    if user:
+        token = _create_token(user["id"], user["username"], user.get("role", "user"))
+        return {"access_token": token, "token_type": "bearer", "user": _user_out(user)}
+
+    # Create new user
+    uid = new_id()
+    ts = now_iso()
+    await execute(
+        "INSERT INTO users (id, username, email, github_id, avatar_url, created_at, updated_at) VALUES (?,?,?,?,?,?,?)",
+        (uid, username, email, gh_id, avatar, ts, ts),
+    )
+    user = await fetch_one("SELECT * FROM users WHERE id=?", (uid,))
+    token = _create_token(uid, username)
+    return {"access_token": token, "token_type": "bearer", "user": _user_out(user)}
+
+
+async def get_user_by_id(user_id: str) -> Optional[Dict[str, Any]]:
+    user = await fetch_one("SELECT * FROM users WHERE id=?", (user_id,))
+    if user:
+        return _user_out(user)
+    return None
+
+
+def _user_out(user: Dict[str, Any]) -> Dict[str, Any]:
+    return {
+        "id": user["id"],
+        "username": user["username"],
+        "email": user.get("email", ""),
+        "avatar_url": user.get("avatar_url", ""),
+        "role": user.get("role", "user"),
+        "tier": user.get("tier", "free"),
+        "created_at": user["created_at"],
+    }
+
+
+# --- API Key management ---
+
+def _hash_api_key(key: str) -> str:
+    return hashlib.sha256(key.encode()).hexdigest()
+
+
+async def create_api_key(user_id: str, name: str) -> Dict[str, Any]:
+    key = f"ragos_{secrets.token_hex(24)}"
+    kid = new_id()
+    ts = now_iso()
+    await execute(
+        "INSERT INTO api_keys (id, user_id, key_hash, name, created_at) VALUES (?,?,?,?,?)",
+        (kid, user_id, _hash_api_key(key), name, ts),
+    )
+    return {"id": kid, "name": name, "key": key, "created_at": ts}
+
+
+async def validate_api_key(key: str) -> Optional[Dict[str, Any]]:
+    h = _hash_api_key(key)
+    row = await fetch_one(
+        "SELECT ak.*, u.username, u.role FROM api_keys ak JOIN users u ON ak.user_id=u.id WHERE ak.key_hash=? AND ak.is_active=1",
+        (h,),
+    )
+    if row:
+        await execute("UPDATE api_keys SET last_used=? WHERE id=?", (now_iso(), row["id"]))
+        return {"user_id": row["user_id"], "username": row["username"], "role": row["role"]}
+    return None
+
+
+async def list_api_keys(user_id: str):
+    from agentic_rag_os.models import fetch_all
+    rows = await fetch_all(
+        "SELECT id, name, created_at, last_used, is_active FROM api_keys WHERE user_id=?",
+        (user_id,),
+    )
+    return [
+        {
+            "id": r["id"],
+            "name": r["name"],
+            "key_prefix": "ragos_****",
+            "created_at": r["created_at"],
+            "last_used": r.get("last_used"),
+            "is_active": bool(r["is_active"]),
+        }
+        for r in rows
+    ]
+
+
+async def revoke_api_key(user_id: str, key_id: str) -> bool:
+    row = await fetch_one("SELECT id FROM api_keys WHERE id=? AND user_id=?", (key_id, user_id))
+    if not row:
+        return False
+    await execute("UPDATE api_keys SET is_active=0 WHERE id=?", (key_id,))
+    return True

agentic_rag_os/services/rag_service.py

@@ -0,0 +1,169 @@
+"""RAG service — user document ingestion, embedding, and retrieval."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+import numpy as np
+
+from agentic_rag_os.config import get_settings
+from agentic_rag_os.models import execute, fetch_all, fetch_one, new_id, now_iso
+
+# Lazy-loaded retriever per domain
+_retrievers: Dict[str, Any] = {}
+
+
+def _get_retriever(domain_id: str):
+    """Get or create a FAISS retriever for a user domain."""
+    if domain_id not in _retrievers:
+        from rag_master.retriever import FAISSRetriever
+        settings = get_settings()
+        index_dir = Path(settings.db_path).parent / "faiss" / domain_id
+        index_dir.mkdir(parents=True, exist_ok=True)
+        _retrievers[domain_id] = FAISSRetriever(
+            index_dir=index_dir,
+            embedding_model=settings.embedding_model,
+            dimension=settings.faiss_dimension,
+        )
+    return _retrievers[domain_id]
+
+
+async def create_domain(user_id: str, name: str, description: str = "") -> Dict[str, Any]:
+    """Create a new domain for the user."""
+    did = new_id()
+    ts = now_iso()
+    await execute(
+        "INSERT INTO domains (id, user_id, name, description, created_at, updated_at) VALUES (?,?,?,?,?,?)",
+        (did, user_id, name, description, ts, ts),
+    )
+    return {"id": did, "name": name, "description": description, "document_count": 0, "total_size_bytes": 0, "created_at": ts}
+
+
+async def list_domains(user_id: str) -> List[Dict[str, Any]]:
+    domains = await fetch_all("SELECT * FROM domains WHERE user_id=?", (user_id,))
+    result = []
+    for d in domains:
+        docs = await fetch_all("SELECT id, size_bytes FROM documents WHERE domain_id=?", (d["id"],))
+        result.append({
+            "id": d["id"],
+            "name": d["name"],
+            "description": d["description"],
+            "document_count": len(docs),
+            "total_size_bytes": sum(doc["size_bytes"] for doc in docs),
+            "created_at": d["created_at"],
+        })
+    return result
+
+
+async def get_domain(user_id: str, domain_id: str) -> Optional[Dict[str, Any]]:
+    return await fetch_one("SELECT * FROM domains WHERE id=? AND user_id=?", (domain_id, user_id))
+
+
+async def delete_domain(user_id: str, domain_id: str) -> bool:
+    d = await fetch_one("SELECT id FROM domains WHERE id=? AND user_id=?", (domain_id, user_id))
+    if not d:
+        return False
+    await execute("DELETE FROM documents WHERE domain_id=?", (domain_id,))
+    await execute("DELETE FROM rag_queries WHERE domain_id=?", (domain_id,))
+    await execute("DELETE FROM domains WHERE id=?", (domain_id,))
+    if domain_id in _retrievers:
+        del _retrievers[domain_id]
+    return True
+
+
+async def upload_document(user_id: str, domain_id: str, filename: str, content: str) -> Dict[str, Any]:
+    """Upload a text document to a domain."""
+    settings = get_settings()
+
+    # Verify domain ownership
+    domain = await fetch_one("SELECT * FROM domains WHERE id=? AND user_id=?", (domain_id, user_id))
+    if not domain:
+        raise ValueError("Domain not found")
+
+    # Check storage limits
+    docs = await fetch_all("SELECT size_bytes FROM documents WHERE domain_id IN (SELECT id FROM domains WHERE user_id=?)", (user_id,))
+    total_used = sum(d["size_bytes"] for d in docs)
+    doc_size = len(content.encode("utf-8"))
+    limit = int(settings.max_upload_mb * 1024 * 1024)
+    if total_used + doc_size > limit:
+        raise ValueError(f"Storage limit exceeded. Free tier allows {settings.max_upload_mb}MB. Upgrade to Premium (coming soon) for {settings.premium_upload_mb}MB.")
+
+    doc_id = new_id()
+    ts = now_iso()
+    await execute(
+        "INSERT INTO documents (id, domain_id, filename, content, size_bytes, created_at) VALUES (?,?,?,?,?,?)",
+        (doc_id, domain_id, filename, content, doc_size, ts),
+    )
+
+    # Index in FAISS
+    retriever = _get_retriever(domain_id)
+    from rag_master.models import Document
+    doc_obj = Document(doc_id=doc_id, content=content, source=filename, metadata={"filename": filename})
+    retriever.index_documents([doc_obj])
+
+    return {"id": doc_id, "filename": filename, "size_bytes": doc_size, "metadata": {}, "created_at": ts}
+
+
+async def list_documents(user_id: str, domain_id: str) -> List[Dict[str, Any]]:
+    domain = await fetch_one("SELECT id FROM domains WHERE id=? AND user_id=?", (domain_id, user_id))
+    if not domain:
+        return []
+    docs = await fetch_all("SELECT id, filename, size_bytes, metadata, created_at FROM documents WHERE domain_id=?", (domain_id,))
+    return [
+        {"id": d["id"], "filename": d["filename"], "size_bytes": d["size_bytes"],
+         "metadata": json.loads(d.get("metadata", "{}")), "created_at": d["created_at"]}
+        for d in docs
+    ]
+
+
+async def delete_document(user_id: str, domain_id: str, doc_id: str) -> bool:
+    domain = await fetch_one("SELECT id FROM domains WHERE id=? AND user_id=?", (domain_id, user_id))
+    if not domain:
+        return False
+    doc = await fetch_one("SELECT id FROM documents WHERE id=? AND domain_id=?", (doc_id, domain_id))
+    if not doc:
+        return False
+    await execute("DELETE FROM documents WHERE id=?", (doc_id,))
+    return True
+
+
+async def rag_query(user_id: str, domain_id: str, query: str, top_k: int = 5) -> Dict[str, Any]:
+    """Run a RAG query against user's domain documents."""
+    domain = await fetch_one("SELECT * FROM domains WHERE id=? AND user_id=?", (domain_id, user_id))
+    if not domain:
+        raise ValueError("Domain not found")
+
+    # Ensure all docs are indexed
+    retriever = _get_retriever(domain_id)
+
+    results = retriever.retrieve(query, top_k=top_k)
+    formatted = [
+        {"content": r.document.content, "score": round(r.score, 4), "metadata": r.document.metadata}
+        for r in results
+    ]
+
+    # Log query
+    qid = new_id()
+    ts = now_iso()
+    await execute(
+        "INSERT INTO rag_queries (id, user_id, domain_id, query, results, created_at) VALUES (?,?,?,?,?,?)",
+        (qid, user_id, domain_id, query, json.dumps(formatted), ts),
+    )
+
+    return {"query": query, "results": formatted, "domain": domain["name"]}
+
+
+async def reindex_domain(domain_id: str) -> None:
+    """Reindex all documents in a domain's FAISS index."""
+    retriever = _get_retriever(domain_id)
+    retriever.clear_index()
+    docs = await fetch_all("SELECT id, filename, content FROM documents WHERE domain_id=?", (domain_id,))
+    if docs:
+        from rag_master.models import Document
+        doc_objs = [
+            Document(doc_id=d["id"], content=d["content"], source=d["filename"], metadata={"filename": d["filename"]})
+            for d in docs
+        ]
+        retriever.index_documents(doc_objs)

agentic_rag_os/services/reward_service.py

@@ -0,0 +1,216 @@
+"""Rewards-as-a-Service — dynamic reward computation for any algorithm."""
+
+from __future__ import annotations
+
+import json
+import math
+import re
+from typing import Any, Dict, List, Optional
+
+from agentic_rag_os.models import execute, fetch_all, fetch_one, new_id, now_iso
+
+
+# --- Reward Config CRUD ---
+
+async def create_reward_config(user_id: str, name: str, algorithm: str, domain_id: Optional[str], config: Dict[str, Any]) -> Dict[str, Any]:
+    rid = new_id()
+    ts = now_iso()
+    await execute(
+        "INSERT INTO reward_configs (id, user_id, domain_id, name, algorithm, config, created_at, updated_at) VALUES (?,?,?,?,?,?,?,?)",
+        (rid, user_id, domain_id, name, algorithm, json.dumps(config), ts, ts),
+    )
+    return {"id": rid, "name": name, "algorithm": algorithm, "domain_id": domain_id, "config": config, "created_at": ts}
+
+
+async def list_reward_configs(user_id: str) -> List[Dict[str, Any]]:
+    rows = await fetch_all("SELECT * FROM reward_configs WHERE user_id=?", (user_id,))
+    return [
+        {"id": r["id"], "name": r["name"], "algorithm": r["algorithm"],
+         "domain_id": r.get("domain_id"), "config": json.loads(r["config"]), "created_at": r["created_at"]}
+        for r in rows
+    ]
+
+
+async def get_reward_config(user_id: str, config_id: str) -> Optional[Dict[str, Any]]:
+    r = await fetch_one("SELECT * FROM reward_configs WHERE id=? AND user_id=?", (config_id, user_id))
+    if not r:
+        return None
+    return {"id": r["id"], "name": r["name"], "algorithm": r["algorithm"],
+            "domain_id": r.get("domain_id"), "config": json.loads(r["config"]), "created_at": r["created_at"]}
+
+
+async def delete_reward_config(user_id: str, config_id: str) -> bool:
+    r = await fetch_one("SELECT id FROM reward_configs WHERE id=? AND user_id=?", (config_id, user_id))
+    if not r:
+        return False
+    await execute("DELETE FROM reward_jobs WHERE reward_config_id=?", (config_id,))
+    await execute("DELETE FROM reward_configs WHERE id=?", (config_id,))
+    return True
+
+
+# --- Reward Computation Engine ---
+
+def compute_reward(
+    algorithm: str,
+    query: str = "",
+    answer: str = "",
+    retrieved_docs: List[str] = [],
+    config: Dict[str, Any] = {},
+) -> Dict[str, Any]:
+    """Compute reward dynamically based on algorithm and config."""
+
+    weights = {
+        "retrieval_relevance_weight": config.get("retrieval_relevance_weight", 0.25),
+        "reasoning_quality_weight": config.get("reasoning_quality_weight", 0.20),
+        "answer_completeness_weight": config.get("answer_completeness_weight", 0.30),
+        "efficiency_weight": config.get("efficiency_weight", 0.15),
+        "anti_hack_weight": config.get("anti_hack_weight", 0.10),
+    }
+
+    breakdown = {}
+
+    # 1. Retrieval relevance — overlap between query and docs
+    if retrieved_docs and query:
+        query_tokens = set(query.lower().split())
+        doc_scores = []
+        for doc in retrieved_docs:
+            doc_tokens = set(doc.lower().split())
+            overlap = len(query_tokens & doc_tokens) / max(len(query_tokens), 1)
+            doc_scores.append(min(overlap * 1.5, 1.0))
+        breakdown["retrieval_relevance"] = sum(doc_scores) / len(doc_scores) if doc_scores else 0.0
+    else:
+        breakdown["retrieval_relevance"] = 0.0
+
+    # 2. Reasoning quality — presence of reasoning markers in answer
+    reasoning_markers = ["because", "therefore", "however", "analysis", "evidence", "conclusion", "furthermore"]
+    if answer:
+        answer_lower = answer.lower()
+        marker_count = sum(1 for m in reasoning_markers if m in answer_lower)
+        breakdown["reasoning_quality"] = min(marker_count / 4.0, 1.0)
+    else:
+        breakdown["reasoning_quality"] = 0.0
+
+    # 3. Answer completeness — length and coverage
+    if answer:
+        word_count = len(answer.split())
+        length_score = min(word_count / 150.0, 1.0)
+        # Coverage of query terms in answer
+        if query:
+            q_tokens = set(query.lower().split())
+            a_tokens = set(answer.lower().split())
+            coverage = len(q_tokens & a_tokens) / max(len(q_tokens), 1)
+        else:
+            coverage = 0.5
+        breakdown["answer_completeness"] = 0.6 * length_score + 0.4 * coverage
+    else:
+        breakdown["answer_completeness"] = 0.0
+
+    # 4. Efficiency — penalize very long or very short answers
+    if answer:
+        wc = len(answer.split())
+        if wc < 20:
+            breakdown["efficiency"] = 0.3
+        elif wc > 500:
+            breakdown["efficiency"] = 0.6
+        else:
+            breakdown["efficiency"] = 0.9
+    else:
+        breakdown["efficiency"] = 0.0
+
+    # 5. Anti-hack penalty
+    penalty = 0.0
+    if answer:
+        words = answer.lower().split()
+        unique_ratio = len(set(words)) / max(len(words), 1)
+        if unique_ratio < 0.3:
+            penalty += 0.5
+        # Repetition check
+        if len(words) > 10:
+            bigrams = [f"{words[i]}_{words[i+1]}" for i in range(len(words) - 1)]
+            bigram_unique = len(set(bigrams)) / max(len(bigrams), 1)
+            if bigram_unique < 0.4:
+                penalty += 0.3
+    breakdown["anti_hack_penalty"] = min(penalty, 1.0)
+
+    # Compute total
+    total = (
+        weights["retrieval_relevance_weight"] * breakdown["retrieval_relevance"]
+        + weights["reasoning_quality_weight"] * breakdown["reasoning_quality"]
+        + weights["answer_completeness_weight"] * breakdown["answer_completeness"]
+        + weights["efficiency_weight"] * breakdown["efficiency"]
+        - weights["anti_hack_weight"] * breakdown["anti_hack_penalty"]
+    )
+    total = max(0.01, min(0.99, total))
+
+    # Algorithm-specific adjustments
+    algo_meta = {}
+    if algorithm == "grpo":
+        algo_meta["group_relative"] = True
+        algo_meta["description"] = "Group Relative Policy Optimization — rewards are relative within groups"
+    elif algorithm == "ppo":
+        algo_meta["clipped"] = True
+        algo_meta["clip_range"] = config.get("clip_range", 0.2)
+        algo_meta["description"] = "Proximal Policy Optimization — clipped surrogate objective"
+    elif algorithm == "dpo":
+        algo_meta["preference_based"] = True
+        algo_meta["beta"] = config.get("beta", 0.1)
+        algo_meta["description"] = "Direct Preference Optimization — reward from preference pairs"
+    elif algorithm == "reinforce":
+        algo_meta["baseline"] = config.get("baseline", 0.5)
+        algo_meta["description"] = "REINFORCE — vanilla policy gradient with baseline"
+        total = total - algo_meta["baseline"]
+        total = max(0.01, min(0.99, (total + 1) / 2))
+    else:
+        algo_meta["description"] = "Custom reward function"
+
+    return {
+        "total_reward": round(total, 6),
+        "breakdown": {k: round(v, 4) for k, v in breakdown.items()},
+        "algorithm": algorithm,
+        "metadata": algo_meta,
+    }
+
+
+# --- Reward Jobs ---
+
+async def create_reward_job(user_id: str, reward_config_id: str, input_data: Dict[str, Any]) -> Dict[str, Any]:
+    config_row = await fetch_one("SELECT * FROM reward_configs WHERE id=? AND user_id=?", (reward_config_id, user_id))
+    if not config_row:
+        raise ValueError("Reward config not found")
+
+    jid = new_id()
+    ts = now_iso()
+
+    # Compute immediately (synchronous for now)
+    cfg = json.loads(config_row["config"])
+    result = compute_reward(
+        algorithm=config_row["algorithm"],
+        query=input_data.get("query", ""),
+        answer=input_data.get("answer", ""),
+        retrieved_docs=input_data.get("retrieved_docs", []),
+        config=cfg,
+    )
+
+    await execute(
+        "INSERT INTO reward_jobs (id, user_id, reward_config_id, status, result, created_at, completed_at) VALUES (?,?,?,?,?,?,?)",
+        (jid, user_id, reward_config_id, "completed", json.dumps(result), ts, ts),
+    )
+    return {"id": jid, "reward_config_id": reward_config_id, "status": "completed", "result": result, "created_at": ts, "completed_at": ts}
+
+
+async def list_reward_jobs(user_id: str, config_id: Optional[str] = None) -> List[Dict[str, Any]]:
+    if config_id:
+        rows = await fetch_all(
+            "SELECT * FROM reward_jobs WHERE user_id=? AND reward_config_id=? ORDER BY created_at DESC LIMIT 50",
+            (user_id, config_id),
+        )
+    else:
+        rows = await fetch_all(
+            "SELECT * FROM reward_jobs WHERE user_id=? ORDER BY created_at DESC LIMIT 50",
+            (user_id,),
+        )
+    return [
+        {"id": r["id"], "reward_config_id": r["reward_config_id"], "status": r["status"],
+         "result": json.loads(r.get("result", "{}")), "created_at": r["created_at"], "completed_at": r.get("completed_at")}
+        for r in rows
+    ]

documents/agentic_rag_os_architecture.md

@@ -0,0 +1,378 @@
+# Agentic RAG OS — Architecture & Design Document
+
+## 1. Overview
+
+**Agentic RAG OS** is an RL B2B Rewards-as-a-Service (RaaS) platform — the operating system for agentic Retrieval-Augmented Generation. It provides a complete pipeline from user data ingestion → embedding → retrieval → reward signal generation, enabling teams to build, evaluate, and fine-tune LLMs using production-grade reward functions.
+
+### 1.1 Mission Statement
+
+Democratize access to RL-driven RAG improvement by providing infrastructure-as-a-service for reward signal generation, eliminating the need for teams to build custom evaluation pipelines from scratch.
+
+### 1.2 Core Value Proposition
+
+| Capability | Description |
+|---|---|
+| **Data → Embeddings** | Upload text documents, auto-embed with sentence-transformers, store in FAISS |
+| **Rewards-as-a-Service** | Generate reward signals for GRPO, PPO, DPO, REINFORCE via API |
+| **Multi-Algorithm Support** | Choose reward algorithm dynamically per request |
+| **Anti-Reward Hacking** | Built-in guards against gaming, repetition, degenerate outputs |
+| **API-First** | Every capability exposed as RESTful endpoint |
+
+---
+
+## 2. System Architecture
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                    Client Layer                               │
+│  ┌──────────────┐  ┌─────────────┐  ┌───────────────────┐   │
+│  │  Web App SPA │  │  API Client  │  │  SDK / CLI        │   │
+│  │  (Dark Theme) │  │  (REST/JWT)  │  │  (API Key Auth)   │   │
+│  └──────┬───────┘  └──────┬──────┘  └────────┬──────────┘   │
+└─────────┼──────────────────┼──────────────────┼──────────────┘
+          │                  │                  │
+          ▼                  ▼                  ▼
+┌─────────────────────────────────────────────────────────────┐
+│                 FastAPI Application Layer                     │
+│                                                              │
+│  ┌──────────────┐  ┌────────────┐  ┌──────────────────┐     │
+│  │  Auth Routes  │  │ RAG Routes │  │  Reward Routes    │     │
+│  │  /auth/*      │  │ /rag/*     │  │  /rewards/*       │     │
+│  └──────┬───────┘  └─────┬──────┘  └────────┬─────────┘     │
+│         │                │                   │               │
+│  ┌──────▼───────┐  ┌─────▼──────┐  ┌────────▼─────────┐     │
+│  │ User Routes  │  │  Deps      │  │  Health / Docs    │     │
+│  │ /user/*      │  │  (Auth DI) │  │  /api/docs|redoc  │     │
+│  └──────────────┘  └────────────┘  └──────────────────┘     │
+└──────────────────────────┬──────────────────────────────────┘
+                           │
+┌──────────────────────────▼──────────────────────────────────┐
+│                    Service Layer                              │
+│                                                              │
+│  ┌──────────────────┐  ┌───────────────────────────────┐    │
+│  │  Auth Service     │  │  RAG Service                   │    │
+│  │  - JWT tokens     │  │  - Domain CRUD                 │    │
+│  │  - Password hash  │  │  - Document upload/embed       │    │
+│  │  - GitHub OAuth   │  │  - FAISS indexing              │    │
+│  │  - API keys       │  │  - Semantic retrieval          │    │
+│  └──────────────────┘  └───────────────────────────────┘    │
+│                                                              │
+│  ┌──��─────────────────────────────────────────────────────┐  │
+│  │  Reward Service                                         │  │
+│  │  - Multi-algorithm compute (GRPO, PPO, DPO, REINFORCE) │  │
+│  │  - Config management                                    │  │
+│  │  - Job execution                                        │  │
+│  │  - Anti-hack detection                                  │  │
+│  └────────────────────────────────────────────────────────┘  │
+└──────────────────────────┬──────────────────────────────────┘
+                           │
+┌──────────────────────────▼──────────────────────────────────┐
+│                   Data / Storage Layer                        │
+│                                                              │
+│  ┌──────────────┐  ┌────────────────┐  ┌────────────────┐   │
+│  │  SQLite DB    │  │  FAISS Indices  │  │  File Storage   │   │
+│  │  - Users      │  │  - Per-domain   │  │  - Uploads      │   │
+│  │  - API Keys   │  │  - MiniLM-L6    │  │  - 2MB free     │   │
+│  │  - Domains    │  │  - 384-dim      │  │  - Premium      │   │
+│  │  - Documents  │  │  - Inner product │  │    coming soon  │   │
+│  │  - Configs    │  │                 │  │                 │   │
+│  │  - Jobs       │  │                 │  │                 │   │
+│  └──────────────┘  └────────────────┘  └────────────────┘   │
+└──────────────────────────┬──────────────────────────────────┘
+                           │
+┌──────────────────────────▼──────────────────────────────────┐
+│                   RAG Master Core                            │
+│  (Shared library from agentic-rag-gym)                      │
+│                                                              │
+│  ┌──────────────┐  ┌────────────────┐  ┌────────────────┐   │
+│  │  Retriever    │  │  Reward Funcs   │  │  Models         │   │
+│  │  FAISSRetriever│ │  Composite      │  │  Document       │   │
+│  │  SentenceTransf│ │  LLM Judge      │  │  Trajectory     │   │
+│  └──────────────┘  └────────────────┘  └────────────────┘   │
+│                                                              │
+│  ┌──────────────┐  ┌────────────────┐  ┌────────────────┐   │
+│  │  Agents       │  │  Orchestrator   │  │  Adapters       │   │
+│  │  5 specialized│  │  Multi-agent    │  │  Base classes   │   │
+│  └──────────────┘  └────────────────┘  └────────────────┘   │
+└─────────────────────────────────────────────────────────────┘
+```
+
+---
+
+## 3. Authentication Architecture
+
+### 3.1 Dual Auth Strategy
+
+```
+┌──────────────────────────────────────────┐
+│           Authentication Flow             │
+│                                          │
+│  Browser ─→ JWT Bearer Token             │
+│    1. POST /auth/register (username/pw)  │
+│    2. POST /auth/login (username/pw)     │
+│    3. GET  /auth/github/callback (OAuth) │
+│    ↓                                     │
+│    JWT in Authorization: Bearer <token>  │
+│                                          │
+│  API Client ─→ API Key                   │
+│    1. POST /user/api-keys (generate)     │
+│    ↓                                     │
+│    X-API-Key: ragos_<hex>                │
+└──────────────────────────────────────────┘
+```
+
+### 3.2 Security Measures
+
+- **Password Hashing**: PBKDF2-HMAC-SHA256, 310,000 iterations, random salt
+- **JWT**: HS256 signing, 24h expiry, rotating secret keys
+- **API Keys**: SHA-256 hashed storage, prefix-only display, revocable
+- **GitHub OAuth**: Standard OAuth 2.0 code exchange flow
+
+---
+
+## 4. Data Flow
+
+### 4.1 Document Ingestion Pipeline
+
+```
+User Upload (text file)
+    │
+    ▼
+Storage Limit Check (2MB free / 100MB premium)
+    │
+    ▼
+SQLite Record (id, content, metadata)
+    │
+    ▼
+Sentence-Transformer Encoding (all-MiniLM-L6-v2, 384-dim)
+    │
+    ▼
+FAISS IndexFlatIP (inner product similarity)
+    │
+    ▼
+Domain-Isolated Index (per-user, per-domain)
+```
+
+### 4.2 RAG Query Pipeline
+
+```
+User Query (text)
+    │
+    ▼
+Embedding (same model as indexing)
+    │
+    ▼
+FAISS Similarity Search (top-k, cosine via normalized IP)
+    │
+    ▼
+Score Normalization [0, 1]
+    │
+    ▼
+Results + Metadata → Response
+    │
+    ▼
+Query Logged (for analytics)
+```
+
+### 4.3 Reward Computation Pipeline
+
+```
+Input: {algorithm, query, answer, retrieved_docs, config}
+    │
+    ├──→ Retrieval Relevance (query-doc overlap)
+    ├──→ Reasoning Quality (marker detection)
+    ├──→ Answer Completeness (length + coverage)
+    ├──→ Efficiency (length bounds)
+    └──→ Anti-Hack Detection (degenerate check)
+    │
+    ▼
+Weighted Sum → Clamp [0.01, 0.99]
+    │
+    ▼
+Algorithm-Specific Adjustments
+    │
+    ▼
+{total_reward, breakdown, algorithm, metadata}
+```
+
+---
+
+## 5. API Design
+
+### 5.1 Endpoint Map
+
+| Method | Path | Auth | Description |
+|--------|------|------|-------------|
+| POST | `/api/v1/auth/register` | No | Create account |
+| POST | `/api/v1/auth/login` | No | Login, get JWT |
+| GET | `/api/v1/auth/github/callback` | No | GitHub OAuth |
+| GET | `/api/v1/user/me` | Yes | Current user profile |
+| GET | `/api/v1/user/dashboard` | Yes | Dashboard statistics |
+| POST | `/api/v1/user/api-keys` | Yes | Create API key |
+| GET | `/api/v1/user/api-keys` | Yes | List API keys |
+| DELETE | `/api/v1/user/api-keys/:id` | Yes | Revoke API key |
+| POST | `/api/v1/rag/domains` | Yes | Create domain |
+| GET | `/api/v1/rag/domains` | Yes | List domains |
+| DELETE | `/api/v1/rag/domains/:id` | Yes | Delete domain |
+| POST | `/api/v1/rag/domains/:id/documents` | Yes | Upload document |
+| GET | `/api/v1/rag/domains/:id/documents` | Yes | List documents |
+| DELETE | `/api/v1/rag/domains/:id/documents/:docId` | Yes | Delete document |
+| POST | `/api/v1/rag/domains/:id/query` | Yes | RAG query |
+| POST | `/api/v1/rewards/compute` | Yes | Compute reward |
+| POST | `/api/v1/rewards/configs` | Yes | Create config |
+| GET | `/api/v1/rewards/configs` | Yes | List configs |
+| DELETE | `/api/v1/rewards/configs/:id` | Yes | Delete config |
+| POST | `/api/v1/rewards/jobs` | Yes | Create job |
+| GET | `/api/v1/rewards/jobs` | Yes | List jobs |
+| GET | `/api/v1/rewards/algorithms` | No | List algorithms |
+| GET | `/api/v1/health` | No | Health check |
+
+### 5.2 Error Responses
+
+All errors follow a consistent format:
+```json
+{
+  "detail": "Human-readable error message"
+}
+```
+
+Standard HTTP status codes: 400 (bad request), 401 (unauthorized), 404 (not found), 500 (server error).
+
+---
+
+## 6. Reward Algorithms
+
+### 6.1 Supported Algorithms
+
+| Algorithm | Description | Use Case |
+|-----------|-------------|----------|
+| **GRPO** | Group Relative Policy Optimization | Stable RL training with relative rewards |
+| **PPO** | Proximal Policy Optimization | Clipped surrogate for monotonic improvement |
+| **DPO** | Direct Preference Optimization | Preference-based, no reward model needed |
+| **REINFORCE** | Policy gradient with baseline | Simple gradient estimation |
+| **Custom** | User-defined weights | Domain-specific scoring |
+
+### 6.2 Reward Signal Components
+
+| Component | Weight | Signal Source |
+|-----------|--------|---------------|
+| Retrieval Relevance | 0.25 | Query-document token overlap |
+| Reasoning Quality | 0.20 | Reasoning marker detection |
+| Answer Completeness | 0.30 | Length + query coverage |
+| Efficiency | 0.15 | Answer length bounds |
+| Anti-Hack Penalty | 0.10 | Degenerate content detection |
+
+All weights are configurable per reward config.
+
+---
+
+## 7. Deployment Architecture
+
+### 7.1 Google Cloud Run
+
+```
+┌─────────────────────────────────────┐
+│          Google Cloud Run            │
+│                                     │
+│  ┌────────────────────────────────┐ │
+│  │  Container: Agentic RAG OS     │ │
+│  │                                │ │
+│  │  FastAPI App (:8080)           │ │
+│  │  ├── Auth Service              │ │
+│  │  ├── RAG Service               │ │
+│  │  ├── Reward Service            │ │
+│  │  └── Static Frontend           │ │
+│  │                                │ │
+│  │  SQLite + FAISS (ephemeral)    │ │
+│  └────────────────────────────────┘ │
+│                                     │
+│  Auto-scaling: 0-10 instances       │
+│  Memory: 2Gi                        │
+│  CPU: 2                             │
+└─────────────────────────────────────┘
+```
+
+### 7.2 Infrastructure
+
+| Component | Service | Details |
+|-----------|---------|---------|
+| Compute | Cloud Run | Serverless containers, auto-scaling |
+| Container Registry | Artifact Registry | Docker image storage |
+| Networking | Cloud Run default | HTTPS with managed TLS |
+| Storage | Ephemeral (container FS) | SQLite + FAISS per instance |
+| Monitoring | Cloud Logging | Automatic log collection |
+
+---
+
+## 8. Security Architecture
+
+### 8.1 OWASP Compliance
+
+| Risk | Mitigation |
+|------|------------|
+| Injection | Parameterized SQL queries (aiosqlite), input sanitization |
+| Auth Failure | PBKDF2 password hashing, JWT with expiry, API key rotation |
+| Data Exposure | Hashed passwords, hashed API keys, prefix-only display |
+| SSRF | No user-controlled URL fetching (except GitHub OAuth) |
+| Security Logging | All auth events logged |
+
+### 8.2 Data Isolation
+
+- Each user has isolated domains
+- Each domain has isolated FAISS index
+- SQL queries filter by `user_id` at every layer
+- File uploads restricted to text content only
+
+---
+
+## 9. Frontend Architecture
+
+### 9.1 SPA Design
+
+- **Framework**: Vanilla JavaScript (zero dependencies)
+- **Theme**: Dark mode with purple/cyan accent gradient
+- **Routing**: Hash-based client-side navigation
+- **State**: In-memory with localStorage for JWT persistence
+- **Animations**: CSS keyframes + IntersectionObserver
+
+### 9.2 Views
+
+| View | Path | Auth Required |
+|------|------|---------------|
+| Landing Page | `/` | No |
+| Dashboard | `/dashboard` | Yes |
+| Domains | `/domains` | Yes |
+| Rewards | `/rewards` | Yes |
+| API Keys | `/apikeys` | Yes |
+
+---
+
+## 10. Integration with RAG Master
+
+Agentic RAG OS reuses core components from the `rag_master` library:
+
+| Component | Usage |
+|-----------|-------|
+| `FAISSRetriever` | Document indexing and retrieval |
+| `Document` model | Document data structure |
+| `CompositeRewardFunction` | Reference reward implementation |
+| `SentenceTransformer` | Embedding generation |
+
+The RAG OS operates independently of the Gym server — it does **not** require the gym to be running.
+
+---
+
+## 11. Technology Stack
+
+| Layer | Technology |
+|-------|-----------|
+| Language | Python 3.10+ |
+| API Framework | FastAPI |
+| Database | SQLite (aiosqlite) |
+| Vector Store | FAISS (faiss-cpu) |
+| Embeddings | sentence-transformers/all-MiniLM-L6-v2 |
+| Auth | PyJWT + PBKDF2 |
+| Frontend | HTML5 + CSS3 + Vanilla JS |
+| Container | Docker |
+| Cloud | Google Cloud Run |
+| CI/CD | GitHub → Cloud Build → Cloud Run |

pyproject.toml

@@ -29,6 +29,11 @@ dependencies = [
 ]
 
 [project.optional-dependencies]
+ragos = [
+    "aiosqlite>=0.20.0",
+    "PyJWT>=2.8.0",
+    "python-multipart>=0.0.9",
+]
 dev = [
     "pytest>=8.3.0",
     "pytest-cov>=5.0.0",
@@ -56,7 +61,7 @@ select = ["E", "F", "W", "I", "N", "UP", "S", "B"]
 ignore = ["S101", "S104"]
 
 [tool.hatch.build.targets.wheel]
-packages = ["rag_master", "server", "domains"]
+packages = ["rag_master", "server", "domains", "agentic_rag_os"]
 
 [tool.mypy]
 python_version = "3.10"