Coastline6/transcript-agent-v2

<div align="center">

🎤 Transcript Agent

AI-powered transcription, interview coaching, and video analysis — local-first.

   

**Live Demo** · **Docker Hub** · **Releases** · **Changelog**

</div>

Two editions: Production vs Development

This repo ships two editions on two branches. They share the same Python engine (transcript_agent.py, video_analyzer.py, interview_vision.py) but use a different UI.

TL;DR: If you want the stable Docker Hub release, use Production. If you need the new React UI and the Live Interview webcam feature, use Development (dev branch).

What it does

Core

Interview Coaching

Video & Body Language Analysis

Platform & Updates

Supported formats

🟢 Production (main)

Stable Gradio UI, distributed as a pre-built Docker Hub image — no git clone, no build.

Requirement: Docker (Desktop or Engine).

mkdir transcript-agent && cd transcript-agent

# Add your API keys (at least one LLM key) — see "Configuration" below
cp .env.example .env

# Pull and start the production image
docker compose -f docker-compose.prod.yml pull
docker compose -f docker-compose.prod.yml up -d

Open http://localhost:7860 (Gradio UI) and http://localhost:8000/docs (REST API).

Image tags: sushi0934/transcript-agent:latest (auto-updates) · sushi0934/transcript-agent:2.5.17 (pinned). The prod compose file sets pull_policy: always, restart: unless-stopped, and a healthcheck. The container runs python app.py (Gradio), which grafts the REST API onto its own server.

Run production without Docker

git clone -b main https://github.com/jayuan101/transcript-agent.git
cd transcript-agent

python -m venv venv
source venv/bin/activate        # Windows: venv\Scripts\activate
pip install -r requirements.txt
pip install torch --index-url https://download.pytorch.org/whl/cpu

python app.py                   # Gradio UI + REST API on port 7860

On Windows you can instead double-click `run.bat`, which detects your GPU and opens the browser automatically.

🧪 Development (dev)

Adds the React + PrimeReact UI (served by api.py) and the 🔴 Live Interview webcam feature. The legacy Gradio UI is still available via UI_MODE=gradio.

git clone -b dev https://github.com/jayuan101/transcript-agent.git
cd transcript-agent
cp .env.example .env            # add your keys

# Build & run the React UI + REST API (UI_MODE=react is the default)
docker compose build
docker compose up -d            # http://localhost:7860

Run the React UI from source

python -m venv venv
source venv/bin/activate        # Windows: venv\Scripts\activate
pip install -r requirements.txt
pip install torch --index-url https://download.pytorch.org/whl/cpu

# Build the React UI once (output frontend/dist is served by api.py at "/")
cd frontend && npm install && npm run build && cd ..

python api.py                   # React UI + REST API (port 8000, override with API_PORT)

For live front-end development with hot reload:

cd frontend
npm run dev                     # Vite dev server, proxies to a running `python api.py`

Dev launcher (Windows, Gradio on 7861)

`launch_dev.bat` runs the Gradio app in dev mode on port 7861 (isolated from a production instance on 7860), with TA_DEV_MODE=1 showing a [DEV] banner:

launch_dev.bat

Note: launch_dev.bat runs the Gradio UI, which does not include the Live Interview tab. To develop Live Interview, use python api.py + npm run dev above.

Promote dev to production

• —Windows desktop: `deploy_to_prod.bat` stops the running prod app, copies the updated .py source into the installed app's _internal folder, and relaunches it.
• —Docker Hub: `push_to_dockerhub.bat` builds and pushes a new image; production then pulls it via docker-compose.prod.yml.

Configuration (.env)

Used by both editions. Copy `.env.example` to .env and fill in at least one LLM key. Keys are mounted read-only into the container and never leave your machine.

# AI / LLM providers (pick one or more)
ANTHROPIC_API_KEY=          # Claude  — https://console.anthropic.com/keys
OPENAI_API_KEY=             # GPT     — https://platform.openai.com/api-keys
GEMINI_API_KEY=             # Gemini  — https://aistudio.google.com/app/apikey
GROQ_API_KEY=               # Groq    — https://console.groq.com/keys

# Speech-to-Text engines (optional — Whisper runs locally for free)
DEEPGRAM_API_KEY=
ASSEMBLYAI_API_KEY=
ELEVENLABS_API_KEY=
REV_AI_ACCESS_TOKEN=

# App settings
TZ=America/New_York         # your timezone

You can also enter keys directly in the UI sidebar — they are saved in your browser only.

GPU acceleration (NVIDIA)

Local Whisper and emotion detection run much faster on a GPU. Uncomment the deploy.resources block in the compose file:

    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]

• —Linux: sudo apt install nvidia-container-toolkit && sudo systemctl restart docker
• —Windows: WSL2 + NVIDIA driver >= 510 + Docker Desktop >= 4.13

Auto-update in production

The latest tag plus pull_policy: always means docker compose -f docker-compose.prod.yml up -d always re-pulls the newest image. For hands-off updates, uncomment the Watchtower service in the prod compose file to re-pull hourly:

  watchtower:
    image: containrrr/watchtower
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
    command: --interval 3600 --cleanup transcript-agent
    restart: unless-stopped

REST API

Available in both editions. Runs on port 8000 by default (and on 7860 inside the container). Interactive Swagger docs: /docs.

Usage

1. 1.Open http://localhost:7860
2. 2.Enter an API key in the sidebar (or set it in .env) and pick your STT engine + AI provider
3. 3.Upload a file, paste a path, or paste a URL — click Analyze
4. 4.Enable Interview Mode for per-question scoring, or use the Video Analysis tab
5. 5.(dev only) Open the Live Interview tab for real-time webcam coaching

Ollama — run AI locally (no API key)

1. 1.Install Ollama from ollama.ai, then ollama pull gemma3:27b
2. 2.In the app, select Ollama (Local) as the provider — models are discovered dynamically

In Docker, the app reaches Ollama on the host via host.docker.internal:11434 automatically.

Project structure

transcript_agent.py  — STT engines, LLM analysis, report & export generation   (both)
video_analyzer.py    — Emotion, eye contact, posture, body language, cultural   (both)
interview_vision.py  — On-screen participant-name OCR + speaker mapping         (both)
api.py               — FastAPI REST API (+ serves the React UI on dev)          (both)
app.py               — Gradio UI                                                (production UI)
frontend/            — React + PrimeReact web UI, incl. Live Interview          (dev only)
entrypoint.sh        — Docker entrypoint (app.py on main, api.py on dev)
docker-compose.prod.yml  — Pull pre-built image from Docker Hub                 (production)
docker-compose.yml       — Build from source                                    (dev)
requirements.txt     — Python dependencies

Support the project

If this tool saves you time, consider buying me a coffee


<div align="center"> _{Transcript Agent · Transcription by OpenAI Whisper · Analysis by Anthropic Claude · <a href="CHANGELOG.md">Changelog</a>} </div>