AI-Trader/docs/plans/2025-10-30-docker-deployment.md

Docker Deployment Implementation Plan

For Claude: REQUIRED SUB-SKILL: Use superpowers:executing-plans to implement this plan task-by-task.

Goal: Package AI-Trader as a Docker container with docker-compose orchestration and automated CI/CD builds on release tags.

Architecture: Single monolithic container running all MCP services and trading agent sequentially via entrypoint script. Environment variables injected via docker-compose. Price data fetched on startup. GitHub Actions builds and pushes images to ghcr.io on release tags.

Tech Stack: Docker, Docker Compose, Bash, GitHub Actions, Python 3.10

---

Task 1: Create .dockerignore

Files:

• Create: .dockerignore

Step 1: Create .dockerignore file

Create .dockerignore in project root:

# Version control
.git/
.gitignore

# Python
__pycache__/
*.py[cod]
*$py.class
*.so
.Python
venv/
env/
ENV/
.venv/

# IDE
.vscode/
.idea/
*.swp
*.swo

# Environment and secrets
.env
.env.*
!.env.example

# Data files (fetched at runtime)
data/*.json
data/agent_data/
data/merged.jsonl
data/merged_daily.jsonl
data/merged_hour.jsonl

# Logs
logs/
*.log

# Runtime state
runtime_env.json
.runtime_env.json

# Documentation (not needed in image)
docs/
!README.md

# CI/CD
.github/

# Git worktrees
.worktrees/

# Test files
test.py
delete.py
refresh_data.sh

# Build artifacts
build/
dist/
*.egg-info/

Step 2: Verify file excludes data and secrets

Run: cat .dockerignore | grep -E "\.env|data/.*\.json|\.git" Expected: Should show .env, data/*.json, .git/ lines

Step 3: Commit

git add .dockerignore
git commit -m "Add .dockerignore for Docker builds

Excludes git history, Python cache, secrets, and runtime data"

---

Task 2: Create Dockerfile

Files:

• Create: Dockerfile

Step 1: Create Dockerfile with multi-stage build

Create Dockerfile in project root:

# Base stage - dependency installation
FROM python:3.10-slim as base

WORKDIR /app

# Install dependencies
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# Application stage
FROM base

WORKDIR /app

# Copy application code
COPY . .

# Create necessary directories
RUN mkdir -p data logs data/agent_data

# Make entrypoint executable
RUN chmod +x entrypoint.sh

# Expose MCP service ports and web dashboard
EXPOSE 8000 8001 8002 8003 8888

# Set Python to run unbuffered for real-time logs
ENV PYTHONUNBUFFERED=1

# Use entrypoint script
ENTRYPOINT ["./entrypoint.sh"]
CMD ["configs/default_config.json"]

Step 2: Verify Dockerfile syntax

Run: docker build --dry-run . 2>&1 | grep -i error || echo "Syntax OK" Expected: "Syntax OK" (or no critical errors)

Step 3: Commit

git add Dockerfile
git commit -m "Add Dockerfile for containerization

Multi-stage build with Python 3.10-slim base
Exposes MCP service ports and web dashboard
Uses entrypoint.sh for sequential startup"

---

Task 3: Create entrypoint script

Files:

• Create: entrypoint.sh

Step 1: Create entrypoint.sh with sequential startup logic

Create entrypoint.sh in project root:

#!/bin/bash
set -e  # Exit on any error

echo "🚀 Starting AI-Trader..."

# Step 1: Data preparation
echo "📊 Fetching and merging price data..."
cd /app/data
python get_daily_price.py
python merge_jsonl.py
cd /app

# Step 2: Start MCP services in background
echo "🔧 Starting MCP services..."
cd /app/agent_tools
python start_mcp_services.py &
MCP_PID=$!
cd /app

# Step 3: Wait for services to initialize
echo "⏳ Waiting for MCP services to start..."
sleep 3

# Step 4: Run trading agent with config file
echo "🤖 Starting trading agent..."
CONFIG_FILE="${1:-configs/default_config.json}"
python main.py "$CONFIG_FILE"

# Cleanup on exit
trap "echo '🛑 Stopping MCP services...'; kill $MCP_PID 2>/dev/null; exit 0" EXIT SIGTERM SIGINT

Step 2: Make script executable

Run: chmod +x entrypoint.sh Expected: No output

Step 3: Verify script has executable permissions

Run: ls -la entrypoint.sh | grep -E "^-rwxr" Expected: Shows executable permissions (x flags)

Step 4: Commit

git add entrypoint.sh
git commit -m "Add entrypoint script for container startup

Sequential execution: data fetch → MCP services → trading agent
Handles graceful shutdown of background services
Supports custom config file as argument"

---

Task 4: Create docker-compose.yml

Files:

• Create: docker-compose.yml

Step 1: Create docker-compose.yml with service definition

Create docker-compose.yml in project root:

version: '3.8'

services:
  ai-trader:
    build: .
    container_name: ai-trader-app
    volumes:
      - ./data:/app/data
      - ./logs:/app/logs
    environment:
      # AI Model API Configuration
      - OPENAI_API_BASE=${OPENAI_API_BASE}
      - OPENAI_API_KEY=${OPENAI_API_KEY}

      # Data Source Configuration
      - ALPHAADVANTAGE_API_KEY=${ALPHAADVANTAGE_API_KEY}
      - JINA_API_KEY=${JINA_API_KEY}

      # System Configuration
      - RUNTIME_ENV_PATH=/app/data/runtime_env.json

      # MCP Service Ports
      - MATH_HTTP_PORT=${MATH_HTTP_PORT:-8000}
      - SEARCH_HTTP_PORT=${SEARCH_HTTP_PORT:-8001}
      - TRADE_HTTP_PORT=${TRADE_HTTP_PORT:-8002}
      - GETPRICE_HTTP_PORT=${GETPRICE_HTTP_PORT:-8003}

      # Agent Configuration
      - AGENT_MAX_STEP=${AGENT_MAX_STEP:-30}
    ports:
      - "8000:8000"
      - "8001:8001"
      - "8002:8002"
      - "8003:8003"
      - "8888:8888"
    restart: unless-stopped

Step 2: Validate YAML syntax

Run: docker-compose config 2>&1 | grep -i error || echo "YAML valid" Expected: "YAML valid" (or docker-compose shows parsed config)

Step 3: Commit

git add docker-compose.yml
git commit -m "Add docker-compose configuration

Mounts data and logs volumes for persistence
Injects environment variables from .env file
Exposes all MCP service ports and web dashboard
Auto-restart on failure"

---

Task 5: Update .env.example for Docker

Files:

• Modify: .env.example

Step 1: Read current .env.example

Run: cat .env.example Expected: Shows existing environment variable examples

Step 2: Add Docker-specific documentation to .env.example

Add these lines at the top of .env.example (or update existing variables):

# =============================================================================
# AI-Trader Environment Configuration
# =============================================================================
# Copy this file to .env and fill in your actual values
# Docker Compose automatically reads .env from project root

# AI Model API Configuration
OPENAI_API_BASE=https://your-openai-proxy.com/v1
OPENAI_API_KEY=your_openai_key_here

# Data Source Configuration
ALPHAADVANTAGE_API_KEY=your_alphavantage_key_here
JINA_API_KEY=your_jina_key_here

# System Configuration (Docker default paths)
RUNTIME_ENV_PATH=/app/data/runtime_env.json

# MCP Service Ports (defaults shown)
MATH_HTTP_PORT=8000
SEARCH_HTTP_PORT=8001
TRADE_HTTP_PORT=8002
GETPRICE_HTTP_PORT=8003

# Agent Configuration
AGENT_MAX_STEP=30

Step 3: Verify .env.example has all required variables

Run: grep -E "OPENAI_API_KEY|ALPHAADVANTAGE_API_KEY|JINA_API_KEY" .env.example Expected: Shows all three API key variables

Step 4: Commit

git add .env.example
git commit -m "Update .env.example with Docker configuration

Add Docker-specific paths and documentation
Include all required API keys and MCP ports
Show default values for optional settings"

---

Task 6: Create Docker documentation

Files:

• Create: docs/DOCKER.md

Step 1: Create docs/DOCKER.md with comprehensive usage guide

Create docs/DOCKER.md:

# Docker Deployment Guide

## Quick Start

### Prerequisites
- Docker Engine 20.10+
- Docker Compose 2.0+
- API keys for OpenAI, Alpha Vantage, and Jina AI

### First-Time Setup

1. **Clone repository:**
   ```bash
   git clone https://github.com/HKUDS/AI-Trader.git
   cd AI-Trader

2. Configure environment:

   cp .env.example .env
   # Edit .env and add your API keys
   

3. Run with Docker Compose:

   docker-compose up
   

That's it! The container will:

• Fetch latest price data from Alpha Vantage
• Start all MCP services
• Run the trading agent with default configuration

Configuration

Environment Variables

Edit .env file with your credentials:

# Required
OPENAI_API_KEY=sk-...
ALPHAADVANTAGE_API_KEY=...
JINA_API_KEY=...

# Optional (defaults shown)
MATH_HTTP_PORT=8000
SEARCH_HTTP_PORT=8001
TRADE_HTTP_PORT=8002
GETPRICE_HTTP_PORT=8003
AGENT_MAX_STEP=30

Custom Trading Configuration

Pass a custom config file:

docker-compose run ai-trader configs/my_config.json

Usage Examples

Run in foreground with logs

docker-compose up

Run in background (detached)

docker-compose up -d
docker-compose logs -f  # Follow logs

Run with custom config

docker-compose run ai-trader configs/custom_config.json

Stop containers

docker-compose down

Rebuild after code changes

docker-compose build
docker-compose up

Data Persistence

Volume Mounts

Docker Compose mounts two volumes:

• ./data:/app/data - Price data and trading records
• ./logs:/app/logs - MCP service logs

Data persists across container restarts. To reset:

docker-compose down
rm -rf data/agent_data/* logs/*
docker-compose up

Backup Trading Data

# Backup
tar -czf ai-trader-backup-$(date +%Y%m%d).tar.gz data/agent_data/

# Restore
tar -xzf ai-trader-backup-YYYYMMDD.tar.gz

Using Pre-built Images

Pull from GitHub Container Registry

docker pull ghcr.io/hkuds/ai-trader:latest

Run without Docker Compose

docker run --env-file .env \
  -v $(pwd)/data:/app/data \
  -v $(pwd)/logs:/app/logs \
  -p 8000-8003:8000-8003 \
  ghcr.io/hkuds/ai-trader:latest

Specific version

docker pull ghcr.io/hkuds/ai-trader:v1.0.0

Troubleshooting

MCP Services Not Starting

Symptom: Container exits immediately or errors about ports

Solutions:

• Check ports 8000-8003 not already in use: lsof -i :8000-8003
• View container logs: docker-compose logs
• Check MCP service logs: cat logs/math.log

Missing API Keys

Symptom: Errors about missing environment variables

Solutions:

• Verify .env file exists: ls -la .env
• Check required variables set: grep OPENAI_API_KEY .env
• Ensure .env in same directory as docker-compose.yml

Data Fetch Failures

Symptom: Container exits during data preparation step

Solutions:

• Verify Alpha Vantage API key valid
• Check API rate limits (5 requests/minute for free tier)
• View logs: docker-compose logs | grep "Fetching and merging"

Permission Issues

Symptom: Cannot write to data or logs directories

Solutions:

• Ensure directories writable: chmod -R 755 data logs
• Check volume mount permissions
• May need to create directories first: mkdir -p data logs

Container Keeps Restarting

Symptom: Container restarts repeatedly

Solutions:

• View logs to identify error: docker-compose logs --tail=50
• Disable auto-restart: Comment out restart: unless-stopped in docker-compose.yml
• Check if main.py exits with error

Advanced Usage

Override Entrypoint

Run bash inside container for debugging:

docker-compose run --entrypoint /bin/bash ai-trader

Build Multi-platform Images

For ARM64 (Apple Silicon) and AMD64:

docker buildx build --platform linux/amd64,linux/arm64 -t ai-trader .

View Container Resource Usage

docker stats ai-trader-app

Access MCP Services Directly

Services exposed on host:

• Math: http://localhost:8000
• Search: http://localhost:8001
• Trade: http://localhost:8002
• Price: http://localhost:8003

Development Workflow

Local Code Changes

1. Edit code in project root
2. Rebuild image: docker-compose build
3. Run updated container: docker-compose up

Test Different Configurations

# Create test config
cp configs/default_config.json configs/test_config.json
# Edit test_config.json

# Run with test config
docker-compose run ai-trader configs/test_config.json

Production Deployment

For production use, consider:

1. Use specific version tags instead of latest
2. External secrets management (AWS Secrets Manager, etc.)
3. Health checks in docker-compose.yml
4. Resource limits (CPU/memory)
5. Log aggregation (ELK stack, CloudWatch)
6. Orchestration (Kubernetes, Docker Swarm)

See design document in docs/plans/2025-10-30-docker-deployment-design.md for architecture details.

**Step 2: Verify markdown formatting**

Run: `head -20 docs/DOCKER.md`
Expected: Shows properly formatted markdown header

**Step 3: Commit**

```bash
git add docs/DOCKER.md
git commit -m "Add Docker deployment documentation

Comprehensive guide including:
- Quick start instructions
- Configuration options
- Usage examples and volume persistence
- Troubleshooting common issues
- Pre-built image usage"

---

Task 7: Update main README with Docker section

Files:

• Modify: README.md

Step 1: Read current README to find insertion point

Run: grep -n "## 🚀 Quick Start" README.md Expected: Shows line number of Quick Start section

Step 2: Add Docker section after Quick Start

Insert this content after the "## 🚀 Quick Start" section (around line 210):

## 🐳 Docker Deployment

### Using Docker Compose (Recommended)

The easiest way to run AI-Trader is with Docker Compose:

```bash
# 1. Clone and setup
git clone https://github.com/HKUDS/AI-Trader.git
cd AI-Trader

# 2. Configure environment
cp .env.example .env
# Edit .env with your API keys:
# - OPENAI_API_KEY
# - ALPHAADVANTAGE_API_KEY
# - JINA_API_KEY

# 3. Run with Docker Compose
docker-compose up

The container automatically:

• Fetches latest NASDAQ 100 price data
• Starts all MCP services
• Runs AI trading agents

Using Pre-built Images

Pull and run pre-built images from GitHub Container Registry:

# Pull latest version
docker pull ghcr.io/hkuds/ai-trader:latest

# Run container
docker run --env-file .env \
  -v $(pwd)/data:/app/data \
  -v $(pwd)/logs:/app/logs \
  ghcr.io/hkuds/ai-trader:latest

📖 See docs/DOCKER.md for detailed Docker usage, troubleshooting, and advanced configuration.

---

**Step 3: Verify Docker section added**

Run: `grep -A 5 "## 🐳 Docker Deployment" README.md`
Expected: Shows the Docker section content

**Step 4: Commit**

```bash
git add README.md
git commit -m "Add Docker deployment section to README

Include quick start with Docker Compose
Add pre-built image usage instructions
Link to detailed Docker documentation"

---

Task 8: Create GitHub Actions workflow

Files:

• Create: .github/workflows/docker-release.yml

Step 1: Create .github/workflows directory

Run: mkdir -p .github/workflows Expected: No output

Step 2: Create docker-release.yml workflow

Create .github/workflows/docker-release.yml:

name: Build and Push Docker Image

on:
  push:
    tags:
      - 'v*'  # Triggers on v1.0.0, v2.1.3, etc.
  workflow_dispatch:  # Manual trigger option

jobs:
  build-and-push:
    runs-on: ubuntu-latest
    permissions:
      contents: read
      packages: write

    steps:
      - name: Checkout code
        uses: actions/checkout@v4

      - name: Set up Docker Buildx
        uses: docker/setup-buildx-action@v3

      - name: Login to GitHub Container Registry
        uses: docker/login-action@v3
        with:
          registry: ghcr.io
          username: ${{ github.actor }}
          password: ${{ secrets.GITHUB_TOKEN }}

      - name: Extract version from tag
        id: meta
        run: |
          VERSION=${GITHUB_REF#refs/tags/v}
          echo "version=$VERSION" >> $GITHUB_OUTPUT
          echo "Building version: $VERSION"

      - name: Build and push Docker image
        uses: docker/build-push-action@v5
        with:
          context: .
          push: true
          tags: |
            ghcr.io/${{ github.repository_owner }}/ai-trader:${{ steps.meta.outputs.version }}
            ghcr.io/${{ github.repository_owner }}/ai-trader:latest
          cache-from: type=gha
          cache-to: type=gha,mode=max

      - name: Image published
        run: |
          echo "✅ Docker image published successfully!"
          echo "📦 Pull with: docker pull ghcr.io/${{ github.repository_owner }}/ai-trader:${{ steps.meta.outputs.version }}"
          echo "📦 Or latest: docker pull ghcr.io/${{ github.repository_owner }}/ai-trader:latest"

Step 3: Verify YAML syntax

Run: cat .github/workflows/docker-release.yml | grep -E "name:|on:|jobs:" | head -3 Expected: Shows workflow name, triggers, and jobs

Step 4: Commit

git add .github/workflows/docker-release.yml
git commit -m "Add GitHub Actions workflow for Docker builds

Triggers on release tags (v*) and manual dispatch
Builds and pushes to GitHub Container Registry
Tags with both version and latest
Uses build caching for faster builds"

---

Task 9: Update CLAUDE.md with Docker commands

Files:

• Modify: CLAUDE.md

Step 1: Add Docker section to CLAUDE.md development commands

Insert after the "### Starting Services" section in CLAUDE.md:

### Docker Deployment

```bash
# Build Docker image
docker-compose build

# Run with Docker Compose
docker-compose up

# Run in background
docker-compose up -d

# Run with custom config
docker-compose run ai-trader configs/my_config.json

# View logs
docker-compose logs -f

# Stop and remove containers
docker-compose down

# Pull pre-built image
docker pull ghcr.io/hkuds/ai-trader:latest

# Test local Docker build
docker build -t ai-trader-test .
docker run --env-file .env -v $(pwd)/data:/app/data ai-trader-test

Releasing Docker Images

# Create and push release tag
git tag v1.0.0
git push origin v1.0.0

# GitHub Actions automatically:
# 1. Builds Docker image
# 2. Tags with version and latest
# 3. Pushes to ghcr.io/hkuds/ai-trader

# Verify build in Actions tab
# https://github.com/HKUDS/AI-Trader/actions

**Step 2: Verify Docker commands added**

Run: `grep -A 10 "### Docker Deployment" CLAUDE.md`
Expected: Shows Docker commands section

**Step 3: Commit**

```bash
git add CLAUDE.md
git commit -m "Update CLAUDE.md with Docker commands

Add Docker build and run commands
Include release process for Docker images
Document GitHub Actions automation"

---

Task 10: Test Docker build locally

Files:

• None (verification task)

Step 1: Build Docker image

Run: docker-compose build Expected: Build completes successfully, shows "Successfully built" and image ID

Step 2: Verify image created

Run: docker images | grep ai-trader Expected: Shows ai-trader image with size and creation time

Step 3: Test dry-run (without API keys)

Create minimal test .env:

cat > .env.test << 'EOF'
OPENAI_API_KEY=test
ALPHAADVANTAGE_API_KEY=test
JINA_API_KEY=test
RUNTIME_ENV_PATH=/app/data/runtime_env.json
EOF

Run: docker-compose --env-file .env.test config Expected: Shows parsed configuration without errors

Step 4: Document test results

Create file docs/plans/docker-test-results.txt with output from build

Step 5: Commit test documentation

git add docs/plans/docker-test-results.txt
git commit -m "Add Docker build test results

Local build verification completed successfully
Image builds without errors
Configuration parses correctly"

---

Task 11: Create release checklist documentation

Files:

• Create: docs/RELEASING.md

Step 1: Create release process documentation

Create docs/RELEASING.md:

# Release Process

## Creating a New Release

### 1. Prepare Release

1. Ensure `main` branch is stable and tests pass
2. Update version numbers if needed
3. Update CHANGELOG.md with release notes

### 2. Create Release Tag

```bash
# Ensure on main branch
git checkout main
git pull origin main

# Create annotated tag
git tag -a v1.0.0 -m "Release v1.0.0: Docker deployment support"

# Push tag to trigger CI/CD
git push origin v1.0.0

3. GitHub Actions Automation

Tag push automatically triggers .github/workflows/docker-release.yml:

1. ✅ Checks out code
2. ✅ Sets up Docker Buildx
3. ✅ Logs into GitHub Container Registry
4. ✅ Extracts version from tag
5. ✅ Builds Docker image with caching
6. ✅ Pushes to ghcr.io/hkuds/ai-trader:VERSION
7. ✅ Pushes to ghcr.io/hkuds/ai-trader:latest

4. Verify Build

1. Check GitHub Actions: https://github.com/HKUDS/AI-Trader/actions
2. Verify workflow completed successfully (green checkmark)
3. Check packages: https://github.com/HKUDS/AI-Trader/pkgs/container/ai-trader

5. Test Release

# Pull released image
docker pull ghcr.io/hkuds/ai-trader:v1.0.0

# Test run
docker run --env-file .env \
  -v $(pwd)/data:/app/data \
  ghcr.io/hkuds/ai-trader:v1.0.0

6. Create GitHub Release (Optional)

1. Go to https://github.com/HKUDS/AI-Trader/releases/new
2. Select tag: v1.0.0
3. Release title: v1.0.0 - Docker Deployment Support
4. Add release notes:

## 🐳 Docker Deployment

This release adds full Docker support for easy deployment.

### Pull and Run

```bash
docker pull ghcr.io/hkuds/ai-trader:v1.0.0
docker run --env-file .env -v $(pwd)/data:/app/data ghcr.io/hkuds/ai-trader:v1.0.0

Or use Docker Compose:

docker-compose up

See docs/DOCKER.md for details.

What's New

• Docker containerization with single-container architecture
• docker-compose.yml for easy orchestration
• Automated CI/CD builds on release tags
• Pre-built images on GitHub Container Registry

5. Publish release

## Version Numbering

Use Semantic Versioning (SEMVER):

- `v1.0.0` - Major release (breaking changes)
- `v1.1.0` - Minor release (new features, backward compatible)
- `v1.1.1` - Patch release (bug fixes)

## Troubleshooting Releases

### Build Fails in GitHub Actions

1. Check Actions logs for error details
2. Test local build: `docker build .`
3. Fix issues and delete/recreate tag:

```bash
# Delete tag
git tag -d v1.0.0
git push origin :refs/tags/v1.0.0

# Recreate after fixes
git tag v1.0.0
git push origin v1.0.0

Image Not Appearing in Registry

1. Check Actions permissions (Settings → Actions → General)
2. Verify packages: write permission in workflow
3. Ensure GITHUB_TOKEN has registry access

Wrong Version Tagged

Delete and recreate:

git tag -d v1.0.0
git push origin :refs/tags/v1.0.0
git tag v1.0.1
git push origin v1.0.1

Manual Build and Push

If automated build fails, manual push:

# Build locally
docker build -t ghcr.io/hkuds/ai-trader:v1.0.0 .

# Login to GHCR
echo $GITHUB_TOKEN | docker login ghcr.io -u USERNAME --password-stdin

# Push
docker push ghcr.io/hkuds/ai-trader:v1.0.0
docker tag ghcr.io/hkuds/ai-trader:v1.0.0 ghcr.io/hkuds/ai-trader:latest
docker push ghcr.io/hkuds/ai-trader:latest

**Step 2: Verify release documentation complete**

Run: `grep -E "^## |^### " docs/RELEASING.md`
Expected: Shows all section headers

**Step 3: Commit**

```bash
git add docs/RELEASING.md
git commit -m "Add release process documentation

Complete guide for creating releases:
- Tag creation and push process
- GitHub Actions automation workflow
- Verification and testing steps
- Troubleshooting common issues"

---

Task 12: Final validation and cleanup

Files:

• None (validation task)

Step 1: Verify all Docker files created

Run:

ls -la Dockerfile docker-compose.yml .dockerignore entrypoint.sh .github/workflows/docker-release.yml

Expected: All files exist with correct permissions

Step 2: Verify documentation complete

Run:

ls -la docs/DOCKER.md docs/RELEASING.md docs/plans/2025-10-30-docker-deployment-design.md

Expected: All documentation files exist

Step 3: Verify git status clean

Run: git status Expected: Shows "working tree clean" or only untracked .env files

Step 4: Review commit history

Run: git log --oneline -15 Expected: Shows all 11+ commits from this implementation

Step 5: Create summary commit if needed

If any files uncommitted:

git add -A
git commit -m "Docker deployment implementation complete

All components implemented:
- Dockerfile with multi-stage build
- docker-compose.yml with volume mounts
- entrypoint.sh for sequential startup
- GitHub Actions workflow for releases
- Comprehensive documentation
- .dockerignore for clean builds"

---

Testing Checklist

Before merging to main:

• Docker image builds successfully (docker-compose build)
• Image size reasonable (<500MB for base image)
• Container starts without errors (with test .env)
• MCP services start in container
• Volume mounts work (data/logs persist)
• Custom config file can be passed
• Documentation accurate and complete
• GitHub Actions workflow syntax valid
• .dockerignore excludes unnecessary files

Post-Implementation

After merging:

1. Create test tag to verify GitHub Actions: git tag v0.1.0-test
2. Monitor Actions build
3. Test pulling from ghcr.io
4. Update project README.md if needed
5. Announce Docker support to users

---

Implementation Complete! All Docker deployment components created with comprehensive documentation and automated CI/CD.