Skip to main content

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 preset 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 provider​

  1. Open the Admin Console at http://localhost:7400/admin
  2. Navigate to LLM Providers
  3. Add a provider — for example, Anthropic Claude:
    • Provider: Anthropic
    • API Key: your Anthropic API key
    • Model: claude-sonnet-4-5 (or your preferred model)
  4. Save and test the connection

3. Add your first connection​

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

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

4. Create an API key​

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

5. 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 any model from the list — CoreCube serves its configured LLM providers through a unified model listing.

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
  }'

6. 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 preset pipeline ran (query tools, default retrieval, chunk tools)
  • Context assembly trace (which chunks were selected, filtered, deduplicated)

Next steps​

We use cookies for analytics to improve our website. More information in our Privacy Policy.