refactor: http not working

api.py

@@ -1,14 +1,14 @@
+# api.py
 from __future__ import annotations
 import os
 import json
 import logging
 import time
+import shutil
 
 from models import OptimizeRequest, QARequest, AutotuneRequest
 from fastapi import FastAPI, HTTPException, UploadFile, File, Form
 from fastapi.middleware.cors import CORSMiddleware
-import uvicorn
-import shutil
 
 try:
     from ragmint.autotuner import AutoRAGTuner
@@ -33,7 +33,7 @@ load_dotenv()
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger("ragmint_mcp_server")
 
-# FastAPI
+# FastAPI app (exported for mounting)
 app = FastAPI(title="Ragmint MCP Server", version="0.1.0")
 app.add_middleware(
     CORSMiddleware,
@@ -43,10 +43,13 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
-DEFAULT_DATA_DIR = "../data/docs"
+# Use repo-local data folder (not parent dirs)
+DEFAULT_DATA_DIR = "data/docs"
 LEADERBOARD_STORAGE = "experiments/leaderboard.jsonl"
-os.makedirs("../experiments", exist_ok=True)
 
+# ensure folders exist
+os.makedirs(DEFAULT_DATA_DIR, exist_ok=True)
+os.makedirs("experiments", exist_ok=True)
 
 @app.get("/health")
 def health():
@@ -56,39 +59,31 @@ def health():
         "import_error": str(_import_error) if _import_error else None,
     }
 
-
 @app.post("/upload_docs")
 async def upload_docs(
-    docs_path: str = Form(...),  # User specifies folder
+    docs_path: str = Form(...),
     files: list[UploadFile] = File(...)
 ):
-    os.makedirs(docs_path, exist_ok=True)  # create folder if missing
+    os.makedirs(docs_path, exist_ok=True)
     saved_files = []
-
     for file in files:
         file_path = os.path.join(docs_path, file.filename)
         with open(file_path, "wb") as f:
             shutil.copyfileobj(file.file, f)
         saved_files.append(file.filename)
-
     return {"status": "ok", "uploaded_files": saved_files, "docs_path": docs_path}
 
 @app.post("/optimize_rag")
 def optimize_rag(req: OptimizeRequest):
     logger.info("Received optimize_rag request: %s", req.json())
-
     if RAGMint is None:
-        raise HTTPException(
-            status_code=500,
-            detail=f"Ragmint imports failed or RAGMint unavailable: {_import_error}"
-        )
+        raise HTTPException(status_code=500, detail=f"Ragmint imports failed: {_import_error}")
 
     docs_path = req.docs_path or DEFAULT_DATA_DIR
     if not os.path.isdir(docs_path):
         raise HTTPException(status_code=400, detail=f"docs_path does not exist: {docs_path}")
 
     try:
-        # Build RAGMint exactly from request
         rag = RAGMint(
             docs_path=docs_path,
             retrievers=req.retriever,
@@ -99,12 +94,11 @@ def optimize_rag(req: OptimizeRequest):
             strategies=req.strategy,
         )
 
-        # Validation selection
+        # validation set handling
         validation_set = None
         validation_choice = (req.validation_choice or "").strip()
         default_val_path = os.path.join(docs_path, "validation_qa.json")
 
-        # Auto
         if not validation_choice:
             if os.path.exists(default_val_path):
                 validation_set = default_val_path
@@ -112,33 +106,22 @@ def optimize_rag(req: OptimizeRequest):
             else:
                 logger.warning("No validation_choice provided and no default found.")
                 validation_set = None
-
-        # Remote HF dataset
         elif "/" in validation_choice and not os.path.exists(validation_choice):
             validation_set = validation_choice
-            logger.info("Using Hugging Face validation dataset: %s", validation_set)
-
-        # Local file
+            logger.info("Using HF dataset as validation: %s", validation_set)
         elif os.path.exists(validation_choice):
             validation_set = validation_choice
             logger.info("Using local validation dataset: %s", validation_set)
-
-        # Generate
         elif validation_choice.lower() == "generate":
-            try:
-                gen_path = os.path.join(docs_path, "validation_qa.json")
-                generate_validation_qa(
-                    docs_path=docs_path,
-                    output_path=gen_path,
-                    llm_model=req.llm_model if hasattr(req, "llm_model") else "gemini-2.5-flash-lite"
-                )
-                validation_set = gen_path
-                logger.info("Generated new validation QA set at: %s", validation_set)
-            except Exception as e:
-                logger.exception("Failed to generate validation QA dataset: %s", e)
-                raise HTTPException(status_code=500, detail=f"Failed to generate validation QA dataset: {e}")
+            gen_path = os.path.join(docs_path, "validation_qa.json")
+            generate_validation_qa(
+                docs_path=docs_path,
+                output_path=gen_path,
+                llm_model=req.llm_model if hasattr(req, "llm_model") else "gemini-2.5-flash-lite"
+            )
+            validation_set = gen_path
+            logger.info("Generated validation QA at: %s", validation_set)
 
-        # Optimize
         start_time = time.time()
         best, results = rag.optimize(
             validation_set=validation_set,
@@ -147,10 +130,8 @@ def optimize_rag(req: OptimizeRequest):
             search_type=req.search_type
         )
         elapsed = time.time() - start_time
-
         run_id = f"opt_{int(time.time())}"
 
-        # Corpus stats
         try:
             corpus_stats = {
                 "num_docs": len(rag.documents),
@@ -160,7 +141,6 @@ def optimize_rag(req: OptimizeRequest):
         except Exception:
             corpus_stats = None
 
-        # Leaderboard
         try:
             if Leaderboard:
                 lb = Leaderboard()
@@ -193,12 +173,8 @@ def optimize_rag(req: OptimizeRequest):
 @app.post("/autotune_rag")
 def autotune_rag(req: AutotuneRequest):
     logger.info("Received autotune_rag request: %s", req.json())
-
     if AutoRAGTuner is None or RAGMint is None:
-        raise HTTPException(
-            status_code=500,
-            detail=f"Ragmint autotuner/RAGMint imports failed: {_import_error}"
-        )
+        raise HTTPException(status_code=500, detail=f"Ragmint autotuner/RAGMint imports failed: {_import_error}")
 
     docs_path = req.docs_path or DEFAULT_DATA_DIR
     if not os.path.isdir(docs_path):
@@ -206,12 +182,8 @@ def autotune_rag(req: AutotuneRequest):
 
     try:
         start_time = time.time()
-
         tuner = AutoRAGTuner(docs_path=docs_path)
-        rec = tuner.recommend(
-            embedding_model=req.embedding_model,
-            num_chunk_pairs=req.num_chunk_pairs
-        )
+        rec = tuner.recommend(embedding_model=req.embedding_model, num_chunk_pairs=req.num_chunk_pairs)
 
         chunk_candidates = tuner.suggest_chunk_sizes(
             model_name=rec.get("embedding_model"),
@@ -232,39 +204,27 @@ def autotune_rag(req: AutotuneRequest):
             strategies=[rec["strategy"]],
         )
 
-        # Validation selection
         validation_set = None
         validation_choice = (req.validation_choice or "").strip()
         default_val_path = os.path.join(docs_path, "validation_qa.jsonl")
-
         if not validation_choice:
             if os.path.exists(default_val_path):
                 validation_set = default_val_path
-                logger.info("Using default validation set: %s", validation_set)
             else:
-                logger.warning("No validation_choice provided and no default found.")
                 validation_set = None
-
         elif "/" in validation_choice and not os.path.exists(validation_choice):
             validation_set = validation_choice
-
         elif os.path.exists(validation_choice):
             validation_set = validation_choice
-
         elif validation_choice.lower() == "generate":
-            try:
-                gen_path = os.path.join(docs_path, "validation_qa.json")
-                generate_validation_qa(
-                    docs_path=docs_path,
-                    output_path=gen_path,
-                    llm_model=req.llm_model if hasattr(req, "llm_model") else "gemini-2.5-flash-lite",
-                )
-                validation_set = gen_path
-            except Exception as e:
-                logger.exception("Failed to generate validation QA dataset: %s", e)
-                raise HTTPException(status_code=500, detail=f"Failed to generate validation QA dataset: {e}")
+            gen_path = os.path.join(docs_path, "validation_qa.json")
+            generate_validation_qa(
+                docs_path=docs_path,
+                output_path=gen_path,
+                llm_model=req.llm_model if hasattr(req, "llm_model") else "gemini-2.5-flash-lite",
+            )
+            validation_set = gen_path
 
-        # Full optimize
         best, results = rag.optimize(
             validation_set=validation_set,
             metric=req.metric,
@@ -272,10 +232,8 @@ def autotune_rag(req: AutotuneRequest):
             trials=req.trials,
         )
         elapsed = time.time() - start_time
-
         run_id = f"autotune_{int(time.time())}"
 
-        # Corpus stats
         try:
             corpus_stats = {
                 "num_docs": len(rag.documents),
@@ -285,7 +243,6 @@ def autotune_rag(req: AutotuneRequest):
         except Exception:
             corpus_stats = None
 
-        # Leaderboard
         try:
             if Leaderboard:
                 lb = Leaderboard()
@@ -320,12 +277,11 @@ def autotune_rag(req: AutotuneRequest):
 @app.post("/generate_validation_qa")
 def generate_qa(req: QARequest):
     logger.info("Received generate_validation_qa request: %s", req.json())
-
     if generate_validation_qa is None:
         raise HTTPException(status_code=500, detail=f"Ragmint imports failed: {_import_error}")
 
     try:
-        out_path = f"data/docs/validation_qa.json"
+        out_path = os.path.join("data", "docs", "validation_qa.json")
         os.makedirs(os.path.dirname(out_path), exist_ok=True)
 
         generate_validation_qa(
@@ -340,25 +296,14 @@ def generate_qa(req: QARequest):
         with open(out_path, "r", encoding="utf-8") as f:
             data = json.load(f)
 
-        return {
-            "status": "finished",
-            "output_path": out_path,
-            "preview_count": len(data),
-            "sample": data[:5],
-        }
+        return {"status": "finished", "output_path": out_path, "preview_count": len(data), "sample": data[:5]}
 
     except Exception as exc:
         logger.exception("generate_validation_qa failed")
         raise HTTPException(status_code=500, detail=str(exc))
 
 
-# -----------------------
-# FastAPI launch
-# -----------------------
-
-def main():
-    uvicorn.run(app, host="0.0.0.0", port=8000, log_level="info")
-
-
+# only run uvicorn if script is executed directly
 if __name__ == "__main__":
-    main()
+    import uvicorn as _uvicorn
+    _uvicorn.run(app, host="0.0.0.0", port=7860, log_level="info")

app.py

@@ -1,122 +1,88 @@
+# app.py
 import gradio as gr
 import requests
 import json
-from models import OptimizeRequest, AutotuneRequest, QARequest
 import os
-import threading
+import shutil
 import uvicorn
-from api import app as fastapi_app
-
-API_URL = "http://127.0.0.1:7861"
-
-def start_fastapi():
-    uvicorn.run(fastapi_app, host="0.0.0.0", port=7861, log_level="info")
+from models import OptimizeRequest, AutotuneRequest, QARequest
+from api import app as backend_app  # import the FastAPI app we just saved
 
-# Start FastAPI in a background thread
-threading.Thread(target=start_fastapi, daemon=True).start()
+# Base URL for internal calls (same process)
+BASE_INTERNAL = "http://127.0.0.1:7860"
 
-# -------------------------------
-# Helper to call API
-# -------------------------------
 def call_api(endpoint: str, payload: dict) -> str:
     try:
-        r = requests.post(f"{API_URL}/{endpoint}", json=payload)
+        r = requests.post(f"{BASE_INTERNAL}{endpoint}", json=payload, timeout=120)
         return json.dumps(r.json(), indent=2)
     except Exception as e:
         return str(e)
 
-
-# -------------------------------
-# MCP Tool Wrappers
-# -------------------------------
 def upload_docs_tool(files, docs_path="data/docs"):
-
     os.makedirs(docs_path, exist_ok=True)
-    uploaded_files = []
-
-    for file_path in files:
-        filename = os.path.basename(file_path)
-        dest_path = os.path.join(docs_path, filename)
-        import shutil
-        shutil.copy(file_path, dest_path)
-        uploaded_files.append(filename)
-
-    return {"status": "ok", "uploaded_files": uploaded_files, "docs_path": docs_path}
-
+    saved = []
+    for f in files:
+        fname = os.path.basename(f)
+        dest = os.path.join(docs_path, fname)
+        shutil.copy(f, dest)
+        saved.append(fname)
+    return {"status": "ok", "uploaded_files": saved, "docs_path": docs_path}
 
 def optimize_rag_tool(payload: str) -> str:
-    return call_api("optimize_rag", json.loads(payload))
-
+    return call_api("/optimize_rag", json.loads(payload))
 
 def autotune_tool(payload: str) -> str:
-    return call_api("autotune_rag", json.loads(payload))
-
+    return call_api("/autotune_rag", json.loads(payload))
 
 def generate_qa_tool(payload: str) -> str:
-    return call_api("generate_validation_qa", json.loads(payload))
-
+    return call_api("/generate_validation_qa", json.loads(payload))
 
-# -------------------------------
-# Generate default JSON for models
-# -------------------------------
 def model_to_json(model_cls) -> str:
-    defaults = {k: v.default for k, v in model_cls.__fields__.items()}
-    return json.dumps(defaults, indent=2)
+    return json.dumps({k: v.default for k, v in model_cls.__fields__.items()}, indent=2)
 
-
-# Default payloads
 DEFAULT_UPLOAD_PATH = "data/docs"
-DEFAULT_UPLOAD_FILES = []  # No files by default
 DEFAULT_OPTIMIZE_JSON = model_to_json(OptimizeRequest)
 DEFAULT_AUTOTUNE_JSON = model_to_json(AutotuneRequest)
 DEFAULT_QA_JSON = model_to_json(QARequest)
 
-# -------------------------------
-# Build Gradio interface
-# -------------------------------
 with gr.Blocks(theme=gr.themes.Soft()) as demo:
-    gr.Markdown("# Ragmint MCP Client")
-
-    # Upload files section
+    gr.Markdown("# Ragmint MCP Client (UI)")
     with gr.Column():
-        gr.Markdown("## Upload Documents\nUpload files to a folder on the server.")
-        upload_files = gr.File(
-            file_types=[".txt", ".md", ".pdf"],  # allowed extensions
-            file_count="multiple",  # allow multiple files
-            type="filepath",  # returns local file path
-            label="Drag & Drop Files"
-        )
+        gr.Markdown("## Upload Documents")
+        upload_files = gr.File(file_count="multiple", type="filepath")
         upload_path = gr.Textbox(value=DEFAULT_UPLOAD_PATH, label="Docs Path")
-        upload_btn = gr.Button("Upload",variant='primary')
-        upload_output = gr.Textbox(label="Response")
-        upload_btn.click(upload_docs_tool, inputs=[upload_files, upload_path], outputs=upload_output)
+        upload_btn = gr.Button("Upload", variant="primary")
+        upload_out = gr.Textbox()
+        upload_btn.click(upload_docs_tool, inputs=[upload_files, upload_path], outputs=upload_out)
         gr.Markdown("---")
 
-    # Optimize RAG
     with gr.Column():
-        gr.Markdown("## Optimize RAG\nRun full RAG optimization with custom parameters.")
+        gr.Markdown("## Optimize RAG")
         optimize_input = gr.Textbox(lines=12, value=DEFAULT_OPTIMIZE_JSON, label="OptimizeRequest JSON")
-        optimize_btn = gr.Button("Submit",variant='primary')
-        optimize_output = gr.Textbox(lines=15, label="Response")
-        optimize_btn.click(optimize_rag_tool, inputs=optimize_input, outputs=optimize_output)
+        optimize_btn = gr.Button("Submit", variant="primary")
+        optimize_out = gr.Textbox(lines=15)
+        optimize_btn.click(optimize_rag_tool, inputs=optimize_input, outputs=optimize_out)
         gr.Markdown("---")
 
-    # Autotune RAG
     with gr.Column():
-        gr.Markdown("## Autotune RAG\nRun AutoRAG tuner and full optimization.")
+        gr.Markdown("## Autotune RAG")
         autotune_input = gr.Textbox(lines=12, value=DEFAULT_AUTOTUNE_JSON, label="AutotuneRequest JSON")
-        autotune_btn = gr.Button("Submit",variant='primary')
-        autotune_output = gr.Textbox(lines=15, label="Response")
-        autotune_btn.click(autotune_tool, inputs=autotune_input, outputs=autotune_output)
+        autotune_btn = gr.Button("Submit", variant="primary")
+        autotune_out = gr.Textbox(lines=15)
+        autotune_btn.click(autotune_tool, inputs=autotune_input, outputs=autotune_out)
         gr.Markdown("---")
 
-    # Generate QA
     with gr.Column():
-        gr.Markdown("## Generate QA\nGenerate validation QA dataset from documents.")
+        gr.Markdown("## Generate QA")
         qa_input = gr.Textbox(lines=12, value=DEFAULT_QA_JSON, label="QARequest JSON")
-        qa_btn = gr.Button("Submit",variant='primary')
-        qa_output = gr.Textbox(lines=15, label="Response")
-        qa_btn.click(generate_qa_tool, inputs=qa_input, outputs=qa_output)
+        qa_btn = gr.Button("Submit", variant="primary")
+        qa_out = gr.Textbox(lines=15)
+        qa_btn.click(generate_qa_tool, inputs=qa_input, outputs=qa_out)
         gr.Markdown("---")
 
-demo.launch(mcp_server=True)
+# mount the Gradio app on FastAPI at root ("/")
+gr.mount_gradio_app(backend_app, demo, path="/")
+
+# When run directly, serve with uvicorn (HF will run this)
+if __name__ == "__main__":
+    uvicorn.run(backend_app, host="0.0.0.0", port=7860, log_level="info")

server.py

@@ -1,7 +0,0 @@
-import threading
-from api import main
-
-def start():
-    threading.Thread(target=main, daemon=True).start()
-
-start()