AI Meeting Assistant

In the previous article, we created the GitHub repository, organized the project structure, added documentation, and established the development roadmap for the Minimal AI Meeting Assistant.

Now it is time to build the first working application component.

In this article, we will create the FastAPI backend, install the required dependencies, configure the development environment, and launch the first API endpoint.

By the end of this article, the backend server will be running locally and FastAPI’s interactive API documentation will be available in the browser.

Goal of This Article

The objective is simple:

Create FastAPI project
        ↓
Configure environment
        ↓
Run backend server
        ↓
Create health endpoint
        ↓
Verify API documentation

This will become the foundation for all future backend development.

What We Are Building

The final backend will eventually handle:

• Meeting uploads
• Audio storage
• Transcription
• AI summaries
• Action items
• User accounts
• Subscription management

For now, we only need a clean and maintainable project structure.

Verify the Repository Structure

Open the repository created in the previous article.

The current structure should resemble:

minimal-ai-meeting-assistant/
│
├── backend/
├── frontend/
├── docs/
├── .github/
├── README.md
└── .gitignore

We will work entirely inside the backend folder.

Step 1: Navigate to the Backend Directory

Open a terminal.

Move into the project:

cd minimal-ai-meeting-assistant

Move into the backend folder:

cd backend

Verify your location:

pwd

or on Windows:

Get-Location

Suggested Screenshot

Capture the terminal showing the backend folder as the current working directory.

Step 2: Create a Python Virtual Environment

A virtual environment isolates project dependencies from the rest of your system.

Create the environment:

python -m venv venv

Depending on your setup, you may need:

python3 -m venv venv

A new folder should appear:

backend/
├── venv/

Activate the Environment

Windows:

venv\Scripts\activate

Mac/Linux:

source venv/bin/activate

When activated, the terminal should display something similar to:

(venv)

Suggested Screenshot

Capture the terminal showing the activated virtual environment.

Step 3: Upgrade Pip

Upgrade pip before installing packages.

python -m pip install --upgrade pip

Verify the version:

pip --version

Keeping pip current helps avoid dependency issues.

Step 4: Install FastAPI and Uvicorn

Install the core backend packages.

pip install fastapi uvicorn

Verify installation:

pip list

You should see:

fastapi
uvicorn
pydantic
starlette

among other packages.

Step 5: Create the Backend Application Structure

Inside backend, create the following structure.

backend/
│
├── app/
│   ├── api/
│   │   └── routes/
│   │
│   ├── core/
│   │
│   ├── db/
│   │
│   ├── schemas/
│   │
│   ├── services/
│   │
│   └── main.py
│
├── tests/
│
├── requirements.txt
└── .env.example

Create folders manually in Visual Studio Code or using terminal commands.

Windows:

mkdir app
mkdir app\api
mkdir app\api\routes
mkdir app\core
mkdir app\db
mkdir app\schemas
mkdir app\services
mkdir tests

Mac/Linux:

mkdir -p app/api/routes
mkdir -p app/core
mkdir -p app/db
mkdir -p app/schemas
mkdir -p app/services
mkdir tests

Suggested Screenshot

Capture the Explorer panel showing the newly created structure.

Step 6: Create Package Initialization Files

Python packages require __init__.py.

Create:

app/__init__.py
app/api/__init__.py
app/api/routes/__init__.py
app/core/__init__.py
app/db/__init__.py
app/schemas/__init__.py
app/services/__init__.py

The files can remain empty.

The structure now becomes:

app/
│
├── api/
│   ├── __init__.py
│   └── routes/
│       └── __init__.py
│
├── core/
│   └── __init__.py
│
├── db/
│   └── __init__.py
│
├── schemas/
│   └── __init__.py
│
├── services/
│   └── __init__.py
│
└── main.py

Step 7: Create the Main FastAPI Application

Create:

app/main.py

Add the following code:

from fastapi import FastAPI
app = FastAPI(
    title="Minimal AI Meeting Assistant",
    version="0.1.0"
)
@app.get("/")
def root():
    return {
        "message": "Minimal AI Meeting Assistant API"
    }

This creates the first FastAPI application and one endpoint.

Step 8: Create the Health Endpoint

Create:

app/api/routes/health.py

Add:

from fastapi import APIRouter
router = APIRouter()
@router.get("/health")
def health_check():
    return {
        "status": "ok"
    }

This route will be used by future monitoring and deployment systems.

Step 9: Register the Route

Open:

app/main.py

Replace its contents with:

from fastapi import FastAPI
from app.api.routes.health import router as health_router
app = FastAPI(
    title="Minimal AI Meeting Assistant",
    version="0.1.0"
)
app.include_router(
    health_router,
    prefix="/api/v1"
)
@app.get("/")
def root():
    return {
        "message": "Minimal AI Meeting Assistant API"
    }

The health endpoint is now registered.

Step 10: Create Environment Configuration

Create:

.env.example

Add:

APP_NAME=Minimal AI Meeting Assistant
APP_VERSION=0.1.0
DEBUG=True
HOST=0.0.0.0
PORT=8000

Future articles will load these values using Pydantic settings.

Never store actual secrets in .env.example.

Step 11: Create Requirements File

Generate the dependency list.

pip freeze > requirements.txt

Open the file and verify that FastAPI and Uvicorn appear.

Example:

fastapi==0.xx.x
uvicorn==0.xx.x
pydantic==x.x.x
starlette==x.x.x

The exact versions will vary.

Step 12: Run the Backend Server

Start the development server.

uvicorn app.main:app --reload

You should see output similar to:

INFO:     Will watch for changes...
INFO:     Uvicorn running on
          http://127.0.0.1:8000

The server is now running.

Suggested Screenshot

Capture the terminal showing Uvicorn running successfully.

Step 13: Test the Root Endpoint

Open:

http://127.0.0.1:8000

Expected response:

{
  "message": "Minimal AI Meeting Assistant API"
}

Suggested Screenshot

Capture the browser showing the root endpoint response.

Step 14: Test the Health Endpoint

Open:

http://127.0.0.1:8000/api/v1/health

Expected response:

{
  "status": "ok"
}

Suggested Screenshot

Capture the health endpoint response.

Step 15: Open FastAPI Documentation

FastAPI automatically generates API documentation.

Open:

http://127.0.0.1:8000/docs

You should see Swagger UI.

Test the health endpoint directly from the interface.

Also open:

http://127.0.0.1:8000/redoc

Both documentation systems are generated automatically.

Suggested Screenshot

Capture the Swagger UI page.

This is one of FastAPI’s biggest advantages because the API remains self-documenting throughout development.

Step 16: Verify Hot Reload

While Uvicorn is running, modify:

@app.get("/")
def root():
    return {
        "message": "Backend is running"
    }

Save the file.

Refresh the browser.

The response should update automatically.

This confirms that auto-reload is functioning correctly.

Step 17: Commit the Changes

Stop the server:

CTRL+C

Check the repository status:

git status

Stage the files:

git add .

Commit:

git commit -m "Initialize FastAPI backend foundation"

Push:

git push origin main

The backend foundation is now safely stored in GitHub.

Testing Checklist

Verify the following:

• Virtual environment created
• Virtual environment activated
• FastAPI installed
• Uvicorn installed
• Backend structure created
• Main application created
• Health endpoint created
• Requirements file generated
• Backend server starts successfully
• Root endpoint works
• Health endpoint works
• Swagger UI works
• Changes committed to GitHub

Common Problems

FastAPI Could Not Be Resolved

In Visual Studio Code:

Python: Select Interpreter

Choose the virtual environment:

backend/venv

This is the same issue many developers encounter when VS Code uses the wrong Python interpreter.

Error Loading ASGI App

Example:

Could not import module "main"

Make sure you are inside the backend directory before starting Uvicorn.

Correct:

uvicorn app.main:app --reload

Incorrect:

uvicorn main:app --reload

unless the file is actually located in the repository root.

Module Not Found

If Python reports:

No module named app

Verify that:

app/__init__.py

exists.

Port Already In Use

If port 8000 is occupied:

uvicorn app.main:app --reload --port 8001

What We Accomplished

The Minimal AI Meeting Assistant now has:

• A functioning FastAPI backend
• A structured backend architecture
• Environment configuration
• Automatic API documentation
• A health endpoint
• Hot-reload development support
• Version-controlled backend code

Most importantly, the project is now a running application rather than just a repository structure.

Next Article

Building the React Frontend for the Minimal AI Meeting Assistant

In the next article we will:

• Create the React application
• Configure TypeScript
• Build the first page
• Connect to the FastAPI backend
• Verify frontend-to-backend communication

At that point, both halves of the application will be operational and ready for feature development.