AI Meeting Assistant

Setting Up the GitHub Repository for a Minimal AI Meeting Assistant

Building an AI Meeting Assistant becomes much easier when the project starts with a clean repository, a predictable folder structure, and a working development environment.

In this first practical article, we will create the GitHub repository that will contain the complete Minimal AI Meeting Assistant. We will also prepare separate backend and frontend folders, initialize version control, and create the initial project documentation.

No transcription, summarization, or AI processing will be added yet.

The goal is to create a stable foundation that we can extend one feature at a time throughout the development series.

What We Are Building

The completed Minimal AI Meeting Assistant will eventually allow users to:

  1. Upload a meeting audio recording.
  2. Generate a transcript.
  3. Create an AI-generated meeting summary.
  4. Extract action items.
  5. Review previously processed meetings.

The first version will use an upload-based workflow rather than joining live meetings.

Meeting audio upload
        ↓
Audio storage
        ↓
Speech-to-text transcription
        ↓
AI-generated summary
        ↓
Action-item extraction
        ↓
Meeting results page

This approach keeps the prototype small enough to build, understand, test, and document.

Planned Technology Stack

The project will use the following technologies.

Backend

Frontend

AI Processing

  • Whisper or Faster-Whisper for transcription
  • A large language model for summaries and action items

Development and Deployment

Not all these technologies will be installed in this article. They are listed here so that the direction of the project remains clear.

Prerequisites

Before starting, make sure the following applications are installed.

Git

Run:

git --version

A successful result should look similar to:

git version 2.50.0

Python

Run:

python --version

Depending on your operating system, you may need to use:

python3 --version

For this project, use Python 3.11 or newer.

Node.js

Run:

node --version

Use a currently supported Node.js version that is compatible with the frontend dependencies.

Also verify npm:

npm --version

Visual Studio Code

Visual Studio Code is not required, but it is a practical editor for this project because it supports Python, TypeScript, Git, terminals, and project-wide search.

Step 1: Create the GitHub Repository

Sign in to GitHub and create a new repository.

Use the following repository name:

minimal-ai-meeting-assistant

Suggested description:

An open-source minimal AI meeting assistant built with FastAPI, React, PostgreSQL, and AI transcription and summarization services.

Choose whether the repository should be public or private.

A public repository is useful if the project will support the development articles published on MeetingNotesAI.org.

During repository creation, you may select:

  • Add a README file
  • Add a Python .gitignore
  • Add an MIT license

Alternatively, these files can be created locally in the next steps.

Suggested Screenshot

Add a screenshot showing the GitHub repository creation page with:

  • Repository name
  • Description
  • Visibility setting

Step 2: Clone the Repository

Open a terminal and navigate to the folder where you store development projects.

Clone the repository:

git clone https://github.com/YOUR-USERNAME/minimal-ai-meeting-assistant.git

Replace YOUR-USERNAME with your GitHub username.

Move into the project directory:

cd minimal-ai-meeting-assistant

Confirm the repository status:

git status

You should see output similar to:

On branch main
Your branch is up to date with 'origin/main'.
nothing to commit, working tree clean

Suggested Screenshot

Add a screenshot of the terminal after cloning the repository successfully.

Step 3: Create the Initial Project Structure

The backend and frontend will be kept in separate top-level folders.

Create the folders:

mkdir backend
mkdir frontend
mkdir docs

On Windows PowerShell, the same commands should work.

Create a folder for GitHub Actions:

mkdir .github
mkdir .github/workflows

The initial structure should now look like this:

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

Some files may not exist yet, depending on the options selected when creating the GitHub repository.

Step 4: Open the Project in Visual Studio Code

From the project directory, run:

code .

If the code command is unavailable, open Visual Studio Code manually and select:

File → Open Folder

Choose the minimal-ai-meeting-assistant folder.

The Explorer panel should show the backend, frontend, docs, and .github directories.

Suggested Screenshot

Add a screenshot of the initial folder structure in the Visual Studio Code Explorer.

Github Initial Folder Structure
Github Initial Folder Structure

Step 5: Create the .gitignore File

Create a .gitignore file in the repository root.

Add the following content:

# Python
__pycache__/
*.py[cod]
*.pyo
*.pyd
.Python
venv/
.venv/
env/
ENV/
.pytest_cache/
.mypy_cache/
.ruff_cache/
# Environment files
.env
.env.local
.env.development
.env.production
# Uploaded files
backend/uploads/*
!backend/uploads/.gitkeep
# Database files
*.db
*.sqlite
*.sqlite3
# Node.js
node_modules/
frontend/node_modules/
npm-debug.log*
yarn-debug.log*
yarn-error.log*
pnpm-debug.log*
# Frontend builds
frontend/dist/
frontend/build/
# Testing and coverage
coverage/
htmlcov/
.coverage
# IDE files
.vscode/
.idea/
# Operating system files
.DS_Store
Thumbs.db
# Docker overrides
docker-compose.override.yml

Environment files must never be committed because they may contain API keys, database passwords, and other sensitive configuration values.

Uploaded meeting recordings should also remain outside version control.

Step 6: Create the Initial README

Open README.md and replace its contents with the following:

# Minimal AI Meeting Assistant
An open-source minimal AI Meeting Assistant built as a practical development project for MeetingNotesAI.org.
## Project Goal
The goal is to build a focused web application that can:
- Upload meeting audio recordings
- Generate transcripts
- Create structured meeting summaries
- Extract action items
- Store and display previous meetings
## Planned Technology Stack
### Backend
- Python
- FastAPI
- SQLAlchemy
- Alembic
- PostgreSQL
### Frontend
- React
- TypeScript
- Vite
### AI Services
- Whisper or Faster-Whisper
- Large language model for summaries and action items
## Planned Workflow
```text
Upload audio
    ↓
Store recording
    ↓
Generate transcript
    ↓
Generate summary
    ↓
Extract action items
    ↓
Display meeting results

Repository Structure

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

Development Status

The project is currently in the foundation phase.

Documentation

The complete development series is published on MeetingNotesAI.org.

License

This project is licensed under the MIT License.


This README will evolve as new functionality is added.

## Step 7: Create the Development Roadmap

Inside the `docs` folder, create:

```text
development-roadmap.md

Add the following content:

# Development Roadmap
## Phase 1: Project Foundation
- Create the GitHub repository
- Create backend and frontend folders
- Initialize the FastAPI backend
- Initialize the React frontend
- Add environment configuration
- Add a backend health-check endpoint
## Phase 2: Audio Upload
- Build the meeting upload interface
- Validate supported audio formats
- Store uploaded recordings
- Create meeting database records
- Display upload confirmation
## Phase 3: Transcription
- Integrate Whisper or Faster-Whisper
- Create the transcription service
- Store generated transcripts
- Display transcript content
## Phase 4: Meeting Intelligence
- Generate meeting summaries
- Extract action items
- Identify owners and deadlines
- Store structured AI output
## Phase 5: User Interface
- Create a meeting history page
- Create a meeting details page
- Display processing statuses
- Improve error handling
## Phase 6: SaaS Features
- Add user registration
- Add authentication
- Separate meetings by user
- Add monthly usage limits
- Add Stripe subscriptions
## Phase 7: Production Readiness
- Add automated tests
- Add GitHub Actions
- Containerize the application
- Add production logging
- Add security controls
- Deploy the application

The roadmap gives contributors and readers a clear overview of the project’s direction.

Step 8: Add Placeholder Files

Git does not track empty folders. To keep the initial structure visible in the repository, add a .gitkeep file to the empty folders.

Create:

backend/.gitkeep
frontend/.gitkeep
.github/workflows/.gitkeep

You can create these files manually in Visual Studio Code.

The structure should now be:

minimal-ai-meeting-assistant/
│
├── .github/
│   └── workflows/
│       └── .gitkeep
│
├── backend/
│   └── .gitkeep
│
├── docs/
│   └── development-roadmap.md
│
├── frontend/
│   └── .gitkeep
│
├── .gitignore
├── LICENSE
└── README.md

Step 9: Review the Repository Changes

Run:

git status

You should see the new files listed as untracked or modified.

Review the changes before committing:

git diff

New untracked files may not appear in git diff until they are staged.

Stage the project files:

git add .

Review the staged changes:

git status

Step 10: Create the First Commit

Commit the project foundation:

git commit -m "Initialize project repository structure"

Push the commit to GitHub:

git push origin main

Open the repository in GitHub and confirm that the new folder structure is visible.

Suggested Screenshot

Add a screenshot of the GitHub repository after the first commit, showing:

  • Backend folder
  • Frontend folder
  • Docs folder
  • README
  • .gitignore

Step 11: Create the First GitHub Milestone

Inside the GitHub repository, open:

Issues → Milestones → New milestone

Create a milestone with the following values:

Title

v0.1.0 — Project Foundation

Description

Establish the backend, frontend, documentation, and development environment for the Minimal AI Meeting Assistant.

The milestone can later contain issues for:

  • FastAPI setup
  • React setup
  • Environment configuration
  • Health endpoint
  • CORS configuration

Step 12: Create the Initial GitHub Issues

Create the following issues.

Issue 1

Initialize the FastAPI backend

Description:

Create the initial FastAPI application, install the core backend dependencies, and verify that the development server starts successfully.

Issue 2

Initialize the React and TypeScript frontend

Description:

Create the frontend with React, TypeScript, and Vite, and verify that the local development server works.

Issue 3

Add backend environment configuration

Description:

Create environment configuration using Pydantic settings and provide a safe .env.example file.

Issue 4

Create the backend health-check endpoint

Description:

Add an API health-check route that returns the current application status.

Assign each issue to the v0.1.0 — Project Foundation milestone.

Suggested Screenshot

Add a screenshot of the GitHub milestone and the initial issues.

Testing the Result

Before considering this article complete, confirm the following.

  • The repository exists on GitHub.
  • The repository has been cloned locally.
  • The backend folder exists.
  • The frontend folder exists.
  • The docs folder exists.
  • The .gitignore file exists.
  • The README is visible on GitHub.
  • The development roadmap is committed.
  • The first milestone has been created.
  • The first GitHub issues have been created.
  • git status reports a clean working tree.

Run:

git status

Expected result:

On branch main
Your branch is up to date with 'origin/main'.
nothing to commit, working tree clean

Common Problems

Git Is Not Recognized

If the following error appears:

'git' is not recognized as an internal or external command

Git is either not installed or has not been added to the system PATH.

Install Git and restart the terminal.

The code Command Is Not Recognized

Open Visual Studio Code manually and use the Open Folder option.

The code command can also be added to the PATH during the Visual Studio Code installation.

Empty Folders Are Missing on GitHub

Git does not track empty directories.

Add a .gitkeep file to each empty folder and commit it.

Push Is Rejected

Pull the remote changes before pushing:

git pull origin main

Resolve any conflicts, commit the result, and push again.

What We Accomplished

The Minimal AI Meeting Assistant now has:

  • A dedicated GitHub repository
  • A clean backend and frontend separation
  • Initial project documentation
  • A development roadmap
  • Version-control protection for secrets and uploaded files
  • A first GitHub milestone
  • A small set of actionable development issues

No application code has been written yet, but the project now has a stable and documented foundation.

Next Article

The next article in the development series will be:

Generating the FastAPI Project Structure for the Minimal AI Meeting Assistant

In that article, we will:

  • Create a Python virtual environment
  • Install FastAPI and Uvicorn
  • Create the backend application structure
  • Add the main FastAPI application
  • Run the local API server
  • Verify the automatically generated API documentation

That will be the first point at which the Minimal AI Meeting Assistant becomes a running application.

Ben Kemp

Discover more from AI Meeting Assistant

Subscribe now to keep reading and get access to the full archive.

Continue reading