Skip to content

actyze/dashboard-docker

BranchesTags

Repository files navigation

Actyze — Docker Compose Deployment

Run Actyze on your local machine or a single host using Docker Compose. Perfect for evaluation, testing, and small production deployments.

License: AGPL v3 GitHub stars Latest Release Docker Pulls Docker Compose

Main repo · Helm charts · Documentation · Website

Who this is for

Actyze is built for three teams:

  • Teams already running Trino. The AI/BI layer your federation has been missing — natural-language queries, dashboards, and ML predictions on top of the catalogs you already have.
  • Metabase or Superset users. Add NL queries and no-code ML predictions without ripping out your stack.
  • Cortex / Genie escapees. Same AI capabilities — text-to-SQL, semantic understanding, predictions — on your own infrastructure, no per-credit pricing, no vendor lock-in.

AGPL v3, fully self-hosted, your data never leaves your network.

Quick Start

Get Actyze running in 5 minutes:

# 1. Clone this repository
git clone https://github.com/actyze/dashboard-docker.git
cd dashboard-docker

# 2. Configure your environment
cp env.example .env
nano .env  # Add your LLM API key

# 3. Start Actyze
./start.sh

# 4. Access Actyze
open http://localhost:3000

Default Login: nexus_admin / admin

What is Actyze?

Actyze is an AI-powered analytics platform that lets you query databases using natural language. No SQL knowledge required.

Key Capabilities:

  • Ask questions in plain English (supports 50+ languages)
  • Automatic SQL generation powered by AI
  • Connect to multiple data sources (PostgreSQL, MySQL, MongoDB, Snowflake, BigQuery, and more)
  • Upload CSV/Excel files for instant analysis
  • Scheduled KPIs — pre-aggregate metrics on a 1-24 hour schedule, materialized as queryable tables in kpi_data schema
  • Predictive Intelligence — ML predictions (forecast, classify, estimate) from KPI data with XGBoost, LightGBM, and AutoGluon
  • Role-based access control
  • Query caching for fast performance

Prerequisites

System Requirements:

  • Docker Desktop 20.10+ (or Docker Engine 20.10+)
  • Docker Compose 2.0+
  • 8GB+ RAM available for Docker
  • 10GB+ disk space

Required Credentials:

  • LLM API key (Anthropic Claude, OpenAI, Perplexity, or Groq)
  • Optional: Your database connection details

Verify Docker is ready:

docker --version  # Should be 20.10.0+
docker-compose --version  # Should be 2.0.0+

Architecture

Actyze runs as five containerized services, all pulled from Docker Hub:

┌─────────────────┐     ┌──────────────────┐     ┌─────────────────┐
│   Frontend      │────▶│   Nexus API      │────▶│   PostgreSQL    │
│   (React:3000)  │     │   (FastAPI:8000) │     │   (5432)        │
└─────────────────┘     └──────────────────┘     └─────────────────┘
                               │
                               │
                      ┌────────┴────────┐
                      ▼                 ▼
            ┌──────────────────┐  ┌──────────────────┐
            │  Schema Service  │  │  Trino Engine    │
            │  (FAISS:8001)    │  │  (8081)          │
            └──────────────────┘  └──────────────────┘
                      │
                      ▼
            ┌──────────────────┐
            │  Your LLM        │
            │  (Claude/GPT-4)  │
            └──────────────────┘

Core Services:

  • Frontend (port 3000): Web interface
  • Nexus (port 8000): API and AI orchestration
  • Schema Service (port 8001): Intelligent table recommendations
  • PostgreSQL (port 5432): Application database
  • Trino (port 8081): Connects to your data sources

Prediction Workers (optional, profile-gated):

  • XGBoost (port 8401): Tabular classification and regression
  • LightGBM (port 8402): Fast tabular predictions for large datasets
  • AutoGluon (port 8403): Time-series forecasting (ARIMA + ETS + Theta ensemble)
# Start with prediction workers
docker compose --profile local --profile predictions up -d

# Add time-series forecasting
docker compose --profile local --profile predictions-timeseries up -d

Installation

Step 1: Clone Repository

git clone https://github.com/actyze/dashboard-docker.git
cd dashboard-docker

Step 2: Configure Environment

# Copy the example configuration
cp env.example .env

# Edit with your settings
nano .env

Required Configuration:

# AI Provider (REQUIRED) - Choose one provider's API key
ANTHROPIC_API_KEY=your-api-key-here
EXTERNAL_LLM_MODEL=claude-sonnet-4-20250514

# Database Password (REQUIRED)
POSTGRES_PASSWORD=choose-a-secure-password

Optional - Connect Your Database:

# If you want to use external Trino
TRINO_HOST=your-trino-server.com
TRINO_PORT=443
TRINO_SSL=true
TRINO_SSL_VERIFY=false  # Set to false for self-signed certificates

See Configuration Guide for all options.

Step 3: Start Actyze

# Start all services
./start.sh

# Wait for all services to become healthy (30-60 seconds)
# You'll see: "All services are healthy!"

Step 4: Access Actyze

Open your browser:

Login with default credentials:

  • Username: nexus_admin
  • Password: admin

Change the default password immediately after first login.

Configuration

AI Providers

Actyze supports 100+ AI providers via LiteLLM. Just set the provider's API key and model name - everything else is automatic.

Anthropic Claude (Recommended):

ANTHROPIC_API_KEY=sk-ant-xxxxx
EXTERNAL_LLM_MODEL=claude-sonnet-4-20250514

OpenAI:

OPENAI_API_KEY=sk-xxxxx
EXTERNAL_LLM_MODEL=gpt-4o

Google Gemini:

GEMINI_API_KEY=your-key
EXTERNAL_LLM_MODEL=gemini/gemini-pro

Perplexity:

PERPLEXITY_API_KEY=pplx-xxxxx
EXTERNAL_LLM_MODEL=perplexity/sonar-reasoning-pro

Groq (Free tier available):

GROQ_API_KEY=gsk_xxxxx
EXTERNAL_LLM_MODEL=groq/llama-3.3-70b-versatile

Enterprise Gateway (for IT-managed AI):

EXTERNAL_LLM_MODE=openai-compatible
EXTERNAL_LLM_BASE_URL=https://llm-gateway.company.com/v1/chat/completions
EXTERNAL_LLM_API_KEY=your-enterprise-token
EXTERNAL_LLM_MODEL=your-internal-model

See Full Provider List:

Database Connections

Use Local PostgreSQL (Default):

  • Included with Actyze
  • No additional configuration needed
  • Starts automatically with ./start.sh

Use External Trino:

TRINO_HOST=your-trino-server.com
TRINO_PORT=443
TRINO_USER=your-username
TRINO_PASSWORD=your-password
TRINO_SSL=true
TRINO_SSL_VERIFY=false  # Set to false for self-signed certificates
TRINO_CATALOG=your-catalog
TRINO_SCHEMA=your-schema

Configure Trino to connect to your databases: See trino/ directory for connector configurations (PostgreSQL, MySQL, MongoDB, Snowflake, etc.)

Scheduled KPI Settings

# How often the scheduler checks for KPIs due for collection (seconds)
KPI_COLLECTION_INTERVAL_SECONDS=300   # Default: 5 minutes

KPI collection intervals (1-24 hours) are configured per-KPI in the UI. This setting controls how frequently the scheduler checks for due KPIs.

Performance Settings

# Query caching (recommended)
CACHE_ENABLED=true
CACHE_QUERY_MAX_SIZE=100      # Cache up to 100 queries
CACHE_QUERY_TTL=1800           # Cache for 30 minutes

# Logging
LOG_LEVEL=INFO  # Options: DEBUG, INFO, WARNING, ERROR
DEBUG=false     # Set to true for detailed logs

Usage

Basic Commands

# Start Actyze
./start.sh

# Stop Actyze (preserves data)
./stop.sh

# Stop and remove all data
./stop.sh --clean

# View logs
docker-compose logs -f

# View logs for specific service
docker-compose logs -f nexus

# Check service status
docker-compose ps

Deployment Profiles

Choose which services to run:

Local (Default) - All services:

./start.sh
# Runs: PostgreSQL, Trino, Schema Service, Nexus, Frontend

External Databases - Connect to your existing infrastructure:

# Configure external databases in .env first
./start.sh --profile external
# Runs: Schema Service, Nexus, Frontend
# Connects to: Your external PostgreSQL and Trino

Mixed - Local PostgreSQL + External Trino:

./start.sh --profile postgres-only

Using Actyze

1. Login

2. Connect Your Data

  • Click "Data Sources"
  • Add Trino connection or upload CSV/Excel files

3. Ask Questions

  • Type your question in natural language
  • Examples:
    • "What were our total sales last quarter?"
    • "Show top 10 customers by revenue"
    • "List all orders from this week"
  • Click "Generate SQL" and "Execute"

4. Save and Share

  • Save queries for later
  • Create dashboards
  • Share with team members (configure RBAC in Settings)

Troubleshooting

Services Won't Start

Check Docker resources:

docker info | grep "Total Memory"
# Should show 8GB+ available

# Increase in Docker Desktop: Preferences → Resources → Memory

Check logs:

docker-compose logs nexus
docker-compose logs schema-service

Port Conflicts

Error: "port is already allocated"

Solution:

# Find what's using the port
lsof -i :3000

# Stop the conflicting service or change ports in docker-compose.yml

Database Connection Failed

# Verify configuration
cat .env | grep POSTGRES

# Reset and restart
./stop.sh --clean
./start.sh

LLM API Errors

Check your API key:

cat .env | grep API_KEY

Test the API key directly:

# For Anthropic
curl https://api.anthropic.com/v1/messages \
  -H "x-api-key: YOUR_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "content-type: application/json" \
  -d '{"model":"claude-sonnet-4-20250514","max_tokens":100,"messages":[{"role":"user","content":"test"}]}'

Slow Performance

Enable caching:

# In .env
CACHE_ENABLED=true

Use faster LLM models:

# Groq is very fast (and free)
EXTERNAL_LLM_PROVIDER=groq
EXTERNAL_LLM_MODEL=mixtral-8x7b-32768

Get Help

Check service health:

curl http://localhost:3000          # Frontend
curl http://localhost:8000/health   # Nexus
curl http://localhost:8001/health   # Schema Service

Review logs:

docker-compose logs -f

Documentation:

Support:

Updating Actyze

# Stop current version
./stop.sh

# Pull latest images
docker-compose pull

# Start updated version
./start.sh

Docker Compose automatically pulls the latest images from Docker Hub when you restart.

Production Deployment

This Docker Compose setup is designed for local use, evaluation, and testing.

For production deployments, use Kubernetes with Helm charts:

Additional Documentation

Related Resources

Build from Source

Instead of pulling pre-built images from Docker Hub, you can build locally:

# Clone the main dashboard repository
git clone https://github.com/actyze/dashboard.git
cd dashboard

# Build images locally
docker build -t actyze/dashboard-frontend:local ./frontend
docker build -t actyze/dashboard-nexus:local ./nexus
docker build -t actyze/dashboard-schema-service:local ./schema-service

Then override the image versions in your .env:

FRONTEND_VERSION=local
NEXUS_VERSION=local
SCHEMA_SERVICE_VERSION=local

Related Repositories

  • actyze/dashboard — primary monorepo (frontend, Nexus API, schema service, source of all images used here)
  • actyze/helm-charts — production Helm charts for Kubernetes deployments

License

AGPL-3.0-or-later

About

Docker Compose deployment for Actyze — open-source self-hosted AI analytics. NL→SQL, federated queries via Trino, ML predictions, voice. AGPL v3.

docs.actyze.io

Topics

docker docker-compose self-hosted agpl business-intelligence trino federated-query text-to-sql nl2sql llm ai-analytics actyze

Resources

Readme

License

AGPL-3.0 license
Activity
Custom properties

Stars

5 stars

Watchers

0 watching

Forks

0 forks
Report repository

Releases

No releases published

Packages

 
 
 

Contributors

Languages