UI and Postgres Bug?

[zloeber]

I've created a local dockerfile for building the application with the UI flag then updated a docker compose to launch it in UI mode along with external services for all the state components (postgres, redis, qdrant). Most everything comes online but I run into 2 issues:

1. The UI seems to work, allows for MCP server configuration and session creation/deletion. But does not allow for anything to be entered into the chat window. I was missing port 3001 for the websocket connection in my docker-compose.

2. Postgres initialization fails no matter what I throw at it to try to get it working. I get some confusing log output like the following:

cipher         | 15:53:00 INFO: Connecting to PostgreSQL database
cipher         | 15:53:00 ERROR: Failed to connect to PostgreSQL database
cipher         | 15:53:00 ERROR: Failed to connect to database backend
cipher         | 15:53:00 WARN: [StorageManager:Database] Primary backend failed, attempting fallback to in-memory
cipher         | 15:53:00 INFO: InMemoryBackend connected
cipher         | 15:53:00 INFO: [StorageManager:Database] Successfully connected to fallback backend
cipher         | 15:53:00 INFO: [StorageManager] Storage system connected
cipher         | 15:53:00 INFO: SessionManager: PostgreSQL persistence storage initialized successfully
cipher         | 15:53:00 INFO: SessionManager: Storage initialized with database backend: in-memory
cipher         | 15:53:00 INFO: Starting UI mode - API server on 0.0.0.0:3001, UI server on 0.0.0.0:3000

My docker-compose.yml if that helps at all:

# Exposes the following services:
# - http://localhost:8081 - pgweb
# - http://localhost:3000 - cipher (ui)
# - http://localhost:6333/dashboard - qdrant (ui)

services:
  cipher:
    image: cipher
    build:
      context: ./
      dockerfile: Dockerfile.cipher
    container_name: cipher
    restart: unless-stopped
    environment:
      - NODE_ENV=production
      - CIPHER_LOG_LEVEL=info
      - REDACT_SECRETS=true
      - VECTOR_STORE_HOST=qdrant
      - VECTOR_STORE_PORT=6333
      - VECTOR_STORE_URL=http://qdrant:6333
      - VECTOR_STORE_COLLECTION=knowledge_memory
      - VECTOR_STORE_DIMENSION=1536
      - VECTOR_STORE_DISTANCE=Cosine
      - VECTOR_STORE_ON_DISK=false
      - STORAGE_CACHE_TYPE=redis
      - STORAGE_CACHE_HOST=redis
      - STORAGE_CACHE_PORT=6379
      - STORAGE_CACHE_PASSWORD=
      - STORAGE_CACHE_DATABASE=0
      - STORAGE_DATABASE_TYPE=postgres
      - STORAGE_DATABASE_HOST=postgres
      - STORAGE_DATABASE_PORT="5432"
      - STORAGE_DATABASE_NAME=cipher_db
      - STORAGE_DATABASE_USER=${CIPHER_PG_ADMIN:-cipher_user}
      - STORAGE_DATABASE_PASSWORD=${CIPHER_PG_PASSWORD:-secret_cipher}
      - STORAGE_DATABASE_SSL=false
      - CIPHER_PG_URL="postgresql://${CIPHER_PG_ADMIN:-cipher_user}:${CIPHER_PG_PASSWORD:-cipher_secret}@postgres:5432/cipher_db?sslmode=disable"
      - OLLAMA_MODEL=${OLLAMA_MODEL:-qwen3-coder:8b}
      - OLLAMA_EMBEDDING_MODEL=${OLLAMA_EMBEDDING_MODEL:-mxbai-embed-large}
      - OLLAMA_BASE_URL=${OLLAMA_BASE_URL:-http://192.168.1.204:11434}

    volumes:
      #- ./cipher.yml:/app/cipher.yml:ro
      - ./data/cipher:/app/.cipher/data
    ports:
      - "3000:3000"
    command:
      [
        'sh',
        '-c',
        "node dist/src/app/index.cjs --mode ui --host 0.0.0.0 --agent /app/memAgent/cipher.yml --mcp-transport-type sse"
      ]
    configs:
      - source: cipher_config
        target: /app/memAgent/cipher.yml
    healthcheck:
      test:
        [
          'CMD',
          'sh',
          '-c',
          'wget --no-verbose --tries=1 --spider http://localhost:3000/health || exit 1',
        ]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 40s
    depends_on:
      postgres-init:
        condition: service_completed_successfully
      postgres:
        condition: service_healthy
      qdrant:
        condition: service_healthy
      redis:
        condition: service_healthy

  qdrant:
    image: qdrant/qdrant:latest
    restart: unless-stopped
    container_name: qdrant
    ports:
      - 6333:6333
      - 6334:6334
    expose:
      - 6333
      - 6334
      - 6335
    configs:
      - source: qdrant_config
        target: /qdrant/config/production.yaml
    volumes:
      - ./data/qdrant:/qdrant/storage
    healthcheck:
      test: ["CMD", "bash", "-c", "exec 3<>/dev/tcp/127.0.0.1/6333 && echo -e 'GET /readyz HTTP/1.1\\r\\nHost: localhost\\r\\nConnection: close\\r\\n\\r\\n' >&3 && grep -q 'HTTP/1.1 200' <&3"]

  postgres:
    image: postgres
    restart: unless-stopped
    container_name: postgres
    environment:
      POSTGRES_USER: ${PG_ADMIN:-admin}
      POSTGRES_PASSWORD: ${PG_PASSWORD:-secret}
    healthcheck:
      test: ["CMD", "pg_isready", "-U", "${POSTGRES_USER:-admin}"]
      interval: 10s
      timeout: 5s
      retries: 5
    volumes:
      - ./data/postgres:/var/lib/postgresql/data
    ports:
      - "5432:5432"

  postgres-init:
    image: postgres:latest
    container_name: postgres-init
    depends_on:
      postgres:
        condition: service_healthy
    environment:
      PG_ADMIN: ${PG_ADMIN:-admin}
      PGPASSWORD: ${PG_PASSWORD:-secret}
      CIPHER_PG_ADMIN: ${CIPHER_PG_ADMIN:-cipher}
      CIPHER_PG_PASSWORD: ${CIPHER_PG_PASSWORD:-secret_cipher}
      POSTGRES_DB: cipher_db
    volumes:
      - ./init-scripts:/docker-entrypoint-initdb.d:ro
    entrypoint: ["/bin/sh", "-c"]
    command:
      - |
        #!/bin/sh
        sleep 5
        psql -h postgres -U "${PG_ADMIN:-admin}" -c "CREATE DATABASE cipher_db" || echo 'Database already exists'
        # Optionally create user and grant privileges if needed
        psql -h postgres -U "${PG_ADMIN:-admin}" -c "CREATE USER ${CIPHER_PG_ADMIN:-cipher_user} WITH PASSWORD '${CIPHER_PG_PASSWORD:-secret_cipher}';"
        psql -h postgres -U "${PG_ADMIN:-admin}" -c "GRANT ALL PRIVILEGES ON DATABASE cipher_db TO ${CIPHER_PG_ADMIN:-cipher_user};"
        psql -h postgres -U "${PG_ADMIN:-admin}" -c "GRANT USAGE, CREATE ON SCHEMA public TO ${CIPHER_PG_ADMIN:-cipher_user};"
        psql -h postgres -U "${PG_ADMIN:-admin}" -c "GRANT ALL ON ALL TABLES IN SCHEMA public TO ${CIPHER_PG_ADMIN:-cipher_user};"
        psql -h postgres -U "${PG_ADMIN:-admin}" -c "GRANT ALL ON ALL SEQUENCES IN SCHEMA public TO ${CIPHER_PG_ADMIN:-cipher_user};"
    restart: "no"

  pgweb:
    container_name: pgweb
    image: sosedoff/pgweb:latest
    build: .
    environment:
      PGWEB_DATABASE_URL: postgres://${CIPHER_PG_ADMIN:-cipher}:${CIPHER_PG_PASSWORD:-secret_cipher}@postgres:5432/cipher_db?sslmode=disable
    ports:
      - 8081:8081
    depends_on:
      postgres-init:
        condition: service_completed_successfully
    healthcheck:
      test: ["CMD", "nc", "-vz", "127.0.0.1", "8081"]
      interval: 5s

  redis:
    image: redis:latest
    container_name: redis
    restart: unless-stopped
    ports:
      - "6379:6379"
    volumes:
      - ./data/redis:/data
    command: ["redis-server", "--appendonly", "yes"]
    healthcheck:
      test: ["CMD", "redis-cli", "ping"]
      interval: 10s
      timeout: 5s
      retries: 5

configs:
  qdrant_config:
    content: |
      log_level: INFO
  cipher_config:
    content: |
      mcpServers: {}

      # Choose ONLY ONE of the following LLM providers
      llm:
        provider: ollama
        model: qwen3-coder:8b
        maxIterations: 50
        baseURL: http://192.168.1.204:11434

      embedding:
        disabled: false
        type: ollama
        model: nomic-embed-text
        baseUrl: http://192.168.1.204:11434

      systemPrompt:
        enabled: true
        content: |
          You are an AI programming assistant focused on coding and reasoning tasks. You excel at:
          - Writing clean, efficient code
          - Debugging and problem-solving
          - Code review and optimization
          - Explaining complex technical concepts
          - Reasoning through programming challenges

The docker image itself (mostly cloned from the official one but using git to pull and build the project):

ARG NODE_VERSION=20.18.1
# Use the latest official Node.js LTS image
FROM node:${NODE_VERSION}-alpine AS builder

ARG BUILD_UI=true

RUN apk add --no-cache \
    git \
    python3 \
    make \
    g++ \
    && rm -rf /var/cache/apk/* \
    && cd /tmp \
    && git clone https://github.com/campfirein/cipher.git

WORKDIR /app
RUN cp /tmp/cipher/package*.json ./ \
    && cp /tmp/cipher/pnpm-lock.yaml ./

# Install pnpm
RUN npm install -g pnpm@9.14.0 \
  && pnpm install --frozen-lockfile

RUN cp -r /tmp/cipher/* ./ \
  && if [ "$BUILD_UI" = "true" ]; then pnpm run build; else pnpm run build:no-ui; fi

# Clean up and prepare production node_modules
RUN pnpm prune --prod && \
    pnpm store prune && \
    rm -rf /root/.npm /tmp/* /usr/lib/node_modules/npm/man /usr/lib/node_modules/npm/doc /usr/lib/node_modules/npm/html /usr/lib/node_modules/npm/scripts

################################################################################
# Production stage - minimal Alpine
FROM node:${NODE_VERSION}-alpine AS production

WORKDIR /app

# Create non-root user
RUN addgroup -g 1001 -S cipher && adduser -S cipher -u 1001

# Create .cipher directory with proper permissions for database
RUN mkdir -p /app/.cipher/database && \
    chown -R cipher:cipher /app/.cipher

# Copy only essential production files
COPY --from=builder --chown=cipher:cipher /app/dist ./dist
COPY --from=builder --chown=cipher:cipher /app/node_modules ./node_modules
COPY --from=builder --chown=cipher:cipher /app/package.json ./
COPY --from=builder --chown=cipher:cipher /app/memAgent ./memAgent

# Create a minimal .env file for Docker (environment variables will be passed via docker)
RUN echo "# Docker environment - variables passed via docker run" > .env

# Environment variables
ENV NODE_ENV=production \
    PORT=3000 \
    CONFIG_FILE=/app/memAgent/cipher.yml

# Switch to non-root user
USER cipher

# Health check
HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
  CMD node -e "const http = require('http'); const req = http.request({host:'localhost',port:process.env.PORT||3000,path:'/health'}, (res) => process.exit(res.statusCode === 200 ? 0 : 1)); req.on('error', () => process.exit(1)); req.end();"

# Single port for deployment platform
EXPOSE $PORT

# API server mode: REST APIs on single port
CMD ["sh", "-c", "node dist/src/app/index.cjs --mode api --port $PORT --host 0.0.0.0 --agent $CONFIG_FILE"]

[zloeber]

I suppose this may also be a good example of how to setup literally every one of the components locally for a perpetually running local development memory system via docker-compose (though at this point maybe I should just throw it into a kube cluster via a helm chart I suppose...)

[zloeber]

When updated to use the root postgres credentials it initialized the database without issues and started using it. It seems to try to run the init via the public/default database which maybe why it fails with the designated account?