Quickstart

Get CoreCube running with Docker Compose and connect your first AI client.

Prerequisites

Docker Desktop or Docker Engine with Compose
An LLM API key (Anthropic or OpenAI), or a self-hosted model endpoint

1. Start CoreCube

Create a docker-compose.yml:

services:
  corecube:
    image: registry.arantic.cloud/corecube/corecube:latest
    ports:
      - '7400:7400'
    environment:
      CUBE_ADMIN_EMAIL: admin@example.com
      CUBE_ADMIN_PASSWORD: changeme123
      PGVECTOR_URL: postgresql://corecube:changeme123@pgvector:5432/corecube
      PGVECTOR_APP_URL: postgresql://corecube_app:changeme123@pgvector:5432/corecube
      PGVECTOR_MAINTENANCE_URL: postgresql://corecube_maintenance:changeme123@pgvector:5432/corecube
      # Local inference sidecars (embedding + reranking) — embeds documents without a cloud key
      INFERENCE_EMBEDDING_URL: http://inf-embedding:9440
      INFERENCE_RERANKER_URL: http://inf-reranker:9450
      # Object storage — required for Library uploads and OCR
      STORAGE_ENDPOINT: s3storage
      STORAGE_PORT: '8333'
      STORAGE_USE_SSL: 'false'
      STORAGE_ACCESS_KEY: corecube
      STORAGE_SECRET_KEY: corecube_secret_key_change_me
      STORAGE_REGION: eu-west-1
      # Browser-reachable URL for presigned uploads
      STORAGE_PUBLIC_ENDPOINT: http://localhost:8333
      # Sandbox executor (Unix-socket IPC)
      CC_EXECUTOR_SOCKET_PATH: /run/corecube/executor.sock
    volumes:
      - corecube-data:/data
      - executor-socket:/run/corecube
    depends_on:
      pgvector:
        condition: service_healthy
      s3storage:
        condition: service_healthy
      executor:
        condition: service_healthy

  pgvector:
    image: pgvector/pgvector:pg17
    environment:
      POSTGRES_USER: corecube
      POSTGRES_PASSWORD: changeme123
      POSTGRES_DB: corecube
    volumes:
      - pgvector-data:/var/lib/postgresql/data
    healthcheck:
      test: ['CMD-SHELL', 'pg_isready -U corecube -d corecube']
      interval: 10s
      timeout: 5s
      retries: 5

  # SeaweedFS object store — holds original uploaded files (Library + OCR re-scan)
  s3storage:
    image: chrislusf/seaweedfs:4.22
    command:
      [
        'server',
        '-dir=/data',
        '-filer',
        '-s3',
        '-s3.config=/etc/s3storage/s3.json',
        '-volume.max=0',
        '-master.volumeSizeLimitMB=1024',
        '-volume.index=leveldb',
        '-master.volumePreallocate',
        '-filer.concurrentUploadLimitMB=100',
        '-s3.allowEmptyFolder=true',
      ]
    ports:
      - '8333:8333' # S3 API (browser-facing presigned PUT)
    volumes:
      - s3storage-data:/data
      - ./s3.json:/etc/s3storage/s3.json:ro
    healthcheck:
      test:
        ['CMD', 'wget', '--no-verbose', '--tries=1', '--spider', 'http://127.0.0.1:9333/dir/status']
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 30s

  # Sandbox that runs configured code tools — the app waits for it to be healthy
  executor:
    image: registry.arantic.cloud/corecube/corecube-executor:latest
    environment:
      CC_EXECUTOR_SOCKET_PATH: /run/corecube/executor.sock
    read_only: true
    tmpfs:
      - /tmp:noexec,nosuid,nodev,size=64m
    network_mode: 'none'
    user: '65532:65532'
    volumes:
      - executor-socket:/run/corecube
    healthcheck:
      test: ['CMD', '/usr/local/bin/healthz.sh']
      interval: 5s
      timeout: 2s
      retries: 5
      start_period: 10s

  # Local inference sidecars — embedding and reranking, no external API key needed
  inf-embedding:
    image: registry.arantic.cloud/corecube/corecube-inference:cpu-latest
    expose:
      - '9440'
    environment:
      HF_HOME: /data/hf-cache
      INFERENCE_ROLE: embedding
      DEVICE: cpu
    volumes:
      - ./inference/hf-cache:/data/hf-cache

  inf-reranker:
    image: registry.arantic.cloud/corecube/corecube-inference:cpu-latest
    expose:
      - '9450'
    environment:
      HF_HOME: /data/hf-cache
      INFERENCE_ROLE: reranker
      DEVICE: cpu
    volumes:
      - ./inference:/data

volumes:
  corecube-data:
  pgvector-data:
  s3storage-data:
  executor-socket:

The s3storage service needs an access-key file next to your docker-compose.yml. Create s3.json:

{
  "identities": [
    {
      "name": "corecube",
      "credentials": [{ "accessKey": "corecube", "secretKey": "corecube_secret_key_change_me" }],
      "actions": ["Admin", "Read", "Write"]
    }
  ]
}

Start the stack:

docker compose up -d

CoreCube will be available at http://localhost:7400/admin.

Change default credentials

Change the default email and password immediately after first login. Go to your profile icon → Profile → update your password.

2. Configure an LLM Model

Open the Admin Console at http://localhost:7400/admin
Navigate to Query Pipeline → LLM Models
Select Add Model — for example, Anthropic Claude:
- Provider: Anthropic
- API Key: your Anthropic API key
- Model: claude-sonnet-4-5 (or your preferred model)
Save and test the connection

3. Apply the Orchestrator

Navigate to Configuration → Orchestrator
On the LLM tab, select the ready model you just added
Review the seeded Fast, Balanced, and Accurate policies on the Modes tab
Select Save
Resolve any validation or readiness notice, then select Apply

Save stores the editable configuration. Apply creates the immutable snapshot used by new answer turns.

4. Add your first connection

Navigate to Connections
Click New Connection
Select a source (e.g., Confluence, Jira, or File Upload)
Configure authentication and source filtering
Assign a compartment and sensitivity level
Save and click Sync Now

CoreCube will begin ingesting, sanitizing, chunking, and embedding your documents in the background.

5. Create an API key

Navigate to System → API Keys
Click New API Key
Give it a name (e.g., "OpenWebUI")
Assign a scope that includes the connections you want the client to access
Copy the key — it is shown only once

6. Connect an AI client

OpenWebUI

In OpenWebUI settings, configure a new OpenAI-compatible connection:

API Base URL: http://localhost:7400/v1
API Key: your CoreCube API key

Select the CoreCube model from the list. CoreCube keeps the internal Orchestrator model binding behind one OpenAI-compatible service entry.

Direct API

curl http://localhost:7400/v1/chat/completions \
  -H "Authorization: Bearer cc_YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "messages": [{"role": "user", "content": "What do our deployment runbooks say about rollbacks?"}],
    "stream": false
  }'

7. Explore query results

Use the Query Explorer in the Admin Console to inspect how CoreCube retrieves and ranks context for any query:

Score breakdown per chunk (vector, FTS, freshness, combined)
Which connections were included or excluded
Which Orchestrator mode and Pipeline ran
Context assembly trace (which chunks were selected, filtered, deduplicated)

Next steps

Configure connectors to automate knowledge ingestion
Configure the Orchestrator to select the answer model and retrieval policies
Review Pipelines to understand the seeded retrieval strategies
Set up access control with compartments and scopes
Configure LLM models, then select one in the Orchestrator
Review the API reference for all available endpoints

Prerequisites​

1. Start CoreCube​

2. Configure an LLM Model​

3. Apply the Orchestrator​

4. Add your first connection​

5. Create an API key​

6. Connect an AI client​

OpenWebUI​

Direct API​

7. Explore query results​

Next steps​