HTTP + SSE Transport — Remote MCP Servers

# document_server_http.py — same 3 tools as MCP01, HTTP transport added
from __future__ import annotations
import math
import os
from mcp.server.fastmcp import FastMCP

# ── All configuration via environment variables ──
PORT = int(os.getenv("MCP_PORT", "8000"))
HOST = os.getenv("MCP_HOST", "0.0.0.0")  # 0.0.0.0 required for Docker

mcp = FastMCP(
    "document-server",
    # Stateless mode is ideal for multi-client HTTP servers.
    # Each request is independent — no session state carried between calls.
    stateless_http=True,
)

# ── In-memory document store (same as MCP01) ──
DOCUMENTS: dict[str, str] = {
    "mcp-overview": "MCP is an open protocol for connecting AI to tools.",
    "fastmcp-guide": "FastMCP reduces MCP server boilerplate with decorators.",
    "transport-docs": "stdio is local; HTTP/SSE is for shared, remote servers.",
}
NOTES: dict[str, str] = {}


@mcp.tool()
def search_documents(query: str, limit: int = 5) -> list[dict]:
    """Search the document store for documents matching a query string."""
    if not query or not query.strip():
        raise ValueError("query must be a non-empty string")
    if limit < 1 or limit > 50:
        raise ValueError("limit must be between 1 and 50")
    q = query.lower()
    results = []
    for doc_id, content in DOCUMENTS.items():
        score = (2 if q in doc_id.lower() else 0) + (1 if q in content.lower() else 0)
        if score > 0:
            results.append({"id": doc_id, "preview": content[:120], "score": score})
    results.sort(key=lambda r: r["score"], reverse=True)
    return results[:limit]


@mcp.tool()
def calculate_similarity(text_a: str, text_b: str) -> dict:
    """Calculate cosine similarity between two texts using word overlap."""
    if not text_a or not text_b:
        raise ValueError("Both text_a and text_b must be non-empty")
    def freq(t: str) -> dict:
        d: dict = {}
        for w in t.lower().split():
            w = w.strip(".,!?;:")
            if w: d[w] = d.get(w, 0) + 1
        return d
    fa, fb = freq(text_a), freq(text_b)
    words = set(fa) | set(fb)
    dot = sum(fa.get(w,0)*fb.get(w,0) for w in words)
    mag = (math.sqrt(sum(v**2 for v in fa.values())) *
           math.sqrt(sum(v**2 for v in fb.values())))
    sim = round(dot/mag, 4) if mag else 0.0
    return {"similarity": sim, "common_words": sorted(set(fa)&set(fb))[:10],
            "interpretation": "highly similar" if sim>0.7 else "somewhat related" if sim>0.3 else "largely different"}


@mcp.tool()
def save_note(title: str, content: str) -> dict:
    """Save a note. Notes persist for the server process lifetime."""
    if not title or len(title) > 100:
        raise ValueError("title must be 1–100 characters")
    if not content or len(content) > 5000:
        raise ValueError("content must be 1–5000 characters")
    NOTES[title.strip()] = content
    return {"success": True, "title": title.strip(), "total_notes": len(NOTES)}


# ── Health check endpoint (required for Docker / cloud health probes) ──
@mcp.custom_server.get("/health")
async def health():
    return {"status": "ok", "server": "document-server", "tools": 3}


if __name__ == "__main__":
    # stdio (MCP01 style):
    #   mcp.run()

    # HTTP/SSE — change is here only, tools are untouched:
    mcp.run(transport="streamable-http", host=HOST, port=PORT)
    # Server now exposes:
    #   POST http://HOST:PORT/mcp     — JSON-RPC messages
    #   GET  http://HOST:PORT/sse     — SSE event stream
    #   GET  http://HOST:PORT/health  — health check

# auth_middleware.py — Bearer token auth for FastMCP HTTP server
# pip install fastapi python-jose[cryptography] uvicorn
from __future__ import annotations

import os
import time
from typing import Annotated

from fastapi import Depends, FastAPI, HTTPException, Request, Security
from fastapi.security import HTTPAuthorizationCredentials, HTTPBearer
from jose import JWTError, jwt

SECRET_KEY = os.environ["JWT_SECRET"]          # set in env, never hardcode
ALGORITHM = "HS256"
TOKEN_EXPIRE_SECONDS = 3600

app = FastAPI()
bearer_scheme = HTTPBearer()


# ── Token issuance (dev/test only — replace with real IdP in production) ──
@app.post("/token")
async def issue_token(client_id: str, scope: str = "mcp:read"):
    """
    Issue a JWT for development.
    scope values: "mcp:read"  — can only list tools
                  "mcp:write" — can list + call tools
    In production: use Auth0 / AWS Cognito / Google IAM here instead.
    """
    allowed_scopes = {"mcp:read", "mcp:write"}
    if scope not in allowed_scopes:
        raise HTTPException(400, f"Invalid scope. Allowed: {allowed_scopes}")

    payload = {
        "sub": client_id,
        "scope": scope,
        "iat": int(time.time()),
        "exp": int(time.time()) + TOKEN_EXPIRE_SECONDS,
    }
    token = jwt.encode(payload, SECRET_KEY, algorithm=ALGORITHM)
    return {"access_token": token, "token_type": "bearer", "expires_in": TOKEN_EXPIRE_SECONDS}


# ── Token validation dependency ──
def verify_token(
    credentials: Annotated[HTTPAuthorizationCredentials, Security(bearer_scheme)]
) -> dict:
    """FastAPI dependency: validate the Bearer token and return the payload."""
    try:
        payload = jwt.decode(credentials.credentials, SECRET_KEY, algorithms=[ALGORITHM])
    except JWTError as exc:
        raise HTTPException(
            status_code=401,
            detail=f"Invalid or expired token: {exc}",
            headers={"WWW-Authenticate": "Bearer"},
        )
    return payload


# ── Scope-based restriction dependency ──
def require_write_scope(token_payload: Annotated[dict, Depends(verify_token)]) -> dict:
    """Only allow clients with mcp:write scope to mutate state."""
    if "mcp:write" not in token_payload.get("scope", ""):
        raise HTTPException(
            status_code=403,
            detail="This operation requires mcp:write scope",
        )
    return token_payload


# ── Protected MCP endpoint ──
from mcp.server.fastmcp import FastMCP

mcp = FastMCP("document-server", stateless_http=True)

# Attach FastMCP to FastAPI — both share the same app
# Requests to /mcp and /sse are guarded by verify_token
@app.post("/mcp")
async def mcp_post(request: Request, _tok: Annotated[dict, Depends(verify_token)]):
    return await mcp.handle_streamable_http(request)


@app.get("/sse")
async def mcp_sse(request: Request, _tok: Annotated[dict, Depends(verify_token)]):
    return await mcp.handle_sse(request)


@app.get("/health")
async def health():
    return {"status": "ok"}


# ── Tools (same as before, write tool checks write scope) ──
@mcp.tool()
async def save_note_authed(
    title: str, content: str, request: Request
) -> dict:
    """Save a note (requires mcp:write scope)."""
    # Extract token from request headers and check scope
    auth = request.headers.get("Authorization", "")
    if not auth.startswith("Bearer "):
        raise PermissionError("Authorization header required")
    token_str = auth.removeprefix("Bearer ")
    try:
        payload = jwt.decode(token_str, SECRET_KEY, algorithms=[ALGORITHM])
    except JWTError:
        raise PermissionError("Invalid token")
    if "mcp:write" not in payload.get("scope", ""):
        raise PermissionError("mcp:write scope required to save notes")
    NOTES[title.strip()] = content
    return {"success": True, "title": title.strip()}


NOTES: dict[str, str] = {}

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)

# ── Stage 1: dependency installation ──
FROM python:3.12-slim AS builder
WORKDIR /build

# Copy and install dependencies first (layer caches if requirements unchanged)
COPY requirements.txt .
RUN pip install --no-cache-dir --prefix=/install -r requirements.txt

# ── Stage 2: minimal runtime image ──
FROM python:3.12-slim
WORKDIR /app

# Copy installed packages from builder stage
COPY --from=builder /install /usr/local

# Copy application code
COPY document_server_http.py .
# If you added auth_middleware.py, copy it too:
# COPY auth_middleware.py .

# Expose the server port (documentation only — does not publish the port)
EXPOSE 8000

# Health check: cloud platforms probe this endpoint every 10s
# If it fails 3 times in a row, the container is restarted
HEALTHCHECK --interval=10s --timeout=5s --retries=3 \
  CMD python -c "import urllib.request; urllib.request.urlopen('http://localhost:8000/health')" \
  || exit 1

# Secrets via environment variables (never hardcode here)
# Set at runtime: docker run -e JWT_SECRET=... -e MCP_PORT=8000
ENV MCP_HOST=0.0.0.0
ENV MCP_PORT=8000

# Run as non-root user (security best practice)
RUN useradd -m mcpuser && chown -R mcpuser /app
USER mcpuser

CMD ["python", "document_server_http.py"]

# Add to your FastAPI app (or FastMCP's underlying Starlette app)
import os
from fastapi.middleware.cors import CORSMiddleware

# Read allowed origins from environment variable (comma-separated)
# Example: ALLOWED_ORIGINS=https://app.example.com,https://staging.example.com
raw_origins = os.getenv("ALLOWED_ORIGINS", "http://localhost:3000")
ALLOWED_ORIGINS = [o.strip() for o in raw_origins.split(",") if o.strip()]

# For FastMCP, access the underlying Starlette app:
# mcp._app is the Starlette app FastMCP wraps
fastapi_app = mcp.streamable_http_app()

fastapi_app.add_middleware(
    CORSMiddleware,
    allow_origins=ALLOWED_ORIGINS,     # specific origins only, never "*"
    allow_credentials=True,            # required for Authorization header
    allow_methods=["GET", "POST", "DELETE", "OPTIONS"],
    allow_headers=["Authorization", "Content-Type", "X-Session-Id"],
    max_age=3600,                      # preflight cache TTL in seconds
)

# Example CORS headers sent to an allowed origin:
# Access-Control-Allow-Origin: https://app.example.com
# Access-Control-Allow-Credentials: true
# Access-Control-Allow-Methods: GET, POST, DELETE, OPTIONS
# Access-Control-Allow-Headers: Authorization, Content-Type, X-Session-Id

# Example: blocking an unrecognized origin
# Browser sends: Origin: https://evil.example.com
# Server responds with NO Access-Control-Allow-Origin header
# Browser: blocks the response, logs "CORS error"

{
  "mcpServers": {
    "my-remote-server": {
      "url": "http://localhost:8000/sse",
      "headers": {
        "Authorization": "Bearer YOUR_TOKEN_HERE"
      }
    }
  }
}

// For a deployed server (replace with your actual URL):
// {
//   "mcpServers": {
//     "my-remote-server": {
//       "url": "https://mcp.example.com/sse",
//       "headers": {
//         "Authorization": "Bearer eyJhbGciOiJIUzI1NiJ9..."
//       }
//     }
//   }
// }

// macOS config path:
//   ~/Library/Application Support/Claude/claude_desktop_config.json
// Windows:
//   %APPDATA%\Claude\claude_desktop_config.json

app = "mcp-document-server"
primary_region = "lax"

[build]
  dockerfile = "Dockerfile"

[env]
  MCP_PORT = "8080"            # Fly uses 8080 internally
  MCP_HOST = "0.0.0.0"
  ALLOWED_ORIGINS = "https://yourapp.example.com"
  # JWT_SECRET set via: fly secrets set JWT_SECRET=...

[[services]]
  internal_port = 8080
  protocol = "tcp"

  [[services.ports]]
    port = 443
    handlers = ["tls", "http"]    # TLS termination by Fly

  [[services.http_checks]]
    path = "/health"
    interval = "10s"
    timeout = "5s"