container-superposition 0.1.6 → 0.1.8

package/overlays/postgres/.env.example

@@ -1,6 +1,6 @@
 # PostgreSQL Configuration
-POSTGRES_VERSION=16
-POSTGRES_DB=devdb
-POSTGRES_USER=postgres
-POSTGRES_PASSWORD=postgres
-POSTGRES_PORT=5432
+POSTGRES_VERSION={{cs.POSTGRES_VERSION}}
+POSTGRES_DB={{cs.POSTGRES_DB}}
+POSTGRES_USER={{cs.POSTGRES_USER}}
+POSTGRES_PASSWORD={{cs.POSTGRES_PASSWORD}}
+POSTGRES_PORT={{cs.POSTGRES_PORT}}

package/overlays/postgres/devcontainer.patch.json

@@ -13,9 +13,9 @@
     },
     "remoteEnv": {
         "POSTGRES_HOST": "postgres",
-        "POSTGRES_PORT": "5432",
-        "POSTGRES_DB": "devdb",
-        "POSTGRES_USER": "postgres",
-        "POSTGRES_PASSWORD": "postgres"
+        "POSTGRES_PORT": "{{cs.POSTGRES_PORT}}",
+        "POSTGRES_DB": "{{cs.POSTGRES_DB}}",
+        "POSTGRES_USER": "{{cs.POSTGRES_USER}}",
+        "POSTGRES_PASSWORD": "{{cs.POSTGRES_PASSWORD}}"
     }
 }

package/overlays/postgres/docker-compose.yml

@@ -2,18 +2,28 @@ version: '3.8'
 
 services:
     postgres:
-        image: postgres:${POSTGRES_VERSION:-16}-alpine
+        image: postgres:${POSTGRES_VERSION:-{{cs.POSTGRES_VERSION}}}-alpine
         restart: unless-stopped
         volumes:
             - postgres-data:/var/lib/postgresql/data
         environment:
-            POSTGRES_DB: ${POSTGRES_DB:-devdb}
-            POSTGRES_USER: ${POSTGRES_USER:-postgres}
-            POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:-postgres}
+            POSTGRES_DB: ${POSTGRES_DB:-{{cs.POSTGRES_DB}}}
+            POSTGRES_USER: ${POSTGRES_USER:-{{cs.POSTGRES_USER}}}
+            POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:-{{cs.POSTGRES_PASSWORD}}}
         ports:
-            - '${POSTGRES_PORT:-5432}:5432'
+            - '${POSTGRES_PORT:-{{cs.POSTGRES_PORT}}}:5432'
         networks:
             - devnet
+        healthcheck:
+            test:
+                [
+                    'CMD-SHELL',
+                    'pg_isready -U ${POSTGRES_USER:-{{cs.POSTGRES_USER}}} -d ${POSTGRES_DB:-{{cs.POSTGRES_DB}}}',
+                ]
+            interval: 10s
+            timeout: 5s
+            retries: 5
+            start_period: 10s
 
 volumes:
     postgres-data:

package/overlays/postgres/overlay.yml

@@ -6,7 +6,8 @@ supports:
     - compose
 requires: []
 suggests: []
-conflicts: []
+conflicts:
+    - pgvector
 tags:
     - database
     - sql
@@ -18,3 +19,20 @@ ports:
       description: PostgreSQL database connection
       onAutoForward: notify
       connectionStringTemplate: 'postgresql://{postgres_user}:{postgres_password}@{host}:{port}/{postgres_db}'
+parameters:
+    POSTGRES_DB:
+        description: Name of the database to create
+        default: devdb
+    POSTGRES_USER:
+        description: PostgreSQL superuser name
+        default: postgres
+    POSTGRES_PASSWORD:
+        description: PostgreSQL superuser password
+        default: postgres
+        sensitive: true
+    POSTGRES_PORT:
+        description: Host port mapped to PostgreSQL (5432 inside container)
+        default: '5432'
+    POSTGRES_VERSION:
+        description: PostgreSQL major version
+        default: '16'

package/overlays/powershell/setup.sh

@@ -5,25 +5,61 @@ set -e
 
 echo "🔧 Setting up PowerShell development environment..."
 
-# Verify PowerShell is installed
-if command -v pwsh &> /dev/null; then
-    PWSH_VERSION=$(pwsh -NoProfile -Command '$PSVersionTable.PSVersion.ToString()')
-    echo "✓ PowerShell found: v$PWSH_VERSION"
-else
+# Verify PowerShell is installed and responds within 10 s.
+# If pwsh doesn't respond quickly (e.g. shared library issue, slow startup),
+# there is no point proceeding — all subsequent pwsh calls would also hang.
+if ! command -v pwsh &>/dev/null; then
     echo "⚠️ PowerShell not found"
     exit 1
 fi
 
-# Install common PowerShell modules
-echo "📦 Installing PowerShell modules..."
+# --kill-after ensures pwsh child processes are SIGKILL-ed after grace period.
+PWSH_VERSION=$(timeout --kill-after=5s 10s \
+    pwsh -NoProfile -NonInteractive -Command '$PSVersionTable.PSVersion.ToString()' \
+    2>/dev/null) || true
+
+if [ -z "$PWSH_VERSION" ]; then
+    echo "⚠️ pwsh did not respond within 10 s — skipping module installation"
+    echo "✓ PowerShell setup complete (modules skipped)"
+    exit 0
+fi
 
-# PSScriptAnalyzer (Linting and best practices)
-pwsh -NoProfile -Command 'Install-Module -Name PSScriptAnalyzer -Force -Scope CurrentUser -AllowClobber' || echo "⚠️ PSScriptAnalyzer installation failed"
+echo "✓ PowerShell found: v$PWSH_VERSION"
+
+# Trust PSGallery non-interactively.
+# PowerShell 7+ bundles the NuGet provider — Install-PackageProvider is not
+# needed and will fail with "No match found" on PS7.  Call it only on PS5.
+echo "🔧 Configuring PSGallery..."
+timeout --kill-after=5s 60s \
+    pwsh -NoProfile -NonInteractive -Command '
+        $major = $PSVersionTable.PSVersion.Major
+        if ($major -lt 7) {
+            Install-PackageProvider -Name NuGet -MinimumVersion 2.8.5.201 -Force -Scope CurrentUser | Out-Null
+        }
+        Set-PSRepository -Name PSGallery -InstallationPolicy Trusted
+    ' || echo "⚠️ Failed to configure PSGallery (network may be unavailable) — skipping modules"
+
+# Install common PowerShell modules.
+# Each module runs in its own pwsh call with a per-module timeout so a slow
+# PSGallery download doesn't block the remaining modules.
+echo "📦 Installing PowerShell modules..."
 
-# Pester (Testing framework)
-pwsh -NoProfile -Command 'Install-Module -Name Pester -Force -Scope CurrentUser -AllowClobber -SkipPublisherCheck' || echo "⚠️ Pester installation failed"
+_install_psmodule() {
+    local name="$1"; shift   # remaining args passed as extra Install-Module params
+    local extra="$*"
+    timeout --kill-after=5s 90s \
+        pwsh -NoProfile -NonInteractive -Command "
+            try {
+                Install-Module -Name '$name' -Force -Scope CurrentUser -AllowClobber -Repository PSGallery $extra -ErrorAction Stop
+                Write-Host '  ✓  $name'
+            } catch {
+                Write-Host '  ⚠️  $name failed: ' + \$_
+            }
+        " 2>/dev/null || echo "  ⚠️  $name timed out"
+}
 
-# PowerShellGet (Module management)
-pwsh -NoProfile -Command 'Install-Module -Name PowerShellGet -Force -Scope CurrentUser -AllowClobber' || echo "⚠️ PowerShellGet installation failed"
+_install_psmodule PSScriptAnalyzer
+_install_psmodule Pester           -SkipPublisherCheck
+_install_psmodule PowerShellGet
 
 echo "✓ PowerShell setup complete"

package/overlays/pre-commit/setup.sh

@@ -5,10 +5,19 @@ set -e
 
 echo "🔍 Setting up pre-commit framework..."
 
-# Install pre-commit using pip
-pip install --user pre-commit
+# Install pre-commit — prefer pipx (avoids --user conflicts inside virtualenvs)
+if command -v pipx &> /dev/null; then
+    pipx install pre-commit
+elif command -v pip3 &> /dev/null; then
+    pip3 install pre-commit 2>/dev/null || pip3 install --break-system-packages pre-commit
+elif command -v pip &> /dev/null; then
+    pip install pre-commit 2>/dev/null || pip install --break-system-packages pre-commit
+else
+    echo "✗ No pip/pipx found — cannot install pre-commit"
+    exit 1
+fi
 
-# Add to PATH if not already there
+# pipx installs to ~/.local/bin
 export PATH="$HOME/.local/bin:$PATH"
 
 # Verify installation

package/overlays/prometheus/overlay.yml

@@ -20,3 +20,5 @@ ports:
       path: /
       onAutoForward: openBrowser
 order: 1
+imports:
+    - .shared/otel/instrumentation.env

package/overlays/promtail/verify.sh

@@ -6,19 +6,25 @@ echo "🔍 Verifying Promtail installation..."
 # Track overall success
 ALL_CHECKS_PASSED=true
 
-# Check if Promtail service is running
-if docker ps --format '{{.Names}}' | grep -q promtail; then
-    echo "✓ Promtail service is running"
-else
-    echo "✗ Promtail service is not running"
+# Wait for Promtail /ready endpoint (primary health signal).
+# docker ps is informational only — not reliably accessible in all devcontainers.
+PROMTAIL_READY=false
+for i in {1..40}; do
+    if curl -s -o /dev/null -w "%{http_code}" http://promtail:3101/ready 2>/dev/null | grep -q "200"; then
+        echo "✓ Promtail is ready (HTTP /ready)"
+        PROMTAIL_READY=true
+        break
+    fi
+    sleep 3
+done
+if [ "$PROMTAIL_READY" = false ]; then
+    echo "✗ Promtail /ready endpoint not responding after 120 s (http://promtail:3101/ready)"
     ALL_CHECKS_PASSED=false
 fi
 
-# Check if Promtail can access Docker socket
-if docker exec promtail test -S /var/run/docker.sock 2>/dev/null; then
-    echo "✓ Promtail has access to Docker socket"
-else
-    echo "⚠️ Promtail cannot access Docker socket"
+# Informational: check via docker ps if available.
+if docker ps --format '{{.Names}}' 2>/dev/null | grep -q promtail; then
+    echo "✓ Promtail container visible in docker ps"
 fi
 
 # Final result

package/overlays/pulumi/devcontainer.patch.json

@@ -1,7 +1,7 @@
 {
     "$schema": "https://raw.githubusercontent.com/devcontainers/spec/main/schemas/devContainer.base.schema.json",
     "features": {
-        "ghcr.io/devcontainers/features/pulumi:1": {
+        "ghcr.io/devcontainers-extra/features/pulumi:1": {
             "version": "latest"
         }
     },

package/overlays/python/setup.sh

@@ -13,6 +13,23 @@ WORKSPACE_ROOT="${PWD}"
 VENV_DIR="${WORKSPACE_ROOT}/.venv"
 
 # Create virtual environment if it doesn't exist
+# Helper: validate that the venv's Python interpreter is actually executable.
+# A stale .venv (e.g., leftover from a previous container build) can have a
+# bin/python that is a dangling symlink, causing "cannot execute: required
+# file not found" when pip or other venv scripts are invoked.
+venv_is_valid() {
+    "${VENV_DIR}/bin/python" -c "import sys" &>/dev/null
+}
+
+if [ -d "${VENV_DIR}" ]; then
+    if venv_is_valid; then
+        echo "✓ Virtual environment already exists at .venv"
+    else
+        echo "⚠️  Existing .venv is invalid (stale interpreter), recreating..."
+        rm -rf "${VENV_DIR}"
+    fi
+fi
+
 if [ ! -d "${VENV_DIR}" ]; then
     echo "📦 Creating virtual environment at .venv..."
     if ! command -v python3 >/dev/null 2>&1; then
@@ -21,49 +38,51 @@ if [ ! -d "${VENV_DIR}" ]; then
     fi
     python3 -m venv "${VENV_DIR}"
     echo "✓ Virtual environment created"
-else
-    echo "✓ Virtual environment already exists at .venv"
 fi
 
-# Activate virtual environment
+# Use the venv's Python directly to invoke pip — this is more robust than
+# calling the pip wrapper script, whose shebang can point to a stale path.
+PYTHON="${VENV_DIR}/bin/python"
+
+# Activate virtual environment for PATH and VIRTUAL_ENV
 # shellcheck source=/dev/null
 source "${VENV_DIR}/bin/activate"
 
 # Upgrade pip, setuptools, and wheel inside the venv
 echo "⬆️  Upgrading pip, setuptools, and wheel..."
-pip install --upgrade pip setuptools wheel
+"${PYTHON}" -m pip install --upgrade pip setuptools wheel
 echo "✓ pip, setuptools, and wheel upgraded"
 
 # Install overlay-specific packages (if requirements-overlay.txt exists)
 if [ -f ".devcontainer/requirements-overlay-${OVERLAY_NAME}.txt" ]; then
     echo "📦 Installing overlay packages from requirements-overlay-${OVERLAY_NAME}.txt..."
-    pip install -r ".devcontainer/requirements-overlay-${OVERLAY_NAME}.txt"
+    "${PYTHON}" -m pip install -r ".devcontainer/requirements-overlay-${OVERLAY_NAME}.txt"
     echo "✓ Overlay packages installed"
 fi
 
 # Install from root requirements.txt (project production dependencies)
 if [ -f "requirements.txt" ]; then
     echo "📦 Installing dependencies from requirements.txt..."
-    pip install -r requirements.txt
+    "${PYTHON}" -m pip install -r requirements.txt
     echo "✓ Dependencies installed from requirements.txt"
 fi
 
 # Install from requirements-dev.txt (project development dependencies)
 if [ -f "requirements-dev.txt" ]; then
     echo "📦 Installing dev dependencies from requirements-dev.txt..."
-    pip install -r requirements-dev.txt
+    "${PYTHON}" -m pip install -r requirements-dev.txt
     echo "✓ Dev dependencies installed from requirements-dev.txt"
 fi
 
 # Install project in editable mode if pyproject.toml exists (modern Python projects)
 if [ -f "pyproject.toml" ]; then
     echo "📦 Found pyproject.toml, installing project in editable mode..."
-    pip install -e .
+    "${PYTHON}" -m pip install -e .
     echo "✓ Project installed in editable mode"
 elif [ -f "setup.py" ]; then
     # Fallback for legacy Python projects
     echo "📦 Found setup.py, installing project in editable mode..."
-    pip install -e .
+    "${PYTHON}" -m pip install -e .
     echo "✓ Project installed in editable mode"
 fi
 

package/overlays/python/verify.sh

@@ -18,10 +18,12 @@ else
 fi
 
 # Check pip is installed
+# Use `python3 -m pip` instead of calling pip3 directly — the wrapper script
+# inside a .venv has a shebang that can point to a stale interpreter path.
 echo ""
 echo "2️⃣ Checking pip..."
-if command -v pip3 &> /dev/null; then
-    pip3 --version
+if python3 -m pip --version &> /dev/null; then
+    python3 -m pip --version
     echo "   ✅ pip found"
 else
     echo "   ❌ pip not found"

package/overlays/qdrant/.env.example

@@ -0,0 +1,4 @@
+# Qdrant Configuration
+QDRANT_VERSION={{cs.QDRANT_VERSION}}
+QDRANT_PORT={{cs.QDRANT_PORT}}
+QDRANT_GRPC_PORT={{cs.QDRANT_GRPC_PORT}}

package/overlays/qdrant/README.md

@@ -0,0 +1,216 @@
+# Qdrant Overlay
+
+Adds [Qdrant](https://qdrant.tech) as a Docker Compose service, providing a high-performance vector database for similarity search and embedding-based retrieval.
+
+## Features
+
+- **Qdrant vector database** — Store, index, and query high-dimensional embedding vectors at scale
+- **REST API on port 6333** — Full-featured HTTP API for collections, points, and search
+- **gRPC API on port 6334** — High-throughput binary protocol for production workloads
+- **Persistent storage** — Named Docker volume preserves data across container rebuilds
+- **Pre-configured `QDRANT_URL`** — Container environment variable set for easy SDK usage
+- **Health check** — Compose readiness check against `/readyz` before dependent services start
+
+## How It Works
+
+Qdrant runs as a Docker Compose service alongside your devcontainer. The devcontainer connects to it using the hostname `qdrant` on port `6333` (REST) or `6334` (gRPC).
+
+**Service configuration:**
+
+- Image: `qdrant/qdrant:latest`
+- Network: `devnet` (shared with the dev container)
+- Ports: `6333` (REST API), `6334` (gRPC)
+- Volume: `qdrant-data` for persistent vector storage
+
+The following environment variables are pre-set in the devcontainer:
+
+| Variable      | Value                |
+| ------------- | -------------------- |
+| `QDRANT_HOST` | `qdrant`             |
+| `QDRANT_PORT` | `6333`               |
+| `QDRANT_URL`  | `http://qdrant:6333` |
+
+## Common Commands
+
+### REST API
+
+```bash
+# Health check
+curl http://qdrant:6333/healthz
+
+# Create a collection
+curl -X PUT http://qdrant:6333/collections/my_collection \
+  -H "Content-Type: application/json" \
+  -d '{
+    "vectors": {
+      "size": 1536,
+      "distance": "Cosine"
+    }
+  }'
+
+# Insert points
+curl -X PUT http://qdrant:6333/collections/my_collection/points \
+  -H "Content-Type: application/json" \
+  -d '{
+    "points": [
+      {
+        "id": 1,
+        "vector": [0.1, 0.2, 0.3],
+        "payload": {"text": "example document"}
+      }
+    ]
+  }'
+
+# Search for similar vectors
+curl -X POST http://qdrant:6333/collections/my_collection/points/search \
+  -H "Content-Type: application/json" \
+  -d '{
+    "vector": [0.1, 0.2, 0.3],
+    "limit": 5
+  }'
+
+# List collections
+curl http://qdrant:6333/collections
+```
+
+### Python SDK
+
+```bash
+pip install qdrant-client
+
+python - <<'EOF'
+from qdrant_client import QdrantClient
+from qdrant_client.models import Distance, VectorParams, PointStruct
+
+client = QdrantClient(url="http://qdrant:6333")
+
+# Create collection
+client.create_collection(
+    collection_name="my_collection",
+    vectors_config=VectorParams(size=1536, distance=Distance.COSINE),
+)
+
+# Insert vectors
+client.upsert(
+    collection_name="my_collection",
+    points=[
+        PointStruct(id=1, vector=[0.1] * 1536, payload={"text": "hello"})
+    ],
+)
+
+# Search
+results = client.search(
+    collection_name="my_collection",
+    query_vector=[0.1] * 1536,
+    limit=5,
+)
+print(results)
+EOF
+```
+
+### Node.js SDK
+
+```bash
+npm install @qdrant/js-client-rest
+
+node - <<'EOF'
+import { QdrantClient } from "@qdrant/js-client-rest";
+
+const client = new QdrantClient({ url: "http://qdrant:6333" });
+
+await client.createCollection("my_collection", {
+  vectors: { size: 1536, distance: "Cosine" },
+});
+
+const results = await client.search("my_collection", {
+  vector: Array(1536).fill(0.1),
+  limit: 5,
+});
+console.log(results);
+EOF
+```
+
+## Configuration
+
+### Environment Variables
+
+| Variable           | Default  | Description             |
+| ------------------ | -------- | ----------------------- |
+| `QDRANT_VERSION`   | `latest` | Qdrant Docker image tag |
+| `QDRANT_PORT`      | `6333`   | Host port for REST API  |
+| `QDRANT_GRPC_PORT` | `6334`   | Host port for gRPC API  |
+
+### Port Customization
+
+```bash
+# .devcontainer/.env
+QDRANT_PORT=6335
+QDRANT_GRPC_PORT=6336
+```
+
+## Use Cases
+
+- **RAG (Retrieval-Augmented Generation)** — Store embeddings for document chunks; retrieve context for LLM queries
+- **Semantic search** — Find similar documents, images, or code snippets by embedding similarity
+- **Recommendation systems** — Surface similar items based on learned embeddings
+- **Anomaly detection** — Identify outliers in high-dimensional embedding spaces
+- **Local AI pipelines** — Pair with `ollama` for fully offline embedding + retrieval workflows
+
+**Integrates well with:**
+
+- `ollama` — Generate embeddings locally (`ollama pull nomic-embed-text`)
+- `python` — LangChain, LlamaIndex, or raw `qdrant-client` integrations
+- `nodejs` — `@qdrant/js-client-rest` for JavaScript embeddings workflows
+
+## Troubleshooting
+
+### Service Not Ready
+
+```bash
+# Check service status
+docker compose ps qdrant
+
+# View Qdrant logs
+docker compose logs qdrant
+
+# Test health endpoint
+curl http://qdrant:6333/healthz
+```
+
+### Port Conflict
+
+If ports 6333 or 6334 are already in use:
+
+```bash
+# .devcontainer/.env
+QDRANT_PORT=6335
+QDRANT_GRPC_PORT=6336
+```
+
+### Data Persistence
+
+Qdrant data is stored in the `qdrant-data` named Docker volume. It persists across container rebuilds but is scoped to the Docker environment:
+
+```bash
+# Inspect the volume
+docker volume inspect qdrant-data
+
+# Backup data
+docker run --rm -v qdrant-data:/data -v $(pwd):/backup alpine \
+  tar czf /backup/qdrant-backup.tar.gz /data
+```
+
+## References
+
+- [Qdrant Documentation](https://qdrant.tech/documentation/)
+- [Qdrant REST API Reference](https://qdrant.github.io/qdrant/redoc/index.html)
+- [Qdrant Docker Hub](https://hub.docker.com/r/qdrant/qdrant)
+- [Python SDK](https://python-client.qdrant.tech/)
+- [JavaScript SDK](https://github.com/qdrant/qdrant-js)
+
+**Related Overlays:**
+
+- [`pgvector`](../pgvector/README.md) — PostgreSQL-native vector storage (alternative; conflicts with `postgres`)
+- [`ollama`](../ollama/README.md) — Local LLM and embedding generation
+- [`python`](../python/README.md) — Python development environment
+- [`nodejs`](../nodejs/README.md) — Node.js development environment

package/overlays/qdrant/devcontainer.patch.json

@@ -0,0 +1,20 @@
+{
+    "$schema": "https://raw.githubusercontent.com/devcontainers/spec/main/schemas/devContainer.base.schema.json",
+    "runServices": ["qdrant"],
+    "forwardPorts": [6333, 6334],
+    "portsAttributes": {
+        "6333": {
+            "label": "Qdrant REST API",
+            "onAutoForward": "notify"
+        },
+        "6334": {
+            "label": "Qdrant gRPC",
+            "onAutoForward": "ignore"
+        }
+    },
+    "containerEnv": {
+        "QDRANT_HOST": "qdrant",
+        "QDRANT_PORT": "6333",
+        "QDRANT_URL": "http://qdrant:6333"
+    }
+}

package/overlays/qdrant/docker-compose.yml

@@ -0,0 +1,25 @@
+version: '3.8'
+
+services:
+    qdrant:
+        image: qdrant/qdrant:${QDRANT_VERSION:-{{cs.QDRANT_VERSION}}}
+        restart: unless-stopped
+        volumes:
+            - qdrant-data:/qdrant/storage
+        ports:
+            - '${QDRANT_PORT:-{{cs.QDRANT_PORT}}}:6333'
+            - '${QDRANT_GRPC_PORT:-{{cs.QDRANT_GRPC_PORT}}}:6334'
+        networks:
+            - devnet
+        healthcheck:
+            test: ['CMD-SHELL', 'curl -sf http://localhost:6333/readyz || exit 1']
+            interval: 10s
+            timeout: 5s
+            retries: 5
+            start_period: 10s
+
+volumes:
+    qdrant-data:
+
+networks:
+    devnet:

package/overlays/qdrant/overlay.yml

@@ -0,0 +1,40 @@
+id: qdrant
+name: Qdrant
+description: High-performance vector database for similarity search and embeddings
+category: database
+supports:
+    - compose
+requires: []
+suggests:
+    - ollama
+    - python
+    - nodejs
+conflicts: []
+tags:
+    - database
+    - vector
+    - embeddings
+    - search
+    - qdrant
+ports:
+    - port: 6333
+      service: qdrant
+      protocol: http
+      description: Qdrant REST API
+      onAutoForward: notify
+      connectionStringTemplate: 'http://{host}:{port}'
+    - port: 6334
+      service: qdrant
+      protocol: grpc
+      description: Qdrant gRPC API
+      onAutoForward: ignore
+parameters:
+    QDRANT_VERSION:
+        description: Qdrant Docker image tag
+        default: latest
+    QDRANT_PORT:
+        description: Host port mapped to Qdrant REST API (6333 inside container)
+        default: '6333'
+    QDRANT_GRPC_PORT:
+        description: Host port mapped to Qdrant gRPC API (6334 inside container)
+        default: '6334'