docker-compose.bldg2.yml

# Quick start (PowerShell):
#   docker compose -f docker-compose.bldg2.yml up -d --build
#   docker compose -f docker-compose.bldg2.yml --profile manual up --build --abort-on-container-exit rasa-train
#   docker compose -f docker-compose.bldg2.yml down
#   # With extras overlay
#   docker compose -f docker-compose.bldg2.yml -f docker-compose.extras.yml up -d --build
#   docker compose -f docker-compose.bldg2.yml -f docker-compose.extras.yml down
# Purpose: Building 2 stack (Rasa at ./rasa-bldg2) + ThingsBoard on Timescale + shared services.

# Stack for Building 2: Rasa (project at ./rasa-bldg2) + ThingsBoard with TimescaleDB

services:
  # ThingsBoard + TimescaleDB (SQL telemetry)
  timescaledb:
    image: timescale/timescaledb:latest-pg14
    container_name: timescaledb
    hostname: timescaledb
    environment:
      POSTGRES_DB: ${PG_THINGSBOARD_DB:-thingsboard}
      POSTGRES_USER: ${PG_THINGSBOARD_USER:-thingsboard}
      POSTGRES_PASSWORD: ${PG_THINGSBOARD_PASSWORD:-thingsboard}
      TIMESCALEDB_TELEMETRY_ENABLED: "false"
    ports:
      - "5433:5432"
    volumes:
      - timescaledb-data:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U thingsboard -d thingsboard"]
      interval: 10s
      timeout: 5s
      retries: 5
      start_period: 30s
    networks:
      - ontobot-network

  mytb:
    image: devmanenvision/my-thingsboard:1.1
    container_name: thingsboard
    hostname: thingsboardhost
    depends_on:
      timescaledb:
        condition: service_healthy
    environment:
      TB_QUEUE_TYPE: in-memory
      SPRING_DATASOURCE_URL: jdbc:postgresql://timescaledb:5432/${PG_THINGSBOARD_DB:-thingsboard}
      SPRING_DATASOURCE_USERNAME: ${PG_THINGSBOARD_USER:-thingsboard}
      SPRING_DATASOURCE_PASSWORD: ${PG_THINGSBOARD_PASSWORD:-thingsboard}
      DATABASE_TS_TYPE: sql
    ports:
      - "8082:9090"   # TB Web UI at http://localhost:8082
      - "1883:1883"
      - "7070:7070"
      - "5683-5688:5683-5688/udp"
      - "8081:8081"
    volumes:
      - mytb-ts-data:/data
      - mytb-ts-logs:/var/log/thingsboard
    networks:
      - ontobot-network

  # Rasa services for Building 2
  rasa:
    image: rasa/rasa:3.6.12-full
    container_name: rasa_bldg2
    restart: unless-stopped
    volumes:
      - ./rasa-bldg2/data:/app/data
      - ./rasa-bldg2/domain.yml:/app/domain.yml
      - ./rasa-bldg2/config.yml:/app/config.yml
      - ./rasa-bldg2/endpoints.yml:/app/endpoints.yml
      - ./rasa-bldg2/credentials.yml:/app/credentials.yml
      - ./rasa-bldg2/models:/app/models
      - ./rasa-bldg2/shared_data:/app/shared_data
      - ./rasa-bldg2/start_rasa.sh:/app/start_rasa.sh:ro
    entrypoint: ["bash", "-lc"]
    command: "/app/start_rasa.sh"
    depends_on:
      - action_server
      - duckling_server
    ports:
      - "5005:5005"
    healthcheck:
      test: ["CMD", "python", "-c", "import urllib.request; urllib.request.urlopen('http://localhost:5005/version').read()"]
      interval: 30s
      timeout: 5s
      retries: 5
    networks:
      - ontobot-network

  action_server:
    build: ./rasa-bldg2/actions
    container_name: action_server_bldg2
    restart: unless-stopped
    volumes:
      - ./rasa-bldg2/actions/actions.py:/app/actions.py
      - ./rasa-bldg2/shared_data:/app/shared_data
    environment:
      - BASE_URL=http://http_server:8080
      - DECIDER_URL=http://decider-service:6009/decide
      - BUNDLE_MEDIA=true
      # If you still fetch anything from MySQL for legacy flows, keep these:
      - DB_HOST=${DB_HOST:-mysqlserver}
      - DB_NAME=${DB_NAME:-sensordb}
      - DB_USER=${DB_USER:-root}
      - DB_PASSWORD=${DB_PASSWORD:-mysql}
      - DB_PORT=3306
      # For TimescaleDB read access from actions (if needed by your actions.py):
      - PG_HOST=timescaledb
      - PG_PORT=5432
      - PG_DATABASE=${PG_THINGSBOARD_DB:-thingsboard}
      - PG_USER=${PG_THINGSBOARD_USER:-thingsboard}
      - PG_PASSWORD=${PG_THINGSBOARD_PASSWORD:-thingsboard}
      - ANALYTICS_URL=http://microservices:6000/analytics/run
    ports:
      - "5055:5055"
    healthcheck:
      test: ["CMD", "python", "-c", "import urllib.request; urllib.request.urlopen('http://localhost:5055/health').read()"]
      interval: 30s
      timeout: 5s
      retries: 5
    networks:
      - ontobot-network
    depends_on:
      - decider-service
      - mysql

  duckling_server:
    image: rasa/duckling:latest
    container_name: duckling_server_bldg2
    restart: unless-stopped
    ports:
      - "8000:8000"
    healthcheck:
      test: ["CMD", "bash", "-lc", "curl -s http://localhost:8000 | grep -q Duckling"]
      interval: 30s
      timeout: 5s
      retries: 5
    networks:
      - ontobot-network

  rasa-train:
    image: rasa/rasa:3.6.12-full
    container_name: rasa_train_bldg2
    profiles: ["manual"]
    working_dir: /srv/rasa
    user: root
    command:
      - train
      - --config
      - /srv/rasa/config.yml
      - --domain
      - /srv/rasa/domain.yml
      - --data
      - /srv/rasa/data
      - --out
      - /srv/rasa/models
    volumes:
      - ./rasa-bldg2/data:/srv/rasa/data
      - ./rasa-bldg2/domain.yml:/srv/rasa/domain.yml
      - ./rasa-bldg2/config.yml:/srv/rasa/config.yml
      - ./rasa-bldg2/models:/srv/rasa/models
      - ./rasa-bldg2/endpoints.yml:/srv/rasa/endpoints.yml
      - ./rasa-bldg2/credentials.yml:/srv/rasa/credentials.yml
    networks:
      - ontobot-network

  http_server:
    image: python:3.8-slim
    container_name: http_server_bldg2
    restart: unless-stopped
    ports:
      - "8080:8080"
    volumes:
      - ./rasa-bldg2/shared_data:/data
      - ./rasa-bldg2/file_server.py:/srv/file_server.py
      - ./rasa-bldg2/start_rasa.sh:/srv/start_rasa.sh:ro
      - ./rasa-bldg2/data:/srv/rasa/data
      - ./rasa-bldg2/domain.yml:/srv/rasa/domain.yml
      - ./rasa-bldg2/config.yml:/srv/rasa/config.yml
      - ./rasa-bldg2/models:/srv/rasa/models
      - /var/run/docker.sock:/var/run/docker.sock
    environment:
      - ROOT_DIR=/data
      - PORT=8080
      - FRONTEND_ORIGIN=${FRONTEND_ORIGIN:-http://localhost:3000}
      - ALLOWED_ORIGINS=${ALLOWED_ORIGINS:-http://localhost:3000}
      - JWT_SECRET=${JWT_SECRET:-change_me_in_prod}
      - JWT_EXPIRES_DAYS=7
      - SECURE_COOKIES=false
      - AUTO_LOAD_AFTER_TRAIN=false
      - RASA_HOST=rasa
      - RASA_HTTP_PORT=5005
      - RASA_PROJECT_ROOT=/srv/rasa
    command: ["sh", "-c", "pip install --no-cache-dir flask werkzeug pyjwt requests docker && python3 /srv/file_server.py"]
    healthcheck:
      test: ["CMD", "python", "-c", "import sys,urllib.request; sys.exit(0 if 'ok' in urllib.request.urlopen('http://localhost:8080/health').read().decode() else 1)"]
      interval: 30s
      timeout: 5s
      retries: 5
    networks:
      - ontobot-network

  rasa-editor:
    build:
      context: ./rasa-bldg2
      dockerfile: editor.Dockerfile
    container_name: rasa_editor_bldg2
    restart: unless-stopped
    ports:
      - "6080:6080"
    environment:
      - PORT=6080
      - FRONTEND_ORIGIN=http://localhost:3000
      - ALLOWED_ORIGINS=http://localhost:3000
      - RASA_PROJECT_ROOT=/srv/rasa
    volumes:
      - ./rasa-bldg2/editor_server.py:/srv/editor_server.py
      - ./rasa-bldg2/data:/srv/rasa/data
      - ./rasa-bldg2/domain.yml:/srv/rasa/domain.yml
      - ./rasa-bldg2/config.yml:/srv/rasa/config.yml
      - ./rasa-bldg2/models:/srv/rasa/models
      - ./rasa-bldg2/endpoints.yml:/srv/rasa/endpoints.yml
      - ./rasa-bldg2/credentials.yml:/srv/rasa/credentials.yml
      - ./rasa-bldg2/actions:/srv/rasa/actions
    entrypoint: ["python", "-m", "uvicorn"]
    command: ["editor_server:app", "--host", "0.0.0.0", "--port", "6080", "--app-dir", "/srv"]
    healthcheck:
      test: ["CMD", "python", "-c", "import urllib.request; urllib.request.urlopen('http://localhost:6080/health').read()"]
      interval: 30s
      timeout: 5s
      retries: 5
    networks:
      - ontobot-network

  rasa-frontend:
    build:
      context: ./rasa-frontend
      dockerfile: Dockerfile
    ports:
      - "3000:3000"
    volumes:
      - ./rasa-frontend/:/app
      - /app/node_modules
    environment:
      - NODE_ENV=development
    container_name: rasa-frontend-bldg2
    hostname: rasa-frontend-host-bldg2
    restart: unless-stopped
    command: npm start
    networks:
      - ontobot-network

  # Shared microservices / decider (same across buildings)
  microservices:
    build:
      context: ./microservices
      dockerfile: Dockerfile
    container_name: microservices_container
    hostname: microserviceshost
    restart: always
    ports:
      - "6001:6000"  # host 6001 -> container 6000 (internal analytics API + T5 training API) - Using 6001 to avoid Chrome ERR_UNSAFE_PORT
    volumes:
      - microservices-bldg2-plugins:/app/analytics_plugins
      - microservices-bldg2-meta:/app/analytics_meta
      - microservices-bldg2-cache:/app/.cache
      # Mount rasa-bldg2 actions for sensor list access
      - ./rasa-bldg2:/app/rasa-bldg2:ro
      # Mount Transformers directory for T5 training
      - ./Transformers:/app/Transformers
    networks:
      - ontobot-network
    healthcheck:
      test: ["CMD", "python", "-c", "import urllib.request; urllib.request.urlopen('http://localhost:6000/health').read()"]
      interval: 30s
      timeout: 5s
      retries: 5

  decider-service:
    build: ./decider-service
    container_name: decider_service
    restart: unless-stopped
    ports:
      - "6009:6009"  # host 6009 -> container 6009 (decider API)
    healthcheck:
      test: ["CMD", "python", "-c", "import urllib.request; urllib.request.urlopen('http://localhost:6009/health').read()"]
      interval: 30s
      timeout: 5s
      retries: 5
    networks:
      - ontobot-network

  # Jena Fuseki (SPARQL) for bldg2
  fuseki-db:
    image: devmanenvision/busybox:latest
    container_name: jena-fuseki-db
    volumes:
      - jena-data2:/fuseki
    command: tail -f /dev/null
    networks:
      - ontobot-network

  jena-fuseki:
    image: devmanenvision/jena-fuseki:latest
    container_name: jena-fuseki-rdf-store
    hostname: jenafusekihost
    ports:
      - "3030:3030"
    volumes_from:
      - fuseki-db
    volumes:
      - jena-data2-config:/fuseki/config
      - jena-data2-datasets:/fuseki/databases
      - jena-data2-backups:/fuseki/backups
    restart: always
    depends_on:
      - fuseki-db
    environment:
      - ADMIN_PASSWORD=${FUSEKI_ADMIN_PASSWORD:-Admin@12345}
    user: "root"
    networks:
      - ontobot-network

  # Optional: pgAdmin to inspect TimescaleDB
  pgadmin:
    image: dpage/pgadmin4:snapshot
    container_name: pgadmin
    hostname: pgadminhost
    ports:
      - "5050:80"
    environment:
      PGADMIN_DEFAULT_EMAIL: ${PGADMIN_DEFAULT_EMAIL:-pgadmin@example.com}
      PGADMIN_DEFAULT_PASSWORD: ${PGADMIN_DEFAULT_PASSWORD:-admin}
      PGADMIN_LISTEN_ADDRESS: 0.0.0.0
      PGADMIN_SERVER_JSON_FILE: /pgadmin4/servers.json
    volumes:
      - ./bldg2/servers.json:/pgadmin4/servers.json
    networks:
      - ontobot-network

  # Legacy MySQL (if needed by actions or migration scripts)
  mysql:
    image: mysql:8
    container_name: mysqlserver
    restart: always
    hostname: mysqlserver
    environment:
      - MYSQL_ROOT_PASSWORD=${MYSQL_ROOT_PASSWORD:-mysql}
      - MYSQL_DATABASE=${DB_NAME:-sensordb}
      - MYSQL_USER=${MYSQL_APP_USER:-thingsboard}
      - MYSQL_PASSWORD=${MYSQL_APP_PASSWORD:-thingsboard}
    ports:
      - "3307:3306"
    volumes:
      - mysql-data:/var/lib/mysql
    networks:
      - ontobot-network


  nl2sparql:
    build:
      context: ./Transformers/t5_base/trained
    ports:
      - "6005:6005"
    volumes:
      # Correct checkpoint mount (was pointing to a non-existent 'checkpoint-' directory)
      - ./Transformers/t5_base/trained/checkpoint-3:/app/checkpoint-3:ro
    environment:
      - PYTHONUNBUFFERED=1
      - MODEL_PATH=/app/checkpoint-3
    container_name: nl2sparql_service
    hostname: nl2sparql-host
    restart: always
    healthcheck:
      test: ["CMD", "python", "-c", "import urllib.request; urllib.request.urlopen('http://localhost:6005/health').read()"]
      interval: 30s
      timeout: 5s
      retries: 5
      start_period: 30s
    networks:
      - ontobot-network

  ollama:
      container_name: ollama
      build:
        context: ./Transformers/Mistral
      pull_policy: always
      restart: unless-stopped
      ports:
        - "11434:11434"
      environment:
        - OLLAMA_NUM_PARALLEL=4
        - OLLAMA_MAX_LOADED_MODELS=1
        - OLLAMA_MODELS=/usr/share/ollama/.ollama/models
        # Space or comma separated list of models to auto-pull & optionally warm up
        - AUTO_PULL_MODELS=mistral:latest
        # Set to 'false' to skip warmup token generation after pull
        - WARMUP_MODELS=true
      healthcheck:
        test: "ollama --version && ollama ps || exit 1"
        interval: 30s
        timeout: 180s
        retries: 3
        start_period: 30s
      # deploy:
      #   resources:
      #     reservations:
            # devices:
            #   - driver: nvidia
            #     count: 1
            #     capabilities: [gpu]
      volumes:
        - .:/usr/share/ollama/.ollama/models
      networks:
        - ontobot-network

networks:
  ontobot-network:

volumes:
  jena-data2:
  timescaledb-data:
  mytb-ts-data:
  mytb-ts-logs:
  mysql-data:
  ollama-models:
  microservices-bldg2-plugins:
  microservices-bldg2-meta:
  microservices-bldg2-cache:
  jena-data2-config:
  jena-data2-datasets:
  jena-data2-backups: