AugMed is a clinical case review platform for research on AI-augmented medical decision-making. It presents clinicians with de-identified patient cases (stored in OMOP CDM format) and collects their diagnostic assessments and clinical recommendations. Researchers control exactly which clinical features each participant sees, enabling controlled experiments on how AI assistance and information disclosure influence clinical judgment. The platform is domain-agnostic — any clinical scenario representable in OMOP format can be studied. The backend API is built using Flask and Python.

Live Website: https://augmed1.dhep.org/.

Deploy your own AugMed instance with one click. Each option deploys the full platform (API + Frontend + RL service + PostgreSQL) with demo data pre-loaded.

• One-Click Deploy Guide (Railway)
• Self-Hosted Deploy Guide (Docker Compose)
• Development Setup

Clone the repository if you haven't done so already, then follow these steps to set up your local environment:

1. Install Python

   Use the following command to install Python:

   brew install python@3.11

   After installation, verify the new version by running:

   python3 --version

2. Install Pipenv

   Pipenv is used to manage dependencies as it can automatically generate the Pipfile.lock, unlike virtualenv which requires manual generation of requirements.txt.

   pip install pipenv

   For installing further dependencies, use pipenv install <package> instead of pip install <package> to manage the dependencies efficiently.

3. Docker

   Ensure Docker is installed and running locally on your machine.

4. Python Path

   In the root path of the project, set the PYTHONPATH by running:

   export PYTHONPATH=$(pwd)

To run the application locally, follow these steps:

1. Ensure all dependencies are installed using Pipenv.

   pipenv install

2. Start your Docker containers if the application requires any external services like databases.
3. Use the following command to run the application under the src directory:

   flask run

   Adjust the command based on your application's entry point if different.
4. Alternatively, run the following command to start the application, at the root path of the project if there is any port conflict on your machine:

   flask run --host=127.0.0.1 --port=5001

pipenv install flask-cors

from flask_cors import CORS
# Then, after declaring `app` in the same file:
CORS(app, origins=["http://localhost:3000"], supports_credentials=True, expose_headers=["Authorization"],)

Pytest discovers tests following these naming conventions:

test_*.py
*_test.py

For more details, visit pytest documentation.

Execute your tests by running:

pytest

Ensure you are in the project's root directory or specify the tests' path.

To maintain code quality and consistency, run linting tools such as flake8 or pylint. Install your chosen linter via pipenv, then run it across your project. For example, with flake8:

pipenv install flake8
flake8 src

It is highly encouraged to use Black for code formatting before every commit. You can run it as follows:

pipenv run black .

Run this inside a pipenv shell, from the root directory of the project. This will format all Python files in the project.

To set up the local database, firstly export the var in .env to local. Then run:

docker-compose up -d

And add a .env file in the root follow the .env_example

Database migration scripts are managed with Flask-Alembic under the src/migrations folder.

To modify the schema, use the following commands under the src:

flask db init  # Only needed the first time to create the migration repository.

flask db migrate -m "Create user table"

flask db upgrade  # Execute this if you pull new changes that alter the schema remotely.

Configure your local hooks as follows:

git config core.hooksPath .githooks

This will ensure that your local git hooks are used instead of the default ones. You can find the hooks in the .githooks directory.

The application is deployed using Docker and AWS services. The deployment process involves building Docker images, pushing them to AWS ECR, and deploying them to AWS ECS.

Specifically, the application is deployed to an AWS ECS cluster using Fargate. The deployment process is automated using GitHub Actions, which builds the Docker image, pushes it to ECR, and updates the ECS service.

It also uses Terraform to manage the infrastructure as code.

This project is licensed under the Apache License 2.0. See the LICENSE file for details.