docker-compose.bldg1.yml

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

# Building 1 stack: Rasa at ./rasa-bldg1 + shared backend services.
# This file mirrors the current docker-compose.yml but points to rasa-bldg1 and excludes
# the bldg2/bldg3 ThingsBoard stacks (use docker-compose.bldg2.yml or bldg3 for those).

services:
  # pgAdmin (used mainly with bldg2 Timescale or TB Postgres options; safe to keep here)
  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:
      # Default to bldg1 pgAdmin servers configuration; adjust if you use a different DB stack
      - ./bldg1/servers.json:/pgadmin4/servers.json
    networks:
      - ontobot-network
  mongo:
    image: mongo      #or
    container_name: abacws-chatbot-mongo
    hostname: mongohost
    restart: always
    volumes:
      - mongo-data:/data/db
    networks:
      - ontobot-network
  api:
    # image: devmanenvision/abacws-api:bldg1-2025-10-29  # Option: pull prebuilt image from Docker Hub (comment out build: below)
    build:
      context: ./Abacws/api
      dockerfile: Dockerfile
    container_name: abacws-api
    hostname: apihost
    environment:
      - API_PORT=5000
      # Choose ONE (time-series / mappings require Postgres OR MySQL):
      # - DB_ENGINE=mongo
      # - DB_ENGINE=postgres
      - DB_ENGINE=mysql
      # - DB_ENGINE=disabled
      - PGHOST=${API_PGHOST:-postgres}
      - PGPORT=${API_PGPORT:-5432}
      - PGUSER=${API_PGUSER:-postgres}
      - PGPASSWORD=${API_PGPASSWORD:-postgres}
      - PGDATABASE=${API_PGDATABASE:-abacws}
      # MySQL connection (used when DB_ENGINE=mysql)
      - MYSQL_HOST=${API_MYSQL_HOST:-mysql}
      - MYSQL_PORT=${API_MYSQL_PORT:-3306}
      - MYSQL_USER=${API_MYSQL_USER:-root}
      - MYSQL_PASSWORD=${API_MYSQL_PASSWORD:-mysql}
      - MYSQL_DATABASE=${API_MYSQL_DATABASE:-abacws}
      - API_KEY=${API_KEY:-change_me}
    restart: always
    depends_on:
      - mongo
      - postgres
      - mysql
    ports:
      - "5000:5000"
    volumes:
      - ./Abacws/api/src/api/data:/api/src/api/data
    healthcheck:
      test: ["CMD", "sh", "-lc", "wget -qO- http://localhost:5000/health | grep -q 'ok'"]
      interval: 30s
      timeout: 5s
      retries: 5
    networks:
      - ontobot-network

  visualiser:
    # image: devmanenvision/abacws-visualiser:bldg1-2025-10-29  # Option: pull prebuilt image from Docker Hub (comment out build: below)
    build:
      context: ./Abacws/visualiser/
      dockerfile: Dockerfile
    container_name: abacws-visualiser
    hostname: visualiserhost
    restart: always
    depends_on:
      - api
    ports:
      - "8090:80"
    environment:
      - WEB_PORT=80
      - API_HOST=api:5000
      # Optional: set to '1' to enable verbose 3D loader logging in browser console
      - ABACWS_DEBUG=1
    labels:
      - "traefik.enable=true"
      - "traefik.http.services.abacws-visualiser.loadbalancer.server.port=80"
      - "traefik.http.routers.abacws-visualiser.rule=Host(`visualiser.abacws.example.com`)"
      - "traefik.http.routers.abacws-visualiser.entrypoints=https"
      - "traefik.http.routers.abacws-visualiser.tls=true"
    healthcheck:
      test: ["CMD", "sh", "-lc", "wget -qO- http://localhost/health | grep -q 'ok'"]
      interval: 30s
      timeout: 10s
      retries: 5
    networks:
      - ontobot-network

  postgres:
    image: postgres:15-alpine
    container_name: postgres
    hostname: postgres
    environment:
      - POSTGRES_DB=${PG_THINGSBOARD_DB}
      - POSTGRES_USER=${PG_THINGSBOARD_USER}
      - POSTGRES_PASSWORD=${PG_THINGSBOARD_PASSWORD}
    ports:
      - "5432:5432"
    volumes:
      - postgres-data:/var/lib/postgresql/data
    networks:
      - ontobot-network

  mytb:
    image: devmanenvision/my-thingsboard:1.1
    container_name: thingsboard
    hostname: thingsboardhost
    depends_on:
      - postgres
    environment:
      - TB_QUEUE_TYPE=in-memory
      - SPRING_DATASOURCE_URL=jdbc:postgresql://postgres:5432/${PG_THINGSBOARD_DB}
      - SPRING_DATASOURCE_USERNAME=${PG_THINGSBOARD_USER}
      - SPRING_DATASOURCE_PASSWORD=${PG_THINGSBOARD_PASSWORD}
      - 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-data:/data
      - mytb-logs:/var/log/thingsboard
    networks:
      - ontobot-network

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

  # Jena Fuseki (SPARQL) and its data volume container
  fuseki-db:
    image: devmanenvision/busybox:latest
    container_name: jena-fuseki-db
    volumes:
      - jena-data1:/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:
      # Named volumes for config, datasets, backups (persist across rebuilds)
      - jena-data1-config:/fuseki/config
      - jena-data1-datasets:/fuseki/databases
      - jena-data1-backups:/fuseki/backups
    restart: always
    depends_on:
      - fuseki-db
    environment:
      - ADMIN_PASSWORD=${FUSEKI_ADMIN_PASSWORD:-Admin@12345}
    user: "root"
    networks:
      - ontobot-network

  # Analytics microservices (shared)
  microservices:
    # image: devmanenvision/microservices:bldg1-2025-10-29  # Option: pull prebuilt image from Docker Hub (comment out build: below)
    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:
      # Persist dynamically added analytics plugins & metadata so rebuilds are faster
      - microservices-bldg1-plugins:/app/analytics_plugins
      - microservices-bldg1-meta:/app/analytics_meta
      # (Optional) cache for model/rule artifacts if used later
      - microservices-bldg1-cache:/app/.cache
      # Mount rasa-bldg1 actions for sensor list access
      - ./rasa-bldg1:/app/rasa-bldg1: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

  # Rasa stack for Building 1
  rasa:
    image: rasa/rasa:3.6.12-full
    container_name: rasa_bldg1
    restart: unless-stopped
    ports:
      - "5005:5005"
    volumes:
      - ./rasa-bldg1/data:/app/data
      - ./rasa-bldg1/domain.yml:/app/domain.yml
      - ./rasa-bldg1/config.yml:/app/config.yml
      - ./rasa-bldg1/endpoints.yml:/app/endpoints.yml
      - ./rasa-bldg1/credentials.yml:/app/credentials.yml
      - ./rasa-bldg1/models:/app/models
      - ./rasa-bldg1/shared_data:/app/shared_data
      - ./rasa-bldg1/start_rasa.sh:/app/start_rasa.sh:ro
    entrypoint: ["bash", "-lc"]
    command: "/app/start_rasa.sh"
    depends_on:
      - action_server
      - duckling_server
    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:
    # image: devmanenvision/rasa_action_server:bldg1-2025-10-29  # Option: pull prebuilt image from Docker Hub (comment out build: below)
    build: ./rasa-bldg1/actions
    container_name: action_server_bldg1
    restart: unless-stopped
    volumes:
      - ./rasa-bldg1/actions/actions.py:/app/actions.py
      - ./rasa-bldg1/actions/sensor_uuids.txt:/app/sensor_uuids.txt
      - ./rasa-bldg1/actions/sensor_list.txt:/app/sensor_list.txt
      - ./rasa-bldg1/shared_data:/app/shared_data
    environment:
      - BASE_URL=http://localhost:8080
      - DECIDER_URL=http://decider-service:6009/decide
      - BUNDLE_MEDIA=true
      - DB_HOST=mysqlserver
      - DB_NAME=sensordb
      - DB_USER=${ACTION_DB_USER:-root}
      - DB_PASSWORD=${ACTION_DB_PASSWORD:-mysql}
      - DB_PORT=3306
      - 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_bldg1
    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_bldg1
    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-bldg1/data:/srv/rasa/data
      - ./rasa-bldg1/domain.yml:/srv/rasa/domain.yml
      - ./rasa-bldg1/config.yml:/srv/rasa/config.yml
      - ./rasa-bldg1/models:/srv/rasa/models
      - ./rasa-bldg1/endpoints.yml:/srv/rasa/endpoints.yml
      - ./rasa-bldg1/credentials.yml:/srv/rasa/credentials.yml
    networks:
      - ontobot-network

  http_server:
    image: python:3.8-slim
    container_name: http_server_bldg1
    restart: unless-stopped
    ports:
      - "8080:8080"
    volumes:
      - ./rasa-bldg1/shared_data:/data
      - ./rasa-bldg1/file_server.py:/srv/file_server.py
      - ./rasa-bldg1/start_rasa.sh:/srv/start_rasa.sh:ro
      - ./rasa-bldg1/data:/srv/rasa/data
      - ./rasa-bldg1/domain.yml:/srv/rasa/domain.yml
      - ./rasa-bldg1/config.yml:/srv/rasa/config.yml
      - ./rasa-bldg1/models:/srv/rasa/models
      - /var/run/docker.sock:/var/run/docker.sock
    environment:
      - ROOT_DIR=/data
      - PORT=8080
      - FRONTEND_ORIGIN=http://localhost:3000
      - 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:
    # image: devmanenvision/rasa-editor:bldg1-2025-10-29  # Option: pull prebuilt image from Docker Hub (comment out build: below)
    build:
      context: ./rasa-bldg1
      dockerfile: editor.Dockerfile
    container_name: rasa_editor_bldg1
    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-bldg1/editor_server.py:/srv/editor_server.py
      - ./rasa-bldg1/data:/srv/rasa/data
      - ./rasa-bldg1/domain.yml:/srv/rasa/domain.yml
      - ./rasa-bldg1/config.yml:/srv/rasa/config.yml
      - ./rasa-bldg1/models:/srv/rasa/models
      - ./rasa-bldg1/endpoints.yml:/srv/rasa/endpoints.yml
      - ./rasa-bldg1/credentials.yml:/srv/rasa/credentials.yml
      - ./rasa-bldg1/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()"]
    networks:
      - ontobot-network

  rasa-frontend:
    # image: devmanenvision/rasa-web-ui:bldg1-2025-10-29  # Option: pull prebuilt image from Docker Hub (comment out build: below)
    build:
      context: ./rasa-frontend
      dockerfile: Dockerfile
    ports:
      - "3000:3000"
    volumes:
      - ./rasa-frontend/:/app
      - /app/node_modules
    environment:
      - NODE_ENV=development
    depends_on:
      - microservices
    container_name: rasa-frontend-bldg1
    hostname: rasa-frontend-host-bldg1
    restart: unless-stopped
    command: npm start
    networks:
      - ontobot-network

  decider-service:
    # image: devmanenvision/decider-service:bldg1-2025-10-29  # Option: pull prebuilt image from Docker Hub (comment out build: below)
    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()"]
    networks:
      - ontobot-network

  nl2sparql:
    # image: devmanenvision/nl2sparql:bldg1-2025-10-29  # Option: pull prebuilt image from Docker Hub (comment out build: below)
    build:
      context: ./Transformers/t5_base/trained
    ports:
      - "6005:6005"
    volumes:
      # Mount the selected checkpoint (read-only); ensure this matches MODEL_PATH
      - ./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
      # image: devmanenvision/ollama-mistral:bldg1-2025-10-29  # Option: pull prebuilt image from Docker Hub (comment out build: below)
      build:
        context: ./Transformers/Mistral
      pull_policy: always
      restart: unless-stopped
      ports:
        - "${OLLAMA_PORT:-11435}: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-data1:
  mongo-data:
  attachments_volume:
  mysql-data:
  ollama-models:
  mytb-data:
  mytb-logs:
  microservices-bldg1-plugins:
  microservices-bldg1-meta:
  microservices-bldg1-cache:
  jena-data1-config:
  jena-data1-datasets:
  jena-data1-backups:
  postgres-data:





  ## to turn up all containers use docker compose --env-file .env -f "C:\Users\suhas\Documents\GitHub\OntoBot\docker-compose.bldg1.yml" up --build