FastAPI Quick-Start

This quick-start will guide you through packaging your python app with FastAPI and deploying it to Health Universe, the open-source health research cloud for ML/AI.

Step 1: Create a GitHub repository

1. Create a new repository on GitHub to host your project. You can make the repository either public or private, and it is a good idea to have a readme.md file in the repository and use a .gitignore template so that you can ignore the .env. This is important when you're linking a local development environment to a github repository.

   • Repo contains main.py and requirements.txt

   • Repo has a readme.md

   • Use the "python" .gitignore template (to ignore .env)

   Note: If you're using a local development environment, link your local environment to your GitHub repository

2. Clone the repository to your local machine or use our FastAPI Template:

   git clone https://github.com/<your_account>/<your_repo_name>.git

3. Change to your project directory:

   cd <your_repo>

4. Create a virtual environment using: python -m venv .env

5. Activate your virtual environment with:

   source .env/bin/activate

6. Upgrade pip to make sure things go smoothly: python -m pip install --upgrade pip

7. Install the FastAPI, Uvicorn, & Pydantic libraries with:

   pip install fastapi uvicorn pydantic

Step 2: Create your python app

In your local repository, create the following files:

• main.py: This file should contain your Python model.

• requirements.txt: This file will list your project dependencies.

Next, learn a little bit about how FastAPI works.

• Overview of the main concepts for creating UI with FastAPI.

• Here's a nifty cheat sheet for all the parameters you can create.

main.py

For FastAPI apps, it is best to work from a template so that Navigator knowns how to interact with your app. The template is listed below:

from typing import Annotated, Any
import httpx
from fastapi import FastAPI, Form
from fastapi.middleware.cors import CORSMiddleware
from fastapi.responses import JSONResponse
from pydantic import BaseModel, Field


# Input and Output Schemas
class Input(BaseModel):
    """
    Form-based input schema for template.
    """
    data: Any = Field(
        ...,
        title="An applicable title is helpful for the navigator.",
        examples=["Examples are helpful for navigator to understand the data."],
        description="Always provide verbose description for the data.",
    )


class Output(BaseModel):
    """
    Form-based output schema for template.
    """
    data: Any = Field(
        ...,
        title="An applicable title is helpful for the navigator.",
        examples=["Examples are helpful for navigator to understand the data."],
        description="Always provide verbose description for the data.",
    )


# FastAPI app initialization
app = FastAPI(
    title="Navigator Tool Template",
    description=(
        "The Navigator tool template provides a starting point for creating new Navigator tools. "
    ),
    version="1.0.0",
)

# CORS middleware configuration
app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)

# Tool endpoint
@app.post("/call/", response_model=Output)
async def call(data: Annotated[Input, Form()]) -> Output | JSONResponse:
    """
    Process the input data and return the output.

    Args:
        data: The input data.

    Returns:
        The output data.
    """
    async with httpx.AsyncClient() as client:
        try:
            return Output(**data.model_dump())
        except (httpx.RequestError, httpx.HTTPStatusError) as e:
            return JSONResponse(
                {"error": f"Request failed: {e}"}, status_code=500
            )


# Health check endpoint
@app.get("/health", response_class=JSONResponse)
async def health_check():
    """
    Health check endpoint.
    """
    return {"status": "Application is running."}

requirements.txt

For FastAPI apps, at a minimum you should include the requirements listed below. You may have additional requirements specific to your app, so be sure to include those as well.

fastapi
python-multipart
uvicorn
httpx
pydantic
# Include any other libraries required by your app.

Test out your app by running it locally:

1. Run your app locally using:

   uvicorn main:app --reload

2. Use the auto-generated Swagger UI at: http://127.0.0.1:8000/docs

Step 3: Deploy to Health Universe

1. Push your local repo to GitHub.

2. Log in or create a Health Universe account if you haven't already.

3. Go to https://healthuniverse.com and navigate to "Apps."

4. Click "Add App" to create a new app.

5. Fill out the following fields:

   • App Name: Name of your app

   • Description: A brief description of your app

   • Github Account: Your GitHub username

   • Github Repo: The exact name of your GitHub repository

   • Main File: The name of your python file (usually main.py)

6. Click "Add App" to deploy your app. This process may take a few minutes.

Once you've completed these steps, your app will be published on Health Universe!