compose.demo.yml

# The whole loop, in containers:
#
#   podman compose -f compose.demo.yml up --build -d
#   podman compose -f compose.demo.yml exec backend bun apps/backend/src/cli/wuzzy.ts crawl https://docs.base.org/ --max=60
#   podman compose -f compose.demo.yml exec backend bun apps/backend/src/cli/wuzzy.ts embed
#   open http://localhost:8080
#
# Two services here are stand-ins so the loop runs with no API key, no funds and
# no mainnet. Both say so loudly in their own source, and neither belongs in a
# real deployment. Everything else is the real thing.
# Postgres is declared here rather than included from compose.yml: `include`
# merges list fields by appending, so an overridden `ports` would try to bind
# 5432 as well as 5433 and collide with whatever already holds it.
services:
  # The crawl queue's broker. A commissioned crawl is asked for by the API and
  # done by a worker, so that a page someone paid for starts being fetched in
  # seconds rather than whenever a nightly job next runs.
  redis:
    image: docker.io/library/redis:7-alpine
    command: ["redis-server", "--save", "", "--appendonly", "no"]
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 5s
      timeout: 3s
      retries: 5

  postgres:
    image: docker.io/pgvector/pgvector:pg16
    environment:
      POSTGRES_USER: app
      POSTGRES_PASSWORD: app
      POSTGRES_DB: app
    # 5433 so this can run alongside another project already on 5432.
    ports:
      - "5433:5432"
    # Named, so a rebuild cannot take the corpus with it. Without this the data
    # sits in the container's writable layer and any `up --build` that decides
    # to recreate postgres silently destroys a crawl that took hours.
    volumes:
      - demo-pgdata:/var/lib/postgresql/data
    # The default 64MB /dev/shm is too small to build the hnsw index over a
    # populated chunks table: a restore fails with "could not resize shared
    # memory segment". Migrations create that index on an empty table, so the
    # problem only appears when restoring a real corpus, which is exactly when
    # it hurts most.
    shm_size: 1gb
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U app -d app"]
      interval: 5s
      timeout: 3s
      retries: 5

  # NOT an embedding model: deterministic hashed bag of words. Enough to show
  # retrieval wiring end to end, useless for real relevance.
  embeddings:
    image: docker.io/oven/bun:1-alpine
    working_dir: /demo
    volumes:
      - ./scripts/demo:/demo:z,ro
    command: ["bun", "/demo/stub-embeddings.ts"]
    expose:
      - "39500"

  # Approves every well-formed payment and settles NOTHING. Real settlement is
  # the @mainnet @manual scenario in contracts/payment.feature.
  facilitator:
    image: docker.io/oven/bun:1-alpine
    working_dir: /demo
    volumes:
      - ./scripts/demo:/demo:z,ro
    command: ["bun", "/demo/mock-facilitator.ts"]
    expose:
      - "39600"

  # The open API the browser talks to. Also owns the schema migration.
  backend:
    build:
      context: .
      dockerfile: apps/backend/Dockerfile
    environment:
      NODE_ENV: production
      DB_MIGRATIONS_RUN: "true"
      PORT: "3000"
      POSTGRES_HOST: postgres
      REDIS_HOST: redis
      POSTGRES_PORT: "5432"
      POSTGRES_USER: app
      POSTGRES_PASSWORD: app
      POSTGRES_DB: app
      EMBEDDING_BASE_URL: http://embeddings:39500
      EMBEDDING_MODEL: stub-embeddings
      EMBEDDING_DIMENSIONS: "1536"
      # A browser cannot sign an x402 payment, so the UI talks to an open
      # instance. The metered path is `backend-metered` below.
      X402_ENABLED: "false"
      # The admin view is opt-in and read-only. Left untokened here because the
      # demo binds to localhost; set ADMIN_TOKEN for anything reachable.
      ADMIN_ENABLED: "true"
      # The free, rate-limited box on the public site. Opt-in, and separate from
      # the meter: this is the route a browser can use, since it cannot sign a
      # payment. The site is served from :8080 here rather than wuzzy.io.
      WEB_SEARCH_ENABLED: "true"
      WEB_SEARCH_ORIGINS: http://localhost:8080
      # Nothing is in front of this container in the demo, so there is no
      # X-Forwarded-For to trust and the socket address is the client.
      WEB_SEARCH_PROXY_HOPS: "0"
    ports:
      - "3000:3000"
    depends_on:
      postgres:
        condition: service_healthy

  # The same image with the meter on, for the demo agent to pay.
  backend-metered:
    build:
      context: .
      dockerfile: apps/backend/Dockerfile
    environment:
      NODE_ENV: production
      PORT: "3000"
      POSTGRES_HOST: postgres
      REDIS_HOST: redis
      POSTGRES_PORT: "5432"
      POSTGRES_USER: app
      POSTGRES_PASSWORD: app
      POSTGRES_DB: app
      EMBEDDING_BASE_URL: http://embeddings:39500
      EMBEDDING_MODEL: stub-embeddings
      EMBEDDING_DIMENSIONS: "1536"
      X402_ENABLED: "true"
      X402_NETWORK: base-sepolia
      X402_PRICE: $$0.01
      X402_PAY_TO: "0x2222222222222222222222222222222222222222"
      X402_FACILITATOR_URL: http://facilitator:39600
    ports:
      - "3001:3000"
    depends_on:
      postgres:
        condition: service_healthy

  frontend:
    build:
      context: .
      dockerfile: apps/frontend/Dockerfile
      # Read while the pages are rendered, not at run time. The demo points at
      # itself rather than at the public hostnames.
      args:
        SITE_ORIGIN: http://localhost:8080
        API_ORIGIN: http://localhost:3001
        SEARCH_ENABLED: "true"
    environment:
      BACKEND_ORIGIN: http://backend:3000
    ports:
      - "8080:80"
    depends_on:
      - backend

  # A crawl worker. Same image as the backend, no HTTP: it takes jobs off the
  # queue until stopped. `--scale worker=3` is how a slow crawl goes faster;
  # each index is only ever crawled by one of them at a time.
  worker:
    build:
      context: .
      dockerfile: apps/backend/Dockerfile
    command: ["bun", "apps/backend/src/worker.ts"]
    # The image healthchecks an HTTP port the worker does not listen on, so
    # without this it reports unhealthy for its whole life while crawling
    # perfectly well.
    healthcheck:
      disable: true
    environment:
      POSTGRES_HOST: postgres
      REDIS_HOST: redis
      POSTGRES_DB: app
      POSTGRES_USER: app
      POSTGRES_PASSWORD: app
      EMBEDDING_BASE_URL: http://embeddings:39500
      EMBEDDING_MODEL: stub-embeddings
      EMBEDDING_DIMENSIONS: "1536"
    depends_on:
      # The backend owns the migration, and the worker's first query is against
      # a table it creates. Waiting on postgres alone is a race that only shows
      # itself on a fresh volume, as an undefined-table crash on boot.
      backend:
        condition: service_healthy
      redis:
        condition: service_healthy

  # A separate app on its own origin, so it can be kept off the public internet
  # rather than hidden behind a path on the public site. Bound to loopback here:
  # the demo runs it without a token.
  admin:
    build:
      context: .
      dockerfile: apps/admin/Dockerfile
    environment:
      BACKEND_ORIGIN: http://backend:3000
    ports:
      - "127.0.0.1:8081:80"
    depends_on:
      - backend

volumes:
  demo-pgdata: