Configuration Reference

Environment variables, Docker, Kubernetes, and feature flags

Configuration Reference

This document covers every configurable knob in the Enterprise Agentic AI Platform: environment variables per service, Docker Compose service topology, Kubernetes Helm values, monorepo tooling, and feature flags.

Table of Contents

1. Environment Variables
   • API Gateway
   • Frontend Applications
   • WebSocket Server
   • n8n Bridge Sidecars
   • Example External Agents
2. Docker Compose
   • Service Map
   • Port Mappings
   • Volume Mounts
3. Kubernetes / Helm
   • Namespace Layout
   • Resource Limits
   • Ingress
   • Sandbox Isolation
4. Monorepo Configuration
   • Workspace Structure
   • Turborepo Tasks
5. Feature Flags

Environment Variables

All backend services read configuration from environment variables. In local development, the API Gateway loads a .env file from the monorepo root via dotenv. In Docker Compose, variables are set in the environment: block of each service or loaded from an env_file.

API Gateway

The API Gateway (services/api-gateway) is the central backend process. It connects to every data store, orchestration system, and external service.

Core

Data Stores

Orchestration

LLM Provider (T-Systems AIFS)

Identity & Auth (Keycloak OIDC)

Token Lifetimes

Object Storage (S3 / MinIO)

Secrets Management (Vault)

Observability

Security & Signing

SPIFFE / SPIRE

Code Execution

External Agent URLs

Frontend Applications (Portal, Studio, Admin)

All three Next.js apps share the same set of environment variables. Values differ only by OIDC client identity.

OIDC Client IDs per app: Portal = portal, Studio = studio, Admin = admin-console.

WebSocket Server

The WebSocket server (services/ws-server) handles real-time push events.

n8n Bridge Sidecars

Four sidecar services form the n8n bridge layer, providing governance, memory, observability, and identity for n8n workflows.

Guardrails Proxy (port 8081)

Memory Bridge (port 8082)

OTel Exporter (port 8083)

Identity Injector (ports 8084 / 8085)

Example External Agents

All example agents (Research, Raw Python, Pydantic AI, CrewAI, AutoGen) share the same LLM configuration pattern.

Docker Compose

The docker-compose.yml at the repository root defines all services for local development. No Docker profiles are used; all services start together.

Service Map

Port Mappings

Volume Mounts

Named volumes persist data across container restarts:

Host bind mounts (read-only):

• ./infra/keycloak/agentic-platform-realm.json into Keycloak for realm import
• ./infra/prometheus/prometheus.yml and alert-rules.yml into Prometheus
• ./infra/grafana/provisioning and dashboards into Grafana
• ./infra/spire/server.conf and agent.conf into SPIRE
• /var/run/docker.sock into API Gateway (infrastructure metrics)
• $HOME/.kube into API Gateway (Kubernetes API access for code execution)

Kubernetes / Helm

The Helm chart lives at infra/helm/agentic-platform/. The values.yaml file provides all defaults for a development deployment.

Namespace Layout

The platform uses four Kubernetes namespaces for isolation:

Resource Limits

Platform Services

n8n Sidecars

All four sidecars share the same resource profile: CPU 100m-500m, Memory 128Mi-256Mi.

Data Services

Ingress

Sandbox Isolation

The platform supports gVisor-based container isolation for agent workloads. Resource limits are tiered by agent autonomy level:

gVisor settings:

• sandbox.gvisor.enabled: true
• sandbox.gvisor.runtimeClassName: gvisor
• sandbox.gvisor.handler: runsc
• sandbox.gvisor.overhead: memory 64Mi, CPU 50m
• sandbox.gvisor.nodeSelector: sandbox.gvisor.io/enabled: "true"

Code execution settings:

• sandbox.codeExecution.defaultTimeoutSeconds: 30
• sandbox.codeExecution.maxTimeoutSeconds: 120
• sandbox.codeExecution.maxCodeSizeBytes: 102400 (100KB)
• sandbox.codeExecution.maxOutputSizeBytes: 65536 (64KB)
• sandbox.codeExecution.localMode: true (child_process in dev, K8s pods in production)

Monorepo Configuration

Workspace Structure

Defined in pnpm-workspace.yaml:

packages:
  - 'apps/*'       # portal, studio, admin, docs
  - 'packages/*'   # ui, api-client, auth, types, config
  - 'services/*'   # api-gateway, ws-server

Package manager: pnpm with workspaces. All dependencies are hoisted to the root node_modules where possible, with per-package overrides managed by pnpm.

Turborepo Tasks

Defined in turbo.json:

Global dependencies: **/.env.*local (any change to local env files invalidates all caches).

Common commands:

pnpm install                    # Install all dependencies
pnpm dev                        # Start all apps in dev mode
pnpm dev --filter=portal        # Start only the Portal
pnpm dev --filter=studio        # Start only the Studio
pnpm dev --filter=admin         # Start only the Admin Console
pnpm build                      # Build all apps
pnpm lint                       # Lint all packages
pnpm test                       # Run all tests

Feature Flags

The platform uses environment variables as feature flags. No external feature flag service is required.

Implicit Feature Detection

Several features are automatically enabled when their backing service is reachable: