integrate dashboard to docker compose up

Signed-off-by: JaredforReal <[email protected]>

Author: JaredforReal

dashboard/README.md

@@ -156,43 +156,100 @@ Recommended upstream settings for embedding:
 - OIDC enablement behind a flag
 - Metrics summary endpoint
 
-## Try it (proposed)
+## Quick Start
 
-Local with existing observability:
+### Method 1: One-click Start with Docker Compose (Recommended)
 
-1. Start Prometheus/Grafana on host network:
+The Dashboard is integrated into the main Compose stack, requiring no extra configuration:
 
-   - `docker compose -f docker-compose.obs.yml up -d`
+```bash
+# Run from the project root directory
+make docker-compose-up
 
-2. Start router natively or with Compose
-3. Start dashboard backend (port 8700) with env vars above
-4. Open `http://localhost:8700`
+# Or use docker compose directly
+docker compose -f deploy/docker-compose/docker-compose.yml up -d --build
+```
 
-### Docker Compose unified run (after adding dashboard overlay)
+After startup, access:
 
+- **Dashboard**: http://localhost:8700
+- **Grafana** (direct access): http://localhost:3000 (admin/admin)
+- **Prometheus** (direct access): http://localhost:9090
+
+### Method 2: Local Development Mode
+
+When developing the Dashboard code locally:
+
+```bash
+# 1. Start the local Observability stack
+make o11y-local
+# Or
+docker compose -f tools/observability/docker-compose.obs.yml up -d
+
+# 2. Start the Router (in another terminal)
+cd src/semantic-router
+go run cmd/main.go -config ../../config/config.yaml
+
+# 3. Start the Dashboard backend (local development)
+cd dashboard/backend
+export TARGET_GRAFANA_URL=http://localhost:3000
+export TARGET_PROMETHEUS_URL=http://localhost:9090
+export TARGET_ROUTER_API_URL=http://localhost:8080
+export TARGET_ROUTER_METRICS_URL=http://localhost:9190/metrics
+go run main.go -port=8700 -static=../frontend
+
+# 4. Open your browser
+open http://localhost:8700
 ```
-docker compose -f docker-compose.yml -f dashboard/deploy/docker/compose.yml up --build
-```
 
-The overlay builds the dashboard image using `dashboard/backend/Dockerfile` and exposes it at `http://localhost:8700`.
+### Method 3: Rebuild Dashboard Only
+
+For a quick rebuild after code changes:
+
+```bash
+# Rebuild the dashboard service
+docker compose -f deploy/docker-compose/docker-compose.yml build dashboard
 
-### Rebuild only dashboard after code changes
+# Restart the dashboard
+docker compose -f deploy/docker-compose/docker-compose.yml up -d dashboard
 
+# View logs
+docker logs -f semantic-router-dashboard
 ```
-docker compose -f docker-compose.yml -f dashboard/deploy/docker/compose.yml build dashboard
-docker compose -f docker-compose.yml -f dashboard/deploy/docker/compose.yml up -d dashboard
+
+## Deployment Details
+
+### Docker Compose Integration Notes
+
+- The Dashboard service is integrated as a **default service** in `deploy/docker-compose/docker-compose.yml`.
+- No additional overlay files are needed; `make docker-compose-up` will automatically start all services.
+- The Dashboard depends on the `semantic-router` (for health checks), `grafana`, and `prometheus` services.
+
+### Dockerfile Build
+
+- A multi-stage build (Go builder → distroless) is defined in `dashboard/backend/Dockerfile`.
+- An independent Go module `dashboard/backend/go.mod` isolates dependencies.
+- Frontend static assets are packaged into the image at `/app/frontend`.
+
+### Grafana Embedding Support
+
+Grafana is already configured for embedding in `deploy/docker-compose/docker-compose.yml`:
+
+```yaml
+- GF_SECURITY_ALLOW_EMBEDDING=true
+- GF_SECURITY_COOKIE_SAMESITE=lax
 ```
 
-### Notes on Dockerfile
+The Dashboard reverse proxy will automatically clean up `X-Frame-Options` and adjust CSP headers to ensure the iframe loads correctly.
 
-- Multi-stage build (Go → distroless) defined in `dashboard/backend/Dockerfile`.
-- Standalone Go module in `dashboard/backend/go.mod` isolates dependencies.
-- Frontend static assets baked into the image under `/app/frontend`.
+### Health Check
 
-### Grafana embedding
+The Dashboard provides a `/healthz` endpoint for container health checks:
 
-- Root `docker-compose.yml` now sets `GF_SECURITY_ALLOW_EMBEDDING=true` for iframe usage.
-- If you need stricter policies, remove the flag and authenticate Grafana separately; the dashboard proxy will still sanitize frame headers but Grafana may block unauthenticated panels.
+```bash
+curl http://localhost:8700/healthz
+# Returns: {"status":"healthy","service":"semantic-router-dashboard"}
+```
 
 ## Notes
 

dashboard/backend/Dockerfile

@@ -1,18 +1,21 @@
 FROM golang:1.24 AS builder
 WORKDIR /app
-# Copy only module files first for layer caching
-COPY dashboard/backend/go.mod dashboard/backend/go.sum ./dashboard/backend/
-WORKDIR /app/dashboard/backend
-RUN go mod download
 # Copy source and frontend assets
-COPY dashboard/backend/ ./
+COPY dashboard/backend/ /app/dashboard/backend/
 COPY dashboard/frontend/ /app/dashboard/frontend/
+# Build the binary
+WORKDIR /app/dashboard/backend
+RUN go mod download || true
 RUN CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -o /app/dashboard-backend main.go
 
-FROM gcr.io/distroless/static:nonroot
+FROM alpine:3.19
+RUN apk --no-cache add ca-certificates wget
 WORKDIR /app
 COPY --from=builder /app/dashboard-backend /app/dashboard-backend
 COPY --from=builder /app/dashboard/frontend /app/frontend
+RUN addgroup -g 65532 nonroot && \
+    adduser -D -u 65532 -G nonroot nonroot && \
+    chown -R nonroot:nonroot /app
 EXPOSE 8700
 USER nonroot:nonroot
 ENTRYPOINT ["/app/dashboard-backend", "-port=8700", "-static=/app/frontend"]

dashboard/backend/main.go

@@ -115,10 +115,15 @@ func main() {
 
 	mux := http.NewServeMux()
 
-	// Static frontend
-	mux.Handle("/", staticFileServer(*staticDir))
+	// Health check endpoint
+	mux.HandleFunc("/healthz", func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(http.StatusOK)
+		w.Write([]byte(`{"status":"healthy","service":"semantic-router-dashboard"}`))
+	})
 
-	// Router API proxy (forward Authorization)
+	// Static frontend
+	mux.Handle("/", staticFileServer(*staticDir)) // Router API proxy (forward Authorization)
 	if *routerAPI != "" {
 		rp, err := newReverseProxy(*routerAPI, "/api/router", true)
 		if err != nil {

dashboard/deploy/docker/.gitkeep

@@ -11,9 +11,13 @@ services:
     volumes:
       - ../../config:/app/config:ro
       - ../../models:/app/models:ro
+      - ~/.cache/huggingface:/root/.cache/huggingface
     environment:
       - LD_LIBRARY_PATH=/app/lib
       - CONFIG_FILE=${CONFIG_FILE:-/app/config/config.yaml}
+      - HUGGINGFACE_HUB_CACHE=/root/.cache/huggingface
+      - HF_HUB_ENABLE_HF_TRANSFER=1
+      - HF_ENDPOINT=https://hf-mirror.com
     networks:
       - semantic-network
     healthcheck:
@@ -117,6 +121,39 @@ services:
       - semantic-network
     command: ["llm-katan", "--model", "Qwen/Qwen3-0.6B", "--host", "0.0.0.0", "--port", "8000"]
 
+  # Semantic Router Dashboard
+  dashboard:
+    build:
+      context: ../../
+      dockerfile: dashboard/backend/Dockerfile
+    image: semantic-router-dashboard:dev
+    container_name: semantic-router-dashboard
+    command: ["/app/dashboard-backend", "-port=8700", "-static=/app/frontend"]
+    environment:
+      - DASHBOARD_PORT=8700
+      - TARGET_GRAFANA_URL=http://grafana:3000
+      - TARGET_PROMETHEUS_URL=http://prometheus:9090
+      - TARGET_ROUTER_API_URL=http://semantic-router:8080
+      - TARGET_ROUTER_METRICS_URL=http://semantic-router:9190/metrics
+      - TARGET_OPENWEBUI_URL=${TARGET_OPENWEBUI_URL:-}
+    ports:
+      - "8700:8700"
+    networks:
+      - semantic-network
+    depends_on:
+      semantic-router:
+        condition: service_healthy
+      grafana:
+        condition: service_started
+      prometheus:
+        condition: service_started
+    healthcheck:
+      test: ["CMD", "wget", "--no-verbose", "--tries=1", "--spider", "http://localhost:8700/healthz"]
+      interval: 10s
+      timeout: 5s
+      retries: 3
+      start_period: 10s
+
 networks:
   semantic-network:
     driver: bridge