Update project structure and dependencies; switch to UV for dependency management and server execution

Author: rafaljanicki

.gitignore

@@ -1,4 +1,4 @@
-venv
+.venv
 */venv
 */.venv
 **/.env

Dockerfile

@@ -1,8 +1,9 @@
-FROM python:3.12-slim
+FROM ghcr.io/astral-sh/uv:python3.12-bookworm-slim
 
 ADD . /app
 WORKDIR /app
 
-RUN pip install -r requirements.txt
+# Install dependencies using UV
+RUN uv sync --frozen --no-dev
 
-CMD ["python", "src/sandbox_api_mcp_server/server.py"]
+CMD ["uv", "run", "sandbox-api-mcp-server"]

README.md

@@ -20,29 +20,30 @@ You can set these variables directly in your environment or place them in a `.en
 
 ## Running the Server
 
-1.  **Install dependencies:**
-    It's recommended to use a virtual environment.
+1.  **Install UV (if not already installed):**
     ```bash
-    python -m venv .venv
-    source .venv/bin/activate  # On Windows use `.venv\\Scripts\\activate`
-    pip install -r requirements.txt
-    # Or using uv
-    # uv pip install -r requirements.txt
-    ```
+    # macOS/Linux
+    curl -LsSf https://astral.sh/uv/install.sh | sh
 
-2.  **Set environment variables:**
-    Ensure the `.env` file is present in the `mcp-server` directory and populated with your Auth0 and Sandbox API credentials as described above.
+    # Windows
+    powershell -c "irm https://astral.sh/uv/install.ps1 | iex"
+    ```
 
-3.  **Run the FastAPI application:**
-    The server can be started using Uvicorn:
+2.  **Install dependencies:**
+    UV will automatically create a virtual environment and install dependencies:
     ```bash
-    uvicorn src.sandbox_api_mcp_server.server:run --factory --host 0.0.0.0 --port 9100
+    uv sync
     ```
-    Alternatively, if you have `src` in your `PYTHONPATH` or are in the `mcp-server` directory:
+
+3.  **Set environment variables:**
+    Ensure the `.env` file is present in the project root and populated with your Auth0 and Sandbox API credentials as described above.
+
+4.  **Run the FastAPI application:**
+    The server can be started using UV:
     ```bash
-    python src/sandbox_api_mcp_server/server.py
+    uv run sandbox-api-mcp-server
     ```
-    This will typically start the server on `http://0.0.0.0:9100`. The MCP endpoint will be available at `http://0.0.0.0:9100/sse` (as configured in `server.py`).
+    This will start the server on `http://0.0.0.0:9100`. The MCP endpoint will be available at `http://0.0.0.0:9100/sse` (as configured in `server.py`).
 
 ## Using with MCP Clients (e.g., Claude Desktop)
 
@@ -59,11 +60,7 @@ npm install -g mcp-remote
 
 Ensure your FastAPI MCP server is running locally (e.g., on `http://localhost:9100` with the MCP endpoint at `http://localhost:9100/sse`):
 ```bash
-python src/sandbox_api_mcp_server/server.py
-```
-Or using uvicorn directly:
-```bash
-uvicorn src.sandbox_api_mcp_server.server:run --factory --host 0.0.0.0 --port 9100
+uv run sandbox-api-mcp-server
 ```
 
 
@@ -244,9 +241,20 @@ The following tools are exposed, derived from the FastAPI application's endpoint
 
 ## Development
 
+### Project Structure
+
 *   The main FastAPI application logic is in `src/sandbox_api_mcp_server/server.py`.
 *   API routes (which become MCP tools) are defined in `src/sandbox_api_mcp_server/sandbox/routes.py`.
 *   Request/response models are primarily in `src/sandbox_api_mcp_server/sandbox/models.py` and `src/sandbox_api_mcp_server/models.py`.
 *   Authentication logic is in `src/sandbox_api_mcp_server/auth.py`.
-*   The project uses `uv` for dependency management (see `uv.lock`) and `pip` for installation (`requirements.txt`).
-*   Consider using `hatch` or `poetry` for more robust dependency management and packaging if distributing this server. (The `pyproject.toml` suggests `hatch` might be intended for future use).
+
+### Dependency Management
+
+This project uses [UV](https://docs.astral.sh/uv/) for fast, reliable dependency management:
+
+*   **Adding dependencies**: `uv add <package-name>`
+*   **Removing dependencies**: `uv remove <package-name>`
+*   **Updating dependencies**: `uv lock --upgrade`
+*   **Running scripts**: `uv run <command>`
+
+All dependencies are defined in `pyproject.toml` and locked in `uv.lock` for reproducible builds.

pyproject.toml

@@ -14,10 +14,13 @@ authors = [
     { name = "Rafal Janicki", email = "[email protected]" }
 ]
 dependencies = [
-    "fastmcp>=2.5.1",
-    "python-dotenv>=1.1.0",
-    "httpx>=0.28.1",
-    "pydantic>=2.11.4",
+    "cryptography~=45.0.0",
+    "fastapi-mcp>=0.3.3",
+    "httpx>=0.28.1,<1.0.0",
+    "PyJWT>=2.10.1,<3.0.0",
+    "python-dotenv>=1.1.0,<2.0.0",
+    "pydantic>=2.11.4,<3.0.0",
+    "uvicorn>=0.30.0,<1.0.0",
 ]
 classifiers = [
     "Programming Language :: Python :: 3",

requirements.txt

@@ -2,11 +2,11 @@
 import json
 from cryptography.hazmat.primitives.asymmetric.rsa import RSAPublicKey
 from cryptography.hazmat.primitives import serialization
-from helpers import get_logger
+from .helpers import get_logger
 from jwt.algorithms import RSAAlgorithm
 from fastapi import Request, HTTPException, status
 from typing import Any
-from models import Auth0Settings
+from .models import Auth0Settings
 
 logger = get_logger(__name__)
 

src/sandbox_api_mcp_server/auth.py

@@ -5,7 +5,7 @@
 from fastapi.responses import PlainTextResponse
 
 from .models import StartSandboxBody, StopSandboxBody, ExtendSandboxBody, AuraUploadBody, BackupDownloadUrlBody, FastApiReadCypherQueryBody, FastApiWriteCypherQueryBody
-from helpers import get_logger
+from ..helpers import get_logger
 from .service import call_sandbox_api, SandboxApiClient, get_sandbox_client
 
 logger = get_logger(__name__)

src/sandbox_api_mcp_server/sandbox/routes.py

@@ -5,8 +5,8 @@
 from typing import Annotated, Optional, Dict, Any
 from fastapi import HTTPException, status, Depends
 
-from auth import verify_auth
-from helpers import get_logger
+from ..auth import verify_auth
+from ..helpers import get_logger
 from .models import FastApiReadCypherQueryResponse
 
 MAX_RETRIES = 3

src/sandbox_api_mcp_server/sandbox/service.py

@@ -1,17 +1,18 @@
 import os
 import uvicorn
 
+from anyio import get_cancelled_exc_class
 from contextlib import asynccontextmanager
 from dotenv import load_dotenv
 from fastapi import FastAPI, Depends
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi_mcp import AuthConfig, FastApiMCP
 from uvicorn._types import ASGI3Application, ASGIReceiveCallable, ASGISendCallable, Scope
 from starlette.middleware.base import BaseHTTPMiddleware
-from auth import fetch_jwks_public_key, verify_auth
-from models import Auth0Settings
-from sandbox.routes import get_sandbox_api_router
-from helpers import get_logger
+from .auth import fetch_jwks_public_key, verify_auth
+from .models import Auth0Settings
+from .sandbox.routes import get_sandbox_api_router
+from .helpers import get_logger
 
 logger = get_logger(__name__)
 
@@ -71,6 +72,23 @@ async def dispatch(self, request, call_next):
         return response
 
 
+def close_on_double_start(app):
+    async def wrapped(scope, receive, send):
+        start_sent = False
+
+        async def check_send(message):
+            nonlocal start_sent
+            if message["type"] == "http.response.start":
+                if start_sent:
+                    raise get_cancelled_exc_class()()
+                start_sent = True
+            await send(message)
+
+        await app(scope, receive, check_send)
+
+    return wrapped
+
+
 def run():
     app = FastAPI(title="SandboxApiMCP", lifespan=lifespan)
     app.include_router(get_sandbox_api_router())