deployml-core 0.0.58__tar.gz → 0.0.60__tar.gz

deployml_core-0.0.60/PKG-INFO

@@ -0,0 +1,117 @@
+Metadata-Version: 2.4
+Name: deployml-core
+Version: 0.0.60
+Summary: Infra for academia
+License-File: LICENSE
+Author: Drew Hoang
+Author-email: codentell@gmail.com
+Requires-Python: >=3.11
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: google-cloud-storage (>=3.1.1,<4.0.0)
+Requires-Dist: ipython (>=9.0.0)
+Requires-Dist: jinja2
+Requires-Dist: jupyter (>=1.0.0)
+Requires-Dist: pandas (>=2.2.1)
+Requires-Dist: pyyaml
+Requires-Dist: requests (>=2.28.0)
+Requires-Dist: rich
+Requires-Dist: typer
+Description-Content-Type: text/markdown
+
+# deployml
+
+A CLI tool that deploys a production MLOps stack on GCP with a single command. Built for academic ML courses so students can focus on building models, not infrastructure.
+
+## What you get
+
+- **MLflow** — experiment tracking, artifact storage, and model registry (backed by Cloud SQL Postgres + GCS)
+- **FastAPI** — model serving endpoint that loads the latest registered model from MLflow automatically
+- **Grafana** — monitoring dashboard connected to your metrics database
+- **BigQuery** — `mlops` dataset with tables for features, predictions, ground truth, and drift metrics
+
+All running on GCP Cloud Run — no servers to manage, scales to zero when idle.
+
+## Quick Start
+
+**1. Install**
+
+```bash
+pip install deployml-core
+```
+
+**2. Initialize your GCP project** (enables APIs, creates Artifact Registry)
+
+```bash
+deployml init --provider gcp --project-id YOUR_PROJECT_ID
+```
+
+**3. Configure**
+
+```bash
+cp config.example.yaml config.yaml
+# Edit config.yaml and set your project_id
+```
+
+**4. Build images**
+
+```bash
+deployml build-images
+```
+
+**5. Deploy**
+
+```bash
+deployml deploy --verbose
+```
+
+First deploy takes ~20 minutes (Cloud SQL provisioning). Subsequent deploys are 1–2 minutes.
+
+**6. Get your URLs**
+
+```bash
+deployml get-urls
+```
+
+Prints service URLs and writes a `.env` file with `MLFLOW_URL`, `FASTAPI_URL`, `GRAFANA_URL`, `BIGQUERY_PROJECT`, and `BIGQUERY_DATASET`.
+
+## End-to-End Example
+
+Once deployed, the `example/` directory walks through a complete MLOps workflow using a synthetic housing price dataset:
+
+```bash
+pip install mlflow scikit-learn pandas numpy google-cloud-bigquery db-dtypes python-dotenv requests
+
+python example/scripts/01_load_training_data.py   # load 500 rows into BigQuery
+python example/scripts/02_train_model.py           # train RandomForest, log to MLflow
+python example/scripts/03_register_model.py        # register model as Production
+python example/scripts/04_make_predictions.py      # serve 50 predictions via FastAPI
+python example/scripts/05_generate_ground_truth.py # simulate actual outcomes
+python example/scripts/06_compute_drift_metrics.py # compute feature drift + MAE
+python example/scripts/07_setup_grafana.py         # provision monitoring dashboard
+```
+
+See [example/README.md](example/README.md) for details.
+
+## Teardown
+
+```bash
+deployml destroy
+```
+
+Deletes all Cloud Run services, Cloud SQL, GCS bucket, and BigQuery dataset. Does not delete Artifact Registry images or the GCP project.
+
+## Full Tutorial
+
+See [docs/tutorials/gcp-cloud-run.md](docs/tutorials/gcp-cloud-run.md) for a step-by-step walkthrough.
+
+## Requirements
+
+- Python 3.10+
+- `gcloud` CLI (authenticated)
+- Docker (running)
+- Terraform
+

deployml_core-0.0.60/README.md

@@ -0,0 +1,92 @@
+# deployml
+
+A CLI tool that deploys a production MLOps stack on GCP with a single command. Built for academic ML courses so students can focus on building models, not infrastructure.
+
+## What you get
+
+- **MLflow** — experiment tracking, artifact storage, and model registry (backed by Cloud SQL Postgres + GCS)
+- **FastAPI** — model serving endpoint that loads the latest registered model from MLflow automatically
+- **Grafana** — monitoring dashboard connected to your metrics database
+- **BigQuery** — `mlops` dataset with tables for features, predictions, ground truth, and drift metrics
+
+All running on GCP Cloud Run — no servers to manage, scales to zero when idle.
+
+## Quick Start
+
+**1. Install**
+
+```bash
+pip install deployml-core
+```
+
+**2. Initialize your GCP project** (enables APIs, creates Artifact Registry)
+
+```bash
+deployml init --provider gcp --project-id YOUR_PROJECT_ID
+```
+
+**3. Configure**
+
+```bash
+cp config.example.yaml config.yaml
+# Edit config.yaml and set your project_id
+```
+
+**4. Build images**
+
+```bash
+deployml build-images
+```
+
+**5. Deploy**
+
+```bash
+deployml deploy --verbose
+```
+
+First deploy takes ~20 minutes (Cloud SQL provisioning). Subsequent deploys are 1–2 minutes.
+
+**6. Get your URLs**
+
+```bash
+deployml get-urls
+```
+
+Prints service URLs and writes a `.env` file with `MLFLOW_URL`, `FASTAPI_URL`, `GRAFANA_URL`, `BIGQUERY_PROJECT`, and `BIGQUERY_DATASET`.
+
+## End-to-End Example
+
+Once deployed, the `example/` directory walks through a complete MLOps workflow using a synthetic housing price dataset:
+
+```bash
+pip install mlflow scikit-learn pandas numpy google-cloud-bigquery db-dtypes python-dotenv requests
+
+python example/scripts/01_load_training_data.py   # load 500 rows into BigQuery
+python example/scripts/02_train_model.py           # train RandomForest, log to MLflow
+python example/scripts/03_register_model.py        # register model as Production
+python example/scripts/04_make_predictions.py      # serve 50 predictions via FastAPI
+python example/scripts/05_generate_ground_truth.py # simulate actual outcomes
+python example/scripts/06_compute_drift_metrics.py # compute feature drift + MAE
+python example/scripts/07_setup_grafana.py         # provision monitoring dashboard
+```
+
+See [example/README.md](example/README.md) for details.
+
+## Teardown
+
+```bash
+deployml destroy
+```
+
+Deletes all Cloud Run services, Cloud SQL, GCS bucket, and BigQuery dataset. Does not delete Artifact Registry images or the GCP project.
+
+## Full Tutorial
+
+See [docs/tutorials/gcp-cloud-run.md](docs/tutorials/gcp-cloud-run.md) for a step-by-step walkthrough.
+
+## Requirements
+
+- Python 3.10+
+- `gcloud` CLI (authenticated)
+- Docker (running)
+- Terraform

{deployml_core-0.0.58 → deployml_core-0.0.60}/pyproject.toml

@@ -1,7 +1,7 @@
 
 [project]
 name = "deployml-core"
-version = "0.0.58"
+version = "0.0.60"
 description = "Infra for academia"
 authors = [
     {name = "Drew Hoang", email = "codentell@gmail.com"},

{deployml_core-0.0.58 → deployml_core-0.0.60}/src/deployml/cli/cli.py

@@ -4,6 +4,7 @@ import typer
 import shutil
 import subprocess
 import re
+import importlib.resources as pkg_resources
 from deployml.utils.banner import display_banner
 from deployml.utils.menu import prompt, show_menu
 from deployml.utils.constants import (
@@ -780,7 +781,7 @@ def terraform(
 @cli.command()
 def deploy(
     config_path: Path = typer.Option(
-        ..., "--config-path", "-c", help="Path to YAML config file"
+        Path("config.yaml"), "--config-path", "-c", help="Path to YAML config file"
     ),
     yes: bool = typer.Option(
         False, "--yes", "-y", help="Skip confirmation prompts and deploy"
@@ -788,6 +789,9 @@ def deploy(
     generate_only: bool = typer.Option(
         False, "--generate-only", "-g", help="Only generate manifests, do not apply (for GKE deployments)"
     ),
+    verbose: bool = typer.Option(
+        False, "--verbose", "-v", help="Stream Terraform logs to stdout instead of showing progress bar"
+    ),
 ):
     """
     Deploy infrastructure based on a YAML configuration file.
@@ -1027,6 +1031,34 @@ def deploy(
 
     typer.echo(f" Unified bucket creation: {create_artifact_bucket}")
 
+    # Auto-resolve image URIs: if a service image is not specified in the config (or still
+    # points to a legacy gcr.io path), derive it from the Artifact Registry path that
+    # `deployml build-images` produces: {region}-docker.pkg.dev/{project}/mlops-images/{name}
+    # This keeps the YAML config free of hardcoded image URIs — project/region are enough.
+    _TOOL_IMAGE_NAMES = {
+        "mlflow": "mlflow",
+        "feast": "feast",
+        "fastapi": "fastapi",
+        "grafana": "grafana-container",
+        "wandb": "wandb",
+    }
+    _ar_base = f"{region}-docker.pkg.dev/{project_id}/mlops-images"
+    for stage in stack:
+        for stage_name, tool in stage.items():
+            tool_name = tool.get("name", "")
+            params = tool.setdefault("params", {})
+            existing_image = params.get("image", "")
+            if not existing_image or existing_image.startswith("gcr.io/"):
+                image_name = _TOOL_IMAGE_NAMES.get(tool_name)
+                if image_name:
+                    params["image"] = f"{_ar_base}/{image_name}:latest"
+            # Cron job images are per-job and must be set explicitly — skip here
+            if stage_name == "workflow_orchestration" and tool_name == "cron":
+                for job in params.get("jobs", []):
+                    if not job.get("image") or job.get("image", "").startswith("gcr.io/"):
+                        job_name = job.get("service_name", "")
+                        job["image"] = f"{_ar_base}/{job_name}:latest"
+
     env = Environment(loader=FileSystemLoader(TEMPLATE_DIR))
     # PATCH: Use wandb_main.tf.j2 or mlflow_main.tf.j2 for cloud_run if present
     if deployment_type == "cloud_run":
@@ -1253,6 +1285,7 @@ def deploy(
             ["terraform", "apply", "-auto-approve"],
             DEPLOYML_TERRAFORM_DIR,
             minutes,
+            verbose=verbose,
         )
         if result_code == 0:
             typer.echo(" Deployment complete!")
@@ -1421,10 +1454,93 @@ def deploy(
         typer.echo(" Deployment cancelled")
 
 
+@cli.command()
+def get_urls(
+    config_path: Path = typer.Option(
+        Path("config.yaml"), "--config-path", "-c", help="Path to YAML config file"
+    ),
+    env_path: Path = typer.Option(
+        Path(".env"), "--env-path", help="Path to write .env file"
+    ),
+):
+    """
+    Print service URLs from the last deployment and write them to a .env file.
+    """
+    if not config_path.exists():
+        typer.echo(f" Config file not found: {config_path}")
+        raise typer.Exit(code=1)
+
+    config = yaml.safe_load(config_path.read_text())
+    workspace_name = config.get("name") or "development"
+    project_id = config.get("provider", {}).get("project_id", "")
+    terraform_dir = Path.cwd() / ".deployml" / workspace_name / "terraform"
+
+    if not terraform_dir.exists():
+        typer.echo(f" No deployment found at {terraform_dir}. Run 'deployml deploy' first.")
+        raise typer.Exit(code=1)
+
+    output_proc = subprocess.run(
+        ["terraform", "output", "-json"],
+        cwd=terraform_dir,
+        capture_output=True,
+        text=True,
+    )
+    if output_proc.returncode != 0:
+        typer.echo(" Could not retrieve Terraform outputs. Is the stack deployed?")
+        raise typer.Exit(code=1)
+
+    try:
+        outputs = json.loads(output_proc.stdout)
+    except Exception:
+        typer.echo(" Failed to parse Terraform outputs.")
+        raise typer.Exit(code=1)
+
+    if not outputs:
+        typer.echo("No outputs found. Is the stack deployed?")
+        raise typer.Exit(code=1)
+
+    typer.echo("\n DeployML Outputs:")
+    env_lines = []
+    for key, value in outputs.items():
+        is_sensitive = value.get("sensitive", False)
+        output_val = value.get("value")
+        env_key = key.upper()
+        if is_sensitive:
+            typer.secho(f"  {key}: [SENSITIVE] (value hidden)", fg=typer.colors.YELLOW)
+        elif isinstance(output_val, str):
+            if output_val.startswith("http://") or output_val.startswith("https://"):
+                typer.secho(f"  {key}: {output_val}", fg=typer.colors.BRIGHT_BLUE, bold=True)
+                env_lines.append(f"{env_key}={output_val}")
+            elif output_val == "":
+                typer.secho(f"  {key}: [No value]", fg=typer.colors.YELLOW)
+            else:
+                typer.echo(f"  {key}: {output_val}")
+                env_lines.append(f"{env_key}={output_val}")
+        elif isinstance(output_val, dict):
+            typer.echo(f"  {key}:")
+            for subkey, subval in output_val.items():
+                sub_env_key = f"{env_key}_{subkey.upper()}"
+                if isinstance(subval, str) and (subval.startswith("http://") or subval.startswith("https://")):
+                    typer.secho(f"    {subkey}: {subval}", fg=typer.colors.BRIGHT_BLUE, bold=True)
+                    env_lines.append(f"{sub_env_key}={subval}")
+                elif isinstance(subval, str) and subval:
+                    typer.echo(f"    {subkey}: {subval}")
+                    env_lines.append(f"{sub_env_key}={subval}")
+        else:
+            typer.echo(f"  {key}: {output_val}")
+
+    if project_id:
+        env_lines.append(f"BIGQUERY_PROJECT={project_id}")
+        typer.echo(f"  bigquery_project: {project_id}")
+
+    env_path.write_text("\n".join(env_lines) + "\n")
+    typer.echo(f"\n .env written to {env_path.resolve()}")
+
+
 @cli.command()
 def destroy(
     config_path: Path = typer.Option(
-        ..., "--config-path", "-c", help="Path to YAML config file"
+        Path("config.yaml"), "--config-path", "-c", help="Path to YAML config file"
     ),
     workspace: Optional[str] = typer.Option(
         None, "--workspace", help="Override workspace name from config"
@@ -1487,16 +1603,53 @@ def destroy(
             cwd=DEPLOYML_TERRAFORM_DIR,
         )
 
-        # Check if we have Cloud SQL resources and clean them up first
-        plan_result = subprocess.run(
-            ["terraform", "plan", "-destroy"],
+        # Shut down Cloud Run services first to close any open DB connections
+        # before attempting to destroy Cloud SQL — otherwise active connections
+        # prevent database/user deletion and the destroy fails.
+        region = config.get("provider", {}).get("region", "us-central1")
+        cr_result = subprocess.run(
+            ["gcloud", "run", "services", "list",
+             "--project", project_id,
+             "--region", region,
+             "--format", "value(metadata.name)"],
+            capture_output=True, text=True
+        )
+        if cr_result.returncode == 0:
+            services = [s.strip() for s in cr_result.stdout.splitlines() if s.strip()]
+            for service in services:
+                typer.echo(f" Deleting Cloud Run service: {service}")
+                subprocess.run(
+                    ["gcloud", "run", "services", "delete", service,
+                     "--project", project_id,
+                     "--region", region,
+                     "--quiet"],
+                    capture_output=True,
+                )
+
+        # Remove Cloud SQL databases and user from Terraform state so Terraform
+        # doesn't try to delete them individually — the instance deletion handles
+        # that automatically, avoiding active-connection errors on destroy.
+        state_result = subprocess.run(
+            ["terraform", "state", "list"],
             cwd=DEPLOYML_TERRAFORM_DIR,
             capture_output=True,
             text=True,
         )
-
-        if "google_sql_database_instance" in plan_result.stdout:
-            cleanup_cloud_sql_resources(DEPLOYML_TERRAFORM_DIR, project_id)
+        if state_result.returncode == 0:
+            resources_to_remove = [
+                r.strip() for r in state_result.stdout.splitlines()
+                if any(x in r for x in [
+                    "google_sql_database.",
+                    "google_sql_user.",
+                ])
+            ]
+            for resource in resources_to_remove:
+                typer.echo(f" Removing from state: {resource}")
+                subprocess.run(
+                    ["terraform", "state", "rm", resource],
+                    cwd=DEPLOYML_TERRAFORM_DIR,
+                    capture_output=True,
+                )
 
         # Build destroy command
         cmd = ["terraform", "destroy", "--auto-approve"]
@@ -2287,15 +2440,17 @@ def gke_apply(
 
 @cli.command("build-images")
 def build_images_command(
-    docker_root: Path = typer.Option(
-        ...,
+    config_path: Path = typer.Option(
+        Path("config.yaml"),
+        "--config-path",
+        "-c",
+        help="Path to YAML config file. Used to infer project and region automatically.",
+    ),
+    docker_root: Optional[Path] = typer.Option(
+        None,
         "--docker-root",
         "-d",
-        help="Path to folder containing subfolders with Dockerfiles.",
-        exists=True,
-        file_okay=False,
-        dir_okay=True,
-        resolve_path=True,
+        help="Path to folder containing subfolders with Dockerfiles. Defaults to the built-in deployml docker directory.",
     ),
     gcp_project: Optional[str] = typer.Option(
         None,
@@ -2303,10 +2458,10 @@ def build_images_command(
         "-p",
         help="If provided, images will be built using Cloud Build in this GCP project.",
     ),
-    region: str = typer.Option(
-        "us-central1",
+    region: Optional[str] = typer.Option(
+        None,
         "--region",
-        help="GCP region for Artifact Registry.",
+        help="GCP region for Artifact Registry. Inferred from config if not set.",
     ),
     repository: str = typer.Option(
         "mlops-images",
@@ -2342,6 +2497,16 @@ def build_images_command(
     --dry-run prints commands without executing them.
     """
 
+    if config_path and config_path.exists():
+        config = yaml.safe_load(config_path.read_text())
+        if not gcp_project:
+            gcp_project = config.get("provider", {}).get("project_id")
+        if not region:
+            region = config.get("provider", {}).get("region", "us-central1")
+
+    if not region:
+        region = "us-central1"
+
     if create_repo and not gcp_project:
         typer.secho(
             "--create-repo can only be used with --gcp-project.",
@@ -2349,6 +2514,10 @@ def build_images_command(
         )
         raise typer.Exit(code=1)
 
+    if docker_root is None:
+        docker_root = Path(str(pkg_resources.files("deployml") / "docker"))
+        typer.echo(f"Using built-in docker directory: {docker_root}")
+
     try:
         build_images(
             docker_root=docker_root,

{deployml_core-0.0.58 → deployml_core-0.0.60}/src/deployml/docker/fastapi/Dockerfile

@@ -1,5 +1,5 @@
 # Build for Linux/amd64 platform (not Apple Silicon)
-FROM --platform=linux/amd64 python:3.9-slim
+FROM python:3.9-slim
 
 # Set working directory
 WORKDIR /app
@@ -34,4 +34,5 @@ HEALTHCHECK --interval=30s --timeout=10s --start-period=30s --retries=3 \
     CMD curl -f http://localhost:8000/health || exit 1
 
 # Run the application
-CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]
+# Uses PORT env var so it works on Cloud Run (PORT=8080) and locally (PORT=8000)
+CMD uvicorn main:app --host 0.0.0.0 --port ${PORT:-8000}

deployml_core-0.0.60/src/deployml/docker/fastapi/main.py

@@ -0,0 +1,167 @@
+from fastapi import FastAPI
+from fastapi.responses import JSONResponse
+from pydantic import BaseModel
+from typing import Dict, Optional
+import os
+import uuid
+from datetime import datetime, timezone
+import pandas as pd
+import mlflow
+import mlflow.pyfunc
+
+app = FastAPI(
+    title="FastAPI Demo",
+    description="Simple FastAPI application for Kubernetes deployment demo",
+    version="1.0.0"
+)
+
+MLFLOW_TRACKING_URI = os.getenv("MLFLOW_TRACKING_URI", "http://mlflow-service:5000")
+MODEL_NAME = os.getenv("MODEL_NAME", "HousingPriceModel")
+BIGQUERY_PROJECT = os.getenv("GOOGLE_CLOUD_PROJECT", "")
+BIGQUERY_DATASET = os.getenv("BIGQUERY_DATASET", "mlops")
+
+model = None
+bq_client = None
+
+FEATURE_ORDER = ['bedrooms', 'bathrooms', 'area_sqft', 'lot_size', 'year_built', 'city', 'state']
+
+
+class PredictionRequest(BaseModel):
+    entity_id: Optional[str] = None
+    features: Dict[str, float]
+
+
+class PredictionResponse(BaseModel):
+    prediction: float
+    timestamp: str
+    model_used: Optional[str] = None
+    entity_id: Optional[str] = None
+
+
+class HealthResponse(BaseModel):
+    status: str
+    timestamp: str
+    port: int
+    mlflow_connected: bool
+    model_loaded: bool
+
+
+def load_model_from_mlflow():
+    global model
+    try:
+        mlflow.set_tracking_uri(MLFLOW_TRACKING_URI)
+        model = mlflow.pyfunc.load_model(f"models:/{MODEL_NAME}/Production")
+        print(f"✓ Loaded model '{MODEL_NAME}' from Production stage")
+        return True
+    except Exception as e:
+        print(f"⚠️  Could not load model from MLflow: {e}")
+        model = None
+        return False
+
+
+def init_bigquery():
+    global bq_client
+    if not BIGQUERY_PROJECT:
+        return
+    try:
+        from google.cloud import bigquery
+        bq_client = bigquery.Client(project=BIGQUERY_PROJECT)
+        print(f"✓ BigQuery client initialized for project {BIGQUERY_PROJECT}")
+    except Exception as e:
+        print(f"⚠️  Could not initialize BigQuery client: {e}")
+        bq_client = None
+
+
+def log_prediction_to_bigquery(entity_id: str, predicted_value: float, model_version: str):
+    if bq_client is None:
+        return
+    try:
+        table_id = f"{BIGQUERY_PROJECT}.{BIGQUERY_DATASET}.predictions"
+        row = {
+            "prediction_id": str(uuid.uuid4()),
+            "entity_id": entity_id,
+            "prediction_timestamp": datetime.now(timezone.utc).isoformat(),
+            "predicted_value": predicted_value,
+            "model_version": model_version,
+            "feature_snapshot_timestamp": datetime.now(timezone.utc).isoformat(),
+        }
+        bq_client.insert_rows_json(table_id, [row])
+    except Exception as e:
+        print(f"⚠️  Could not log prediction to BigQuery: {e}")
+
+
+@app.on_event("startup")
+async def startup_event():
+    load_model_from_mlflow()
+    init_bigquery()
+
+
+@app.get("/")
+async def root():
+    return {
+        "service": "FastAPI Demo",
+        "version": "1.0.0",
+        "model_loaded": model is not None,
+        "model_name": MODEL_NAME,
+        "mlflow_uri": MLFLOW_TRACKING_URI,
+        "endpoints": {"health": "/health", "predict": "/predict", "docs": "/docs"}
+    }
+
+
+@app.get("/health", response_model=HealthResponse)
+async def health():
+    port = int(os.getenv("PORT", "8000"))
+    return HealthResponse(
+        status="healthy",
+        timestamp=datetime.now().isoformat(),
+        port=port,
+        mlflow_connected=True,
+        model_loaded=model is not None
+    )
+
+
+@app.post("/predict", response_model=PredictionResponse)
+async def predict(request: PredictionRequest):
+    global model
+
+    entity_id = request.entity_id or str(uuid.uuid4())
+
+    if model is None:
+        load_model_from_mlflow()
+
+    if model is None:
+        return PredictionResponse(
+            prediction=-1.0,
+            timestamp=datetime.now().isoformat(),
+            model_used=None,
+            entity_id=entity_id
+        )
+
+    try:
+        feature_values = [request.features.get(f, 0.0) for f in FEATURE_ORDER]
+        X = pd.DataFrame([feature_values], columns=FEATURE_ORDER)
+
+        prediction = float(model.predict(X)[0])
+        model_version = f"MLflow: {MODEL_NAME}"
+
+        log_prediction_to_bigquery(entity_id, prediction, model_version)
+
+        return PredictionResponse(
+            prediction=prediction,
+            timestamp=datetime.now().isoformat(),
+            model_used=model_version,
+            entity_id=entity_id
+        )
+    except Exception as e:
+        return PredictionResponse(
+            prediction=-1.0,
+            timestamp=datetime.now().isoformat(),
+            model_used=None,
+            entity_id=entity_id
+        )
+
+
+if __name__ == "__main__":
+    import uvicorn
+    port = int(os.getenv("PORT", "8000"))
+    uvicorn.run(app, host="0.0.0.0", port=port)