networks:
  mcpnet:
    driver: bridge

services:

  gateway:
    build:
      context: ./gateway-proxy
      dockerfile: Dockerfile
    container_name: mcp-gateway
    restart: unless-stopped
    ports:
      - "${GATEWAY_PORT:-4444}:4444"
    volumes:
      - gateway-data:/data
    environment:
      - PORT=4444
      - OAUTH_ISSUER_URL=${OAUTH_ISSUER_URL}
      - OAUTH_PASSWORD=${OAUTH_PASSWORD}
      - OAUTH_ACCESS_TOKEN_TTL=${OAUTH_ACCESS_TOKEN_TTL:-3600}
      - OAUTH_REFRESH_TOKEN_TTL=${OAUTH_REFRESH_TOKEN_TTL:-2592000}
      - MCP_BACKEND_ERPNEXT=http://mcp-erpnext:32802/mcp
      - MCP_BACKEND_TRUENAS=http://mcp-truenas:8100/mcp
      - MCP_BACKEND_HOMEASSISTANT=http://mcp-homeassistant:8200/mcp
      - MCP_BACKEND_WAVE=http://mcp-wave:8300/mcp
      - MCP_BACKEND_LINKEDIN=http://mcp-linkedin:8500/mcp
      - MCP_BACKEND_FORGEJO=http://mcp-forgejo:8400/mcp
      - MCP_BACKEND_SSH=http://mcp-ssh:8600/mcp
      - MCP_BACKEND_MEMORY_BANK=http://mcp-memory-bank:8700/mcp
      - MCP_BACKEND_PUPPETEER=http://mcp-puppeteer:8800/mcp
      - MCP_BACKEND_SEQUENTIAL_THINKING=http://mcp-sequential-thinking:8900/mcp
      - GATEWAY_STATIC_API_KEY=${GATEWAY_STATIC_API_KEY}
    depends_on:
      - erpnext-mcp
      - truenas-mcp
      - homeassistant-mcp
      - wave-mcp
      - linkedin-mcp
      - forgejo-mcp
      - ssh-mcp
      - memory-bank-mcp
      - puppeteer-mcp
      - sequential-thinking-mcp
    networks: [mcpnet]
    healthcheck:
      test: ["CMD", "python3", "-c", "import urllib.request; urllib.request.urlopen('http://localhost:4444/health', timeout=5)"]
      interval: 15s
      timeout: 5s
      start_period: 15s
      retries: 3

  erpnext-mcp:
    build:
      context: ./erpnext-mcp
      dockerfile: Dockerfile
    container_name: mcp-erpnext
    restart: unless-stopped
    environment:
      - TRANSPORT=http
      - PORT=32802
      - ERPNEXT_URL=${ERPNEXT_URL}
      - ERPNEXT_API_KEY=${ERPNEXT_API_KEY}
      - ERPNEXT_API_SECRET=${ERPNEXT_API_SECRET}
    networks: [mcpnet]
    healthcheck:
      test: ["CMD", "wget", "-qO-", "http://localhost:32802/health"]
      interval: 30s
      timeout: 5s
      start_period: 15s
      retries: 3

  truenas-mcp:
    build:
      context: ./truenas-mcp
      dockerfile: Dockerfile
    container_name: mcp-truenas
    restart: unless-stopped
    environment:
      - TRUENAS_URL=${TRUENAS_URL}
      - TRUENAS_API_KEY=${TRUENAS_API_KEY}
      - PORT=8100
    networks: [mcpnet]
    healthcheck:
      test: ["CMD", "python3", "-c", "import urllib.request; urllib.request.urlopen('http://localhost:8100/mcp', timeout=5)"]
      interval: 30s
      timeout: 5s
      start_period: 15s
      retries: 3

  homeassistant-mcp:
    build:
      context: ./homeassistant-mcp
      dockerfile: Dockerfile
    container_name: mcp-homeassistant
    restart: unless-stopped
    environment:
      - HASS_URL=${HASS_URL}
      - HASS_TOKEN=${HASS_TOKEN}
      - PORT=8200
    networks: [mcpnet]
    healthcheck:
      test: ["CMD", "python3", "-c", "import urllib.request; urllib.request.urlopen('http://localhost:8200/mcp', timeout=5)"]
      interval: 30s
      timeout: 5s
      start_period: 15s
      retries: 3

  wave-mcp:
    build:
      context: ./wave-mcp
      dockerfile: Dockerfile
    container_name: mcp-wave
    restart: unless-stopped
    environment:
      - TRANSPORT=http
      - PORT=8300
      - WAVE_ACCESS_TOKEN=${WAVE_ACCESS_TOKEN}
    networks: [mcpnet]
    healthcheck:
      test: ["CMD", "wget", "-qO-", "http://localhost:8300/health"]
      interval: 30s
      timeout: 5s
      start_period: 15s
      retries: 3

  linkedin-mcp:
    build:
      context: ./linkedin-mcp
      dockerfile: Dockerfile
    container_name: mcp-linkedin
    restart: unless-stopped
    environment:
      - PORT=8500
      - LINKEDIN_CLIENT_ID=${LINKEDIN_CLIENT_ID}
      - LINKEDIN_CLIENT_SECRET=${LINKEDIN_CLIENT_SECRET}
      - LINKEDIN_REDIRECT_URI=${LINKEDIN_REDIRECT_URI}
    volumes:
      - linkedin-data:/data
    networks: [mcpnet]
    healthcheck:
      test: ["CMD", "python3", "-c", "import urllib.request; urllib.request.urlopen('http://localhost:8500/health', timeout=5)"]
      interval: 30s
      timeout: 5s
      start_period: 10s
      retries: 3

  forgejo-mcp:
    build:
      context: ./forgejo-mcp
      dockerfile: Dockerfile
    container_name: mcp-forgejo
    restart: unless-stopped
    environment:
      - TRANSPORT=http
      - PORT=8400
      - FORGEJO_URL=${FORGEJO_URL:-https://forge.wilddragon.net}
      - FORGEJO_ACCESS_TOKEN=${FORGEJO_ACCESS_TOKEN:-9b80e9ea5e1d1955585fab22fb86e740951940b4}
    networks: [mcpnet]
    healthcheck:
      test: ["CMD", "python3", "-c", "import urllib.request; urllib.request.urlopen('http://localhost:8400/mcp', timeout=5)"]
      interval: 30s
      timeout: 5s
      start_period: 15s
      retries: 3

  ssh-mcp:
    build:
      context: ./ssh-mcp
      dockerfile: Dockerfile
    container_name: mcp-ssh
    restart: unless-stopped
    environment:
      - PORT=8600
      - SSH_HOST=${SSH_HOST}
      - SSH_PORT=${SSH_PORT:-22}
      - SSH_USER=${SSH_USER:-root}
      - SSH_PASSWORD=${SSH_PASSWORD:-}
      - SSH_KEY_PATH=${SSH_KEY_PATH:-}
      - SSH_PASSPHRASE=${SSH_PASSPHRASE:-}
    networks: [mcpnet]
    healthcheck:
      test: ["CMD", "python3", "-c", "import urllib.request; urllib.request.urlopen('http://localhost:8600/mcp', timeout=5)"]
      interval: 30s
      timeout: 5s
      start_period: 15s
      retries: 3

  memory-bank-mcp:
    build:
      context: ./memory-bank-mcp
      dockerfile: Dockerfile
    container_name: mcp-memory-bank
    restart: unless-stopped
    environment:
      - PORT=8700
      - MEMORY_DIR=/data/memories
      - MAX_MEMORIES=${MAX_MEMORIES:-10000}
    volumes:
      - memory-bank-data:/data
    networks: [mcpnet]
    healthcheck:
      test: ["CMD", "python3", "-c", "import urllib.request; urllib.request.urlopen('http://localhost:8700/mcp', timeout=5)"]
      interval: 30s
      timeout: 5s
      start_period: 15s
      retries: 3

  puppeteer-mcp:
    build:
      context: ./puppeteer-mcp
      dockerfile: Dockerfile
    container_name: mcp-puppeteer
    restart: unless-stopped
    environment:
      - PORT=8800
      - VIEWPORT_WIDTH=${PUPPETEER_VIEWPORT_WIDTH:-1280}
      - VIEWPORT_HEIGHT=${PUPPETEER_VIEWPORT_HEIGHT:-720}
      - PAGE_TIMEOUT=${PUPPETEER_PAGE_TIMEOUT:-30000}
    networks: [mcpnet]
    healthcheck:
      test: ["CMD", "python3", "-c", "import urllib.request; urllib.request.urlopen('http://localhost:8800/mcp', timeout=5)"]
      interval: 30s
      timeout: 5s
      start_period: 20s
      retries: 3

  sequential-thinking-mcp:
    build:
      context: ./sequential-thinking-mcp
      dockerfile: Dockerfile
    container_name: mcp-sequential-thinking
    restart: unless-stopped
    environment:
      - PORT=8900
    networks: [mcpnet]
    healthcheck:
      test: ["CMD", "python3", "-c", "import urllib.request; urllib.request.urlopen('http://localhost:8900/mcp', timeout=5)"]
      interval: 30s
      timeout: 5s
      start_period: 15s
      retries: 3

volumes:
  gateway-data:
  linkedin-data:
  memory-bank-data: