fixed gaugepilot upload routes

DocPilot/backend/app/main.py

@@ -37,11 +37,11 @@ app.include_router(auth.router, prefix="/auth")
 app.include_router(billing.router, prefix="/billing")
 app.include_router(history.router, prefix="/history")
 app.include_router(models.router, prefix="/models", tags=["models"])
-app.include_router(
+"""app.include_router(
     benchmark.router,
     prefix="/benchmark",
     tags=["benchmark"],
-)
+)"""
 app.add_middleware(
     CORSMiddleware,
     allow_origins=["*"],

GaugePilot/backend/app/api/benchmark.py

@@ -0,0 +1,72 @@
+from fastapi import APIRouter, Depends
+
+from GaugePilot.backend.app.core.dependencies import (
+    get_current_user,
+)
+
+from GaugePilot.backend.app.schemas.benchmark import (
+    BenchmarkRequest,
+)
+
+from pilotcore.benchmarking.benchmark_runner import (
+    run_benchmark,
+)
+
+from pilotcore.benchmarking.leaderboard import (
+    generate_leaderboard,
+)
+
+from pilotcore.runtime.experiment_config import (
+    ExperimentConfig,
+)
+
+router = APIRouter()
+
+
+@router.post("/run")
+def run_benchmark_endpoint(
+    request: BenchmarkRequest,
+    current_user=Depends(get_current_user),
+):
+    configs = [
+        ExperimentConfig(
+            experiment_name="Hybrid+MiniLM",
+            retrieval_method="hybrid",
+            reranker=True,
+            reranker_model="minilm",
+        ),
+        ExperimentConfig(
+            experiment_name="BM25",
+            retrieval_method="lexical",
+            reranker=False,
+        ),
+        ExperimentConfig(
+            experiment_name="Hybrid_NoRewrite",
+            retrieval_method="hybrid",
+            reranker=True,
+            reranker_model="minilm",
+            query_rewrite=False,
+        ),
+        ExperimentConfig(
+            experiment_name="Hybrid_NoReranker",
+            retrieval_method="hybrid",
+            reranker=False,
+        ),
+        ExperimentConfig(
+            experiment_name="Vector_Only",
+            retrieval_method="vector",
+            reranker=True,
+            reranker_model="minilm",
+        ),
+    ]
+
+    results = run_benchmark(
+        questions=request.questions,
+        configs=configs,
+        user_id=current_user.id,
+        source=None,
+    )
+
+    leaderboard = generate_leaderboard(results)
+
+    return {"leaderboard": leaderboard}

GaugePilot/backend/app/api/documents.py

@@ -0,0 +1,219 @@
+from fastapi import (
+    APIRouter,
+    UploadFile,
+    File,
+    Depends,
+    HTTPException,
+)
+
+from sqlalchemy.orm import Session
+
+import shutil
+import os
+
+from DocPilot.backend.app.services.ingestion import (
+    process_document,
+    TextExtractionError,
+)
+
+from pilotcore.retrieval.vector_store import (
+    reset_vector_store,
+    rebuild_index_without_document,
+)
+
+from DocPilot.backend.app.core.dependencies import (
+    get_current_user,
+)
+
+from DocPilot.backend.app.db.session import get_db
+
+from DocPilot.backend.app.models.document import Document
+
+from GaugePilot.backend.app.schemas.document import (
+    DocumentResponse,
+)
+
+router = APIRouter()
+
+
+@router.post("/upload")
+async def upload_document(
+    file: UploadFile = File(...),
+    current_user=Depends(get_current_user),
+    db: Session = Depends(get_db),
+):
+
+    document_count = (
+        db.query(Document).filter(Document.owner_id == current_user.id).count()
+    )
+
+    if current_user.plan == "free" and document_count >= 3:
+
+        raise HTTPException(
+            status_code=403,
+            detail="Free plan upload limit reached.",
+        )
+
+    os.makedirs(
+        "temp",
+        exist_ok=True,
+    )
+
+    allowed_extensions = [
+        ".pdf",
+        ".docx",
+        ".pptx",
+        ".txt",
+        ".md",
+        ".csv",
+        ".xlsx",
+        ".png",
+        ".jpg",
+        ".jpeg",
+        ".webp",
+        # treated as plain-text/code-like content
+        ".py",
+        ".js",
+        ".jsx",
+        ".ts",
+        ".tsx",
+        ".java",
+        ".cpp",
+        ".c",
+        ".h",
+        ".go",
+        ".rs",
+        ".json",
+        ".yaml",
+        ".yml",
+        ".sql",
+        ".css",
+        ".html",
+    ]
+
+    file_ext = os.path.splitext(file.filename)[1].lower()
+
+    if file_ext not in allowed_extensions:
+
+        raise HTTPException(
+            status_code=400,
+            detail="Unsupported file type.",
+        )
+
+    file_path = f"temp/{file.filename}"
+
+    with open(
+        file_path,
+        "wb",
+    ) as buffer:
+
+        shutil.copyfileobj(
+            file.file,
+            buffer,
+        )
+
+    document = Document(
+        owner_id=current_user.id,
+        filename=file.filename,
+        filepath=file_path,
+        file_size=os.path.getsize(file_path),
+    )
+
+    db.add(document)
+
+    db.commit()
+
+    db.refresh(document)
+
+    try:
+
+        process_document(
+            file_path,
+            current_user.id,
+            document.id,
+            mime_type=file.content_type,
+        )
+
+    except TextExtractionError as exc:
+
+        db.delete(document)
+
+        db.commit()
+
+        raise HTTPException(
+            status_code=422,
+            detail=str(exc),
+        ) from exc
+
+    return {
+        "message": "Document uploaded",
+        "document_id": document.id,
+    }
+
+
+@router.get(
+    "/",
+    response_model=list[DocumentResponse],
+)
+def get_documents(
+    db: Session = Depends(get_db),
+    current_user=Depends(get_current_user),
+):
+
+    documents = db.query(Document).filter(Document.owner_id == current_user.id).all()
+
+    return documents
+
+
+@router.delete("/reset")
+def reset_documents(
+    current_user=Depends(get_current_user),
+    db: Session = Depends(get_db),
+):
+    reset_vector_store(current_user.id)
+
+    db.query(Document).filter(Document.owner_id == current_user.id).delete()
+    db.commit()
+
+    return {"message": "Vector store and documents cleared."}
+
+
+@router.delete("/{document_id}")
+def delete_document(
+    document_id: int,
+    db: Session = Depends(get_db),
+    current_user=Depends(get_current_user),
+):
+
+    document = (
+        db.query(Document)
+        .filter(
+            Document.id == document_id,
+            Document.owner_id == current_user.id,
+        )
+        .first()
+    )
+
+    if not document:
+
+        raise HTTPException(
+            status_code=404,
+            detail="Document not found",
+        )
+
+    if os.path.exists(document.filepath):
+
+        os.remove(document.filepath)
+
+    rebuild_index_without_document(
+        current_user.id,
+        document.id,
+    )
+
+    db.delete(document)
+
+    db.commit()
+
+    return {
+        "message": "Document deleted",
+    }

GaugePilot/backend/app/core/dependencies.py

@@ -0,0 +1,5 @@
+from fastapi import Depends
+
+# Reuse DocPilot's auth/db wiring if available in this monorepo.
+# This keeps GaugePilot thin while preserving existing behavior.
+from DocPilot.backend.app.core.dependencies import get_current_user  # noqa: F401

GaugePilot/backend/app/main.py

@@ -0,0 +1,28 @@
+from fastapi import FastAPI
+
+from fastapi.middleware.cors import CORSMiddleware
+
+from .api import benchmark
+from .api import documents
+
+app = FastAPI()
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+app.include_router(benchmark.router, prefix="/benchmark", tags=["benchmark"])
+
+app.include_router(
+    documents.router,
+    prefix="/docs",
+)
+
+
+@app.get("/")
+def root():
+    return {"status": "running", "service": "gaugepilot"}

GaugePilot/backend/app/schemas/benchmark.py

@@ -0,0 +1,5 @@
+from pydantic import BaseModel
+
+
+class BenchmarkRequest(BaseModel):
+    questions: list[str]

GaugePilot/backend/app/schemas/document.py

@@ -0,0 +1,25 @@
+from pydantic import BaseModel
+from datetime import datetime
+
+
+class DocumentResponse(BaseModel):
+    id: int
+
+    filename: str
+
+    filepath: str
+
+    file_size: int | None = None
+
+    page_count: int | None = None
+
+    chunk_count: int | None = None
+
+    ocr_used: bool
+
+    status: str
+
+    created_at: datetime
+
+    class Config:
+        from_attributes = True

README.md

@@ -10,202 +10,167 @@ pinned: false
 
 # PilotMaster
 
-**PilotMaster** is a retrieval engineering and AI observability platform for building, debugging, and evaluating Retrieval-Augmented Generation (RAG) systems.
+**PilotMaster** is a retrieval engineering, document intelligence, and AI observability platform for building, debugging, evaluating, and improving Retrieval-Augmented Generation (RAG) systems.
 
 Most RAG applications expose only the final answer.
 
 PilotMaster exposes the entire retrieval journey.
 
-It allows developers to inspect what was retrieved, why chunks ranked the way they did, whether retrieval methods agreed, how reranking influenced the final context, how grounded the answer was, and how different language models behave when given the same evidence.
-
-The platform combines:
-
-- **DocPilot** — document intelligence and grounded question answering
-- **TracePilot** — observability, tracing, replay, and evaluation
-- **PilotCore** — the shared execution kernel that powers retrieval, generation, evaluation, and tracing
-
----
-
-# Why PilotMaster Exists
-
-Modern GenAI systems often behave like black boxes.
-
-A document is uploaded.
-
-A question is asked.
-
-An answer is returned.
-
-What remains invisible is:
-
-- what information was retrieved
-- why certain chunks outranked others
-- whether dense retrieval or lexical retrieval dominated
-- how confident the reranker was
-- whether the answer was sufficiently grounded
-- where hallucination risk emerged
-- how a different model would have answered using the exact same context
-
-PilotMaster was built to make those decisions observable.
+From retrieval and reranking to evaluation and trace replay, every major decision can be inspected, analyzed, benchmarked, and improved.
 
 ---
 
-# Experimental Workspace
-
-PilotMaster includes an Experimental Workspace for retrieval engineering research and controlled pipeline experimentation.
+# Platform Overview
 
-Unlike the production workspace, which uses the platform's recommended retrieval configuration, the Experimental Workspace allows developers to modify retrieval strategies and retrieval enhancements at runtime.
+PilotMaster consists of three major layers:
 
-Current experimentation capabilities include:
+## DocPilot
 
-- Dense-only retrieval
-- BM25-only retrieval
-- Hybrid retrieval
-- Hybrid + RRF
-- Hybrid + RRF + Reranker
+The document intelligence workspace.
 
-The Experimental Workspace is designed to answer questions such as:
+Provides:
 
-- Does reranking improve grounding?
-- When does BM25 outperform dense retrieval?
-- How much does RRF improve recall?
-- Which retrieval strategy performs best for a specific document collection?
+- Document ingestion
+- OCR processing
+- Grounded question answering
+- Citation-aware responses
+- Runtime model selection
+- Retrieval experimentation
 
-The long-term goal is transforming PilotMaster from a RAG application into a retrieval engineering platform.
+## TracePilot
 
-# What PilotMaster Does
+The observability workspace.
 
-PilotMaster combines:
+Provides:
 
-- Dense semantic retrieval
-- BM25 retrieval
-- Hybrid retrieval
-- Reciprocal Rank Fusion (RRF)
-- Cross-encoder reranking
-- Runtime model selection
-- Grounded generation
 - Retrieval diagnostics
+- Chunk lineage inspection
 - Replayable traces
-- Retrieval evaluation
-- Comparative model benchmarking
-
-The objective is not merely generating answers.
+- Reranker analysis
+- Evaluation metrics
+- Hallucination analysis
+- Retrieval agreement analysis
 
-The objective is understanding how answers were generated.
+## PilotCore
 
----
+The shared execution kernel.
 
-# High-Level Architecture
+Provides:
 
-Current request flow:
+- Embeddings
+- Retrieval
+- Fusion
+- Reranking
+- Prompt construction
+- Generation
+- Evaluation
+- Tracing
 
-Dashboard.jsx
-→ FastAPI
-→ DocPilot
-→ PilotCore
-→ Retrieval
-→ Reranking
-→ Generation
-→ Evaluation
-→ TracePilot
+---
 
-PilotCore acts as the execution kernel shared by both DocPilot and TracePilot.
+# Why PilotMaster Exists
 
----
+Modern GenAI systems frequently behave like black boxes.
 
-# System Components
+A document is uploaded.
 
-## PilotCore — Execution Kernel
+A question is asked.
 
-PilotCore contains:
+An answer is returned.
 
-- embeddings
-- retrieval
-- reranking
-- prompt construction
-- generation
-- evaluation
-- tracing
-- replay
+What remains hidden:
 
-Key runtime modules:
+- What was retrieved?
+- Why did those chunks rank first?
+- Which retriever contributed the evidence?
+- Did BM25 or dense retrieval dominate?
+- How confident was the reranker?
+- Was the answer grounded?
+- Did the model hallucinate?
+- Would another model answer differently using the same evidence?
 
-pilotcore/retrieval/runtime.py
+PilotMaster was built to make those decisions observable.
 
-pilotcore/retrieval/vector_store.py
+---
 
-pilotcore/retrieval/reranker.py
+# Unified Workspace
 
-pilotcore/runtime/pipeline.py
+DocPilot and TracePilot operate inside the same platform experience.
 
-pilotcore/generation/generator.py
+Typical workflow:
 
-Both DocPilot and TracePilot delegate execution to PilotCore.
+1. Upload a document
+2. Ask a question
+3. Review citations
+4. Inspect retrieved chunks
+5. Analyze ranking signals
+6. Evaluate answer quality
+7. Replay the execution
+8. Compare retrieval strategies
 
 ---
 
-## DocPilot — Document Intelligence Layer
+# Research Workspace
 
-DocPilot is the primary user-facing application.
+PilotMaster includes a dedicated workspace for retrieval engineering.
 
-Features include:
+Supported retrieval modes:
 
-- document upload
-- OCR ingestion
-- citation-aware QA
-- grounded responses
-- chat sessions
-- runtime model selection
+- Dense Retrieval
+- BM25 Retrieval
+- Hybrid Retrieval
+- Hybrid + RRF
+- Hybrid + RRF + Reranking
 
-Supported formats:
+Experimental controls include:
 
-- PDF
-- DOCX
-- TXT
-- CSV
-- XLSX
-- PNG
-- JPG
-- JPEG
+- Embedding model selection
+- Reranker selection
+- Retrieval strategy selection
+- Query enhancement testing
+- Model benchmarking
 
----
+Questions the workspace helps answer:
 
-## TracePilot — Observability Layer
+- Does reranking improve grounding?
+- When does BM25 outperform dense retrieval?
+- Does RRF improve recall?
+- Which embedding model performs best?
+- Which reranker produces the best ranking quality?
 
-TracePilot exposes the internal behavior of retrieval and generation.
+---
 
-Every trace can contain:
+# High-Level Architecture
 
-- retrieved chunks
-- dense retrieval diagnostics
-- BM25 diagnostics
-- RRF fusion signals
-- reranker diagnostics
-- retrieval lineage
-- latency spans
-- evaluation metrics
-- replay metadata
+Dashboard
+→ FastAPI
+→ DocPilot
+→ PilotCore
+→ Retrieval
+→ Fusion
+→ Reranking
+→ Generation
+→ Evaluation
+→ TracePilot
 
-The goal is observable AI execution rather than guess-based debugging.
+PilotCore acts as the execution kernel shared by every workspace.
 
 ---
 
-# Retrieval System
+# Retrieval Architecture
 
 ## Retrieval Pipeline
 
-Current retrieval flow:
-
 Query
-→ Dense Retrieval (FAISS)
+→ Dense Retrieval
 → BM25 Retrieval
-→ Reciprocal Rank Fusion (RRF)
-→ Candidate Pool Construction
+→ Reciprocal Rank Fusion
+→ Candidate Pool
 → Cross-Encoder Reranking
-→ Top Context Selection
+→ Context Selection
 → LLM Generation
 → Evaluation
-→ Trace Ingestion
+→ Trace Storage
 
 ---
 
@@ -214,93 +179,101 @@ Query
 Semantic retrieval uses:
 
 - SentenceTransformers
-- all-mpnet-base-v2
-- FAISS IndexFlatIP
-- cosine similarity
+- Cosine Similarity
+- FAISS
+- IndexFlatIP
+
+Responsibilities:
 
-Dense retrieval is responsible for semantic recall and concept-level matching.
+- Concept matching
+- Semantic recall
+- Contextual retrieval
 
 ---
 
 ## BM25 Retrieval
 
-BM25 complements dense retrieval by handling:
+Responsibilities:
 
-- exact terminology
-- acronyms
-- keyword-heavy queries
-- lexical matching
-- negation-sensitive retrieval
+- Exact terminology
+- Acronyms
+- Keywords
+- Lexical precision
+- Negation-sensitive retrieval
 
-This mitigates weaknesses found in vector-only retrieval systems.
+BM25 compensates for weaknesses found in purely vector-based systems.
 
 ---
 
-## Reciprocal Rank Fusion (RRF)
+## Reciprocal Rank Fusion
 
-RRF combines:
+Combines:
 
-- dense retrieval rankings
+- Dense rankings
 - BM25 rankings
 
-This provides a more stable ranking signal than simple result concatenation.
+Benefits:
+
+- Better recall
+- Stable rankings
+- Reduced retriever bias
 
 ---
 
 ## Cross-Encoder Reranking
 
-Final ranking uses:
+Reranking occurs after retrieval and before prompt construction.
 
-cross-encoder/ms-marco-MiniLM-L-6-v2
+Supported families:
 
-The reranker:
+- MiniLM rerankers
+- BGE rerankers
+- Experimental rerankers
 
-- jointly evaluates query-chunk pairs
-- rescoring fused candidates
-- promotes semantically relevant evidence
-- improves ranking precision
+Responsibilities:
 
-Reranking occurs after retrieval and before prompt construction.
+- Joint query/chunk evaluation
+- Candidate rescoring
+- Precision improvement
+- Evidence prioritization
 
 ---
 
-# Current Retrieval Configuration
-
-| Component               | Configuration                             |
-| ----------------------- | ----------------------------------------- |
-| Embedding Model         | `sentence-transformers/all-mpnet-base-v2` |
-| Embedding Dimension     | 768                                       |
-| Vector Store            | FAISS (`IndexFlatIP`)                     |
-| Similarity Metric       | Cosine Similarity                         |
-| Chunk Size              | 500 characters                            |
-| Chunk Overlap           | 80 characters                             |
-| Dense Retrieval Depth   | Top 7                                     |
-| BM25 Retrieval Depth    | Top 7                                     |
-| Fusion Strategy         | Reciprocal Rank Fusion (RRF)              |
-| Reranker                | `cross-encoder/ms-marco-MiniLM-L-6-v2`    |
-| Reranker Candidate Pool | Up to 20 chunks                           |
-| Final Context Window    | Top 7 reranked chunks                     |
-| Retrieval Version       | `hybrid_rrf_v1`                           |
+# Runtime Retrieval Components
 
----
+PilotMaster supports runtime experimentation.
 
-# Model Runtime
+## Embedding Models
+
+Examples:
+
+- all-mpnet-base-v2
+- BGE family
+- Additional SentenceTransformer models
 
-PilotMaster supports runtime model selection through a centralized model registry.
+## Rerankers
 
-Models are defined in:
+Examples:
 
-pilotcore/models/registry.py
+- MiniLM
+- BGE Reranker Large
+- BGE Reranker v2 M3
 
-and exposed through:
+## Retrieval Strategies
 
-GET /docpilot/models/
+- Dense
+- BM25
+- Hybrid
+- Hybrid + RRF
+- Hybrid + RRF + Reranking
 
-The frontend dynamically discovers available models from the backend.
+---
 
-This allows new models to be introduced without modifying frontend code.
+# Model Runtime
 
-## Currently Supported Models
+Models are managed through a centralized registry.
+
+Currently supported:
 
 - Llama 3.1 8B
 - Llama 3.3 70B
@@ -309,47 +282,59 @@ This allows new models to be introduced without modifying frontend code.
 - GPT OSS 20B
 - GPT OSS 120B
 
-Runtime model selection enables:
-
-- model benchmarking
-- latency comparisons
-- grounding comparisons
-- retrieval-consistent evaluations
+Runtime selection enables:
 
-because every model can be tested against identical retrieved evidence.
+- Latency comparisons
+- Grounding comparisons
+- Retrieval-consistent benchmarking
+- Comparative model evaluation
 
 ---
 
-# Retrieval Observability
+# TracePilot
 
-A primary goal of PilotMaster is retrieval introspection.
+TracePilot exposes the internal behavior of the system.
 
 ## Per-Chunk Diagnostics
 
-Every retrieved chunk can expose:
+Available metrics:
 
-- dense score
-- dense rank
-- BM25 score
-- BM25 rank
-- RRF score
-- reranker score
-- reranker confidence
-- reranker margin
-- final rank
-- retrieval provenance
+- Dense Score
+- Dense Rank
+- BM25 Score
+- BM25 Rank
+- RRF Score
+- Reranker Score
+- Reranker Confidence
+- Reranker Margin
+- Final Rank
+- Retrieval Provenance
+
+---
+
+## Retrieval Lineage
+
+Every chunk records where it originated:
+
+- Dense Retrieval
+- BM25 Retrieval
+- Hybrid Retrieval
+- RRF Fusion
+- Reranking
+
+This makes ranking behavior significantly easier to debug.
 
 ---
 
 ## Retrieval Agreement
 
-TracePilot identifies whether retrieval was:
+TracePilot determines whether retrieval was:
 
-- strong
-- semantic-dominant
-- lexical-dominant
+- Strong
+- Semantic-Dominant
+- Lexical-Dominant
 
-This makes retrieval behavior substantially easier to debug.
+Agreement analysis helps explain why a response succeeded or failed.
 
 ---
 
@@ -357,51 +342,54 @@ This makes retrieval behavior substantially easier to debug.
 
 Every execution can be replayed.
 
-This enables:
+Replay enables:
 
-- retrieval debugging
-- ranking inspection
-- evaluator comparison
-- regression testing
-- pipeline experimentation
+- Retrieval debugging
+- Regression testing
+- Evaluation comparison
+- Pipeline experimentation
+- Ranking inspection
 
 ---
 
-# Evaluation System
+# Evaluation Framework
 
 PilotMaster evaluates multiple dimensions of answer quality.
 
-Current metrics include:
+Current metrics:
 
 - Retrieval Quality
-- Grounding Confidence
+- Grounding
+- Faithfulness
+- Query Coverage
+- Retrieval Agreement
 - Answerability
 - Hallucination Risk
 
-Evaluation considers:
-
-- reranker confidence
-- reranker margin
-- retrieval agreement
-- retrieval lineage
+Evaluation incorporates:
 
-rather than relying exclusively on lexical overlap.
+- Retrieval confidence
+- Reranker confidence
+- Reranker margin
+- Retrieval agreement
+- Evidence quality
+- Retrieval lineage
 
 ---
 
 # Comparative Model Evaluation
 
-PilotMaster supports comparative evaluation across multiple models using identical retrieval context.
+Multiple models can be tested against identical retrieved evidence.
 
-Developers can analyze differences in:
+Developers can compare:
 
-- grounding
-- reasoning
-- latency
-- retrieval utilization
-- answer completeness
+- Grounding
+- Reasoning quality
+- Latency
+- Retrieval utilization
+- Answer completeness
 
-Because retrieval context remains constant, behavioral differences can be attributed primarily to the model rather than retrieval variance.
+Because retrieval context remains fixed, behavioral differences can be attributed primarily to model behavior.
 
 ---
 
@@ -409,53 +397,54 @@ Because retrieval context remains constant, behavioral differences can be attrib
 
 ## Retrieval
 
-- Dense retrieval
-- BM25 retrieval
-- Hybrid retrieval
+- Dense Retrieval
+- BM25 Retrieval
+- Hybrid Retrieval
 - Reciprocal Rank Fusion
-- Cross-encoder reranking
-- Retrieval lineage tracing
+- Cross-Encoder Reranking
+- Retrieval Lineage Tracking
 
 ## Observability
 
-- Replayable traces
-- Retrieval diagnostics
-- Chunk ranking inspection
-- Latency tracking
-- Span visualization
-- Confidence metrics
+- Replayable Traces
+- Retrieval Diagnostics
+- Ranking Inspection
+- Latency Tracking
+- Confidence Metrics
+- Evaluation Insights
 
-## Model Runtime
+## Runtime Controls
 
-- Runtime model selection
-- Dynamic model registry
-- Comparative model evaluation
+- Runtime Model Selection
+- Runtime Embedding Selection
+- Runtime Reranker Selection
+- Dynamic Model Registry
 
 ## Document Intelligence
 
-- OCR ingestion
+- OCR Ingestion
 - Grounded QA
-- Citation-aware responses
-- Multi-format document support
+- Citation-Aware Responses
+- Multi-Format Support
 
 ---
 
 # Research Directions
 
-PilotMaster has increasingly evolved into a retrieval engineering platform.
+Current focus areas:
 
-Current research focuses on:
+- Semantic Chunking
+- Query Rewriting
+- Query Expansion
+- Multi-Query Retrieval
+- Parent-Child Retrieval
+- Contextual Retrieval
+- Metadata-Aware Retrieval
+- Agentic Retrieval
 
-- semantic chunking
-- query rewriting
-- query expansion
-- multi-query retrieval
-- parent-child retrieval
-- contextual retrieval
-- metadata-aware retrieval
-- agentic retrieval
+Observation:
 
-Recent experiments suggest that retrieval quality is becoming a larger bottleneck than generation quality, making retrieval engineering the primary area of exploration.
+Retrieval quality increasingly appears to be a larger bottleneck than generation quality, making retrieval engineering a primary area of exploration.
 
 ---
 
@@ -463,33 +452,35 @@ Recent experiments suggest that retrieval quality is becoming a larger bottlenec
 
 ## Retrieval Engineering
 
-- Query rewriting
-- Query expansion
-- Multi-query retrieval
-- Parent-child retrieval
-- Contextual retrieval
-- Metadata-aware retrieval
-- Semantic chunking
-- Agentic retrieval
+- Query Rewriting
+- Query Expansion
+- Multi-Query Retrieval
+- Parent-Child Retrieval
+- Contextual Retrieval
+- Metadata-Aware Retrieval
+- Semantic Chunking
+- Agentic Retrieval
 
 ## Evaluation
 
-- Comparative model evaluation
-- Judge ensembles
-- Grounding regression testing
+- Comparative Evaluation
+- Judge Ensembles
+- Grounding Regression Testing
 
 ## Observability
 
-- Retrieval lineage visualization
-- Cross-run trace comparison
-- Advanced retrieval diagnostics
+- Cross-Run Comparisons
+- Retrieval Lineage Visualization
+- Advanced Diagnostics
 
-## Experimental Workspace
+## Experimentation
 
-- Runtime retrieval controls
-- Runtime enhancement controls
-- Retrieval A/B testing
-- Side-by-side retrieval comparisons
+- Retrieval A/B Testing
+- Embedding Benchmarks
+- Reranker Benchmarks
+- Side-by-Side Comparisons
+
+---
 
 # Tech Stack
 
@@ -501,8 +492,8 @@ Recent experiments suggest that retrieval quality is becoming a larger bottlenec
 | Vector Engine | FAISS                        |
 | Embeddings    | SentenceTransformers         |
 | Retrieval     | Dense + BM25 + RRF           |
-| Reranker      | Cross-Encoder MiniLM         |
-| LLM Runtime   | Groq Multi-Model Runtime     |
+| Reranking     | Cross-Encoder Models         |
+| Runtime       | Multi-Model Inference        |
 | Deployment    | Hugging Face Spaces + Vercel |
 
 ---
@@ -517,10 +508,12 @@ _Add screenshot_
 
 _Add screenshot_
 
-## Experimental Workspace
+## Research Workspace
 
 _Add screenshot_
 
+---
+
 # Local Setup
 
 ## Backend
@@ -543,51 +536,20 @@ npm run dev
 
 ---
 
-# Environment Variables
-
-```env
-GROQ_API_KEY=
-DATABASE_URL=
-SECRET_KEY=
-TRACEPILOT_URL=
-DOCPILOT_URL=
-```
-
----
-
-# Deployment
-
-## Frontend
-
-- Vercel
-- React + Vite
-
-## Backend
-
-- Hugging Face Spaces
-- Docker deployment
-- Unified FastAPI runtime
-
-## Database
-
-- Neon PostgreSQL
-
----
-
 # What Makes PilotMaster Different
 
 Most RAG systems expose only the final answer.
 
 PilotMaster exposes:
 
-- how retrieval behaved
-- why chunks ranked the way they did
-- whether retrievers agreed
-- how confident reranking was
-- how grounded the answer was
-- where hallucination risk emerged
-- how different models behave on identical context
-- how retrieval quality evolves over time
+- How retrieval behaved
+- Why chunks ranked the way they did
+- Whether retrievers agreed
+- How confident reranking was
+- How grounded the answer was
+- Where hallucination risk emerged
+- How different models behave on identical context
+- How retrieval quality evolves over time
 
 The goal is not simply AI generation.
 

frontend/src/gaugepilot/api.js

@@ -1,7 +1,7 @@
 import axios from "axios";
 
 const API = axios.create({
-  baseURL: "http://127.0.0.1:8000/docpilot",
+  baseURL: "http://127.0.0.1:8000/gaugepilot",
 });
 
 export async function runBenchmark(payload, token) {
@@ -15,5 +15,23 @@ export async function runBenchmark(payload, token) {
     }
   );
 
+  return response.data;
+}
+export async function uploadDocument(file, token) {
+  const formData = new FormData();
+
+  formData.append("file", file);
+
+  const response = await API.post(
+    "/docs/upload",
+    formData,
+    {
+      headers: {
+        Authorization: `Bearer ${token}`,
+        "Content-Type": "multipart/form-data",
+      },
+    }
+  );
+
   return response.data;
 }

frontend/src/gaugepilot/pages/ExperimentSetup.jsx

@@ -2,7 +2,10 @@ import { useState, useRef } from "react";
 import { useBenchmark } from "../hooks/useBenchmark";
 import Leaderboards from "./Leaderboards";
 import ExperimentSelector from "../components/ExperimentSelector";
-
+import {
+  runBenchmark,
+  uploadDocument,
+} from "../api";
 /*const SAMPLE_QUESTIONS = [
   "What is the main contribution of this paper?",
   "How does the proposed method compare to baselines?",
@@ -22,6 +25,7 @@ export default function ExperimentSetup() {
   const [isDragging, setIsDragging] = useState(false);
   const [isHoveringUpload, setIsHoveringUpload] = useState(false);
   const [isHoveringRun, setIsHoveringRun] = useState(false);
+  const [uploading, setUploading] = useState(false);
   const [benchmarkRuns, setBenchmarkRuns] = useState(0);
   const [bestScore, setBestScore] = useState(null);
   const fileInputRef = useRef(null);
@@ -48,7 +52,36 @@ export default function ExperimentSetup() {
     }
   };
 
-  const handleFileChange = (file) => { if (file) setUploadedFile(file); };
+  const handleFileChange = async (file) => {
+  if (!file) return;
+
+  try {
+    setUploading(true);
+
+    const token = localStorage.getItem("token");
+
+    await uploadDocument(
+      file,
+      token
+    );
+
+    setUploadedFile(file);
+
+    console.log(
+      "GaugePilot upload successful"
+    );
+  } catch (err) {
+    console.error(
+      "GaugePilot upload failed",
+      err
+    );
+  } finally {
+    setUploading(false);
+  }
+};
+
+
+
   const handleDrop = (e) => {
     e.preventDefault(); setIsDragging(false);
     handleFileChange(e.dataTransfer.files[0]);
@@ -214,42 +247,141 @@ export default function ExperimentSetup() {
               pointerEvents: "none",
             }} />
 
-            {uploadedFile ? (
-              <>
-                <div style={{
-                  width: 60, height: 60, borderRadius: "16px",
-                  background: "rgba(34,197,94,0.15)",
-                  display: "flex", alignItems: "center", justifyContent: "center", fontSize: "28px",
-                  boxShadow: "0 0 20px rgba(34,197,94,0.2)",
-                }}>✅</div>
-                <div style={{ textAlign: "center", zIndex: 1 }}>
-                  <p style={{ margin: 0, fontWeight: 700, fontSize: "15px", color: green }}>{uploadedFile.name}</p>
-                  <p style={{ margin: "4px 0 0", fontSize: "12px", color: "rgba(255,255,255,0.35)" }}>
-                    {(uploadedFile.size / 1024).toFixed(1)} KB · Click to replace
-                  </p>
-                </div>
-              </>
-            ) : (
-              <>
-                <div style={{
-                  width: 64, height: 64, borderRadius: "18px",
-                  background: isDragging ? `rgba(79,110,247,0.2)` : "rgba(79,110,247,0.1)",
-                  display: "flex", alignItems: "center", justifyContent: "center",
-                  fontSize: "28px", zIndex: 1,
-                  boxShadow: isDragging ? `0 0 24px rgba(79,110,247,0.3)` : "none",
-                  transition: "all 0.2s ease",
-                }}>⬆️</div>
-                <div style={{ textAlign: "center", zIndex: 1 }}>
-                  <p style={{ margin: 0, fontWeight: 700, fontSize: "16px", color: "white" }}>
-                    {isDragging ? "Drop to upload" : "Upload Document"}
-                  </p>
-                  <p style={{ margin: "5px 0 0", fontSize: "12px", color: "rgba(255,255,255,0.35)", lineHeight: 1.6 }}>
-                    Drag & drop or click to browse<br />
-                    <span style={{ color: "rgba(255,255,255,0.2)" }}>Any document format supported</span>
-                  </p>
-                </div>
-              </>
-            )}
+            {uploading ? (
+  <>
+    <div
+      style={{
+        width: 60,
+        height: 60,
+        borderRadius: "16px",
+        background: "rgba(79,110,247,0.15)",
+        display: "flex",
+        alignItems: "center",
+        justifyContent: "center",
+        fontSize: "28px",
+        boxShadow: "0 0 20px rgba(79,110,247,0.2)",
+      }}
+    >
+      ⏳
+    </div>
+
+    <div style={{ textAlign: "center", zIndex: 1 }}>
+      <p
+        style={{
+          margin: 0,
+          fontWeight: 700,
+          fontSize: "15px",
+          color: "#4f6ef7",
+        }}
+      >
+        Uploading & Indexing...
+      </p>
+
+      <p
+        style={{
+          margin: "4px 0 0",
+          fontSize: "12px",
+          color: "rgba(255,255,255,0.35)",
+        }}
+      >
+        Processing document
+      </p>
+    </div>
+  </>
+) : uploadedFile ? (
+  <>
+    <div
+      style={{
+        width: 60,
+        height: 60,
+        borderRadius: "16px",
+        background: "rgba(34,197,94,0.15)",
+        display: "flex",
+        alignItems: "center",
+        justifyContent: "center",
+        fontSize: "28px",
+        boxShadow: "0 0 20px rgba(34,197,94,0.2)",
+      }}
+    >
+      ✅
+    </div>
+
+    <div style={{ textAlign: "center", zIndex: 1 }}>
+      <p
+        style={{
+          margin: 0,
+          fontWeight: 700,
+          fontSize: "15px",
+          color: green,
+        }}
+      >
+        {uploadedFile.name}
+      </p>
+
+      <p
+        style={{
+          margin: "4px 0 0",
+          fontSize: "12px",
+          color: "rgba(255,255,255,0.35)",
+        }}
+      >
+        {(uploadedFile.size / 1024).toFixed(1)} KB · Click to replace
+      </p>
+    </div>
+  </>
+) : (
+  <>
+    <div
+      style={{
+        width: 64,
+        height: 64,
+        borderRadius: "18px",
+        background: isDragging
+          ? `rgba(79,110,247,0.2)`
+          : "rgba(79,110,247,0.1)",
+        display: "flex",
+        alignItems: "center",
+        justifyContent: "center",
+        fontSize: "28px",
+        zIndex: 1,
+        boxShadow: isDragging
+          ? `0 0 24px rgba(79,110,247,0.3)`
+          : "none",
+        transition: "all 0.2s ease",
+      }}
+    >
+      ⬆️
+    </div>
+
+    <div style={{ textAlign: "center", zIndex: 1 }}>
+      <p
+        style={{
+          margin: 0,
+          fontWeight: 700,
+          fontSize: "16px",
+          color: "white",
+        }}
+      >
+        {isDragging
+          ? "Drop to upload"
+          : "Upload Document"}
+      </p>
+
+      <p
+        style={{
+          margin: "5px 0 0",
+          fontSize: "12px",
+          color: "rgba(255,255,255,0.35)",
+          lineHeight: 1.6,
+        }}
+      >
+        Drag & drop or click to browse
+        <br />
+        
+      </p>
+    </div>
+  </>
+)}
           </div>
 
           {/* Benchmark Summary */}

main.py

@@ -3,6 +3,7 @@ from fastapi.middleware.cors import CORSMiddleware
 
 from DocPilot.backend.app.main import app as docpilot_app
 from TracePilot.backend.app.main import app as tracepilot_app
+from GaugePilot.backend.app.main import app as gaugepilot_app
 
 app = FastAPI(title="PilotMaster")
 
@@ -16,6 +17,7 @@ app.add_middleware(
 
 app.mount("/docpilot", docpilot_app)
 app.mount("/tracepilot", tracepilot_app)
+app.mount("/gaugepilot", gaugepilot_app)
 
 
 @app.get("/")