Configuration

my-atlas-project/
├── atlas.config.ts    # ← here
├── package.json
├── semantic/
│   └── entities/
└── .env

// atlas.config.ts — secrets from env, structure in config
import { defineConfig } from "@atlas/api/lib/config";

export default defineConfig({
  datasources: {
    // URL from env var, structure in config
    default: { url: process.env.ATLAS_DATASOURCE_URL! },
  },
});

// atlas.config.ts — minimal config
import { defineConfig } from "@atlas/api/lib/config";

export default defineConfig({
  datasources: {
    default: { url: process.env.ATLAS_DATASOURCE_URL! },
  },
  // All other fields are optional with sensible defaults:
  // tools: ["explore", "executeSQL"]
  // auth: "auto"
  // semanticLayer: "./semantic"
  // maxTotalConnections: 100
});

// atlas.config.ts — custom semantic layer path
export default defineConfig({
  // Relative to project root (default: "./semantic")
  semanticLayer: "./custom/semantic",
});

# Profile the "warehouse" datasource → writes to semantic/warehouse/entities/
bun run atlas -- init --connection warehouse

semantic/
├── entities/            # Default datasource entities
│   └── users.yml
├── warehouse/
│   └── entities/        # "warehouse" datasource entities
│       └── inventory.yml
├── metrics/
└── glossary.yml

// atlas.config.ts — pin auth mode
export default defineConfig({
  // "auto" | "none" | "api-key" | "managed" | "byot"
  auth: "managed",
});

// atlas.config.ts — default tool set
export default defineConfig({
  // These are the defaults when omitted
  tools: ["explore", "executeSQL"],
});

// atlas.config.ts — plugins
import { clickhousePlugin } from "@useatlas/clickhouse";
import { snowflakePlugin } from "@useatlas/snowflake";

export default defineConfig({
  plugins: [
    // Each plugin binds to a named datasource
    clickhousePlugin({ connectionId: "analytics" }),
    snowflakePlugin({ connectionId: "warehouse" }),
  ],
});

// atlas.config.ts — connection pool limit
export default defineConfig({
  // Max total connections across all datasource pools (default: 100)
  // When exceeded, least-recently-used datasources are evicted
  maxTotalConnections: 50,
});

export default defineConfig({
  pool: {
    perOrg: {
      maxConnections: 5,      // Max connections per org (default: 5)
      idleTimeoutMs: 30000,   // Idle timeout in ms (default: 30000)
      maxOrgs: 50,            // Max org pools before LRU eviction (default: 50)
      warmupProbes: 2,        // Warmup probes when pool created (default: 2)
      drainThreshold: 5,      // Consecutive errors before auto-drain (default: 5)
    },
  },
});

export default defineConfig({
  cache: {
    enabled: true,       // default: true
    ttl: 300_000,        // 5 minutes (milliseconds)
    maxSize: 1000,       // max cached entries
  },
});

export default defineConfig({
  learn: {
    confidenceThreshold: 0.7,  // default: 0.7
  },
});

ATLAS_LEARN_CONFIDENCE_THRESHOLD=0.7

// atlas.config.ts — multi-condition RLS policy
export default defineConfig({
  rls: {
    enabled: true,
    policies: [
      {
        tables: ["orders", "invoices"],
        // Both conditions must match — the query gets:
        // WHERE tenant_id = <org_id claim> AND region = <region claim>
        conditions: [
          { column: "tenant_id", claim: "org_id" },
          { column: "region", claim: "app_metadata.region" },
        ],
      },
    ],
  },
});

ATLAS_RLS_ENABLED=true
ATLAS_RLS_COLUMN=tenant_id
ATLAS_RLS_CLAIM=org_id

// atlas.config.ts — action framework
export default defineConfig({
  actions: {
    // Default settings for all actions
    defaults: {
      approval: "manual",          // "auto" | "manual" | "admin-only"
      timeout: 300000,             // 5 min per-action timeout in ms
      maxPerConversation: 10,      // Max actions per conversation
    },
    // Per-action overrides (key = action type)
    "email:send": {
      approval: "admin-only",
      requiredRole: "admin",
      // Credentials validated at startup
      credentials: {
        RESEND_API_KEY: { env: "RESEND_API_KEY" },
      },
    },
    "jira:create": {
      approval: "manual",
      requiredRole: "analyst",
    },
  },
});

// atlas.config.ts — scheduler
export default defineConfig({
  scheduler: {
    // "bun" (in-process) | "webhook" (external cron) | "vercel" (Vercel Cron)
    backend: "bun",
    // Max concurrent task executions per tick (default: 5)
    maxConcurrentTasks: 5,
    // Per-task execution timeout in ms (default: 60000)
    taskTimeout: 60_000,
    // How often the scheduler checks for due tasks in seconds (default: 60)
    tickIntervalSeconds: 60,
  },
});

# Comma-separated backend names
ATLAS_SANDBOX_PRIORITY=sidecar,nsjail,just-bash

export default defineConfig({
  session: {
    idleTimeout: 3600,       // 1 hour — invalidate sessions inactive for this long
    absoluteTimeout: 86400,  // 24 hours — hard limit regardless of activity
  },
});

ATLAS_SESSION_IDLE_TIMEOUT=3600
ATLAS_SESSION_ABSOLUTE_TIMEOUT=86400

export default defineConfig({
  semanticIndex: {
    enabled: true,  // default: true
  },
});

ATLAS_SEMANTIC_INDEX_ENABLED=false  # Set to "false" to disable

export default defineConfig({
  enterprise: {
    enabled: true,
    licenseKey: process.env.ATLAS_ENTERPRISE_LICENSE_KEY,
  },
});

ATLAS_ENTERPRISE_ENABLED=true
ATLAS_ENTERPRISE_LICENSE_KEY=your-key-here

export default defineConfig({
  enterprise: { enabled: true, licenseKey: process.env.ATLAS_ENTERPRISE_LICENSE_KEY },
  residency: {
    regions: {
      "us-east": { label: "US East", databaseUrl: process.env.US_EAST_DB_URL! },
      "eu-west": { label: "EU West", databaseUrl: process.env.EU_WEST_DB_URL! },
    },
    defaultRegion: "us-east",
  },
});

// atlas.config.ts — complete example
import { defineConfig } from "@atlas/api/lib/config";
import { snowflakePlugin } from "@useatlas/snowflake";

export default defineConfig({
  // Named datasources (at least "default")
  datasources: {
    default: {
      url: process.env.ATLAS_DATASOURCE_URL!,
      description: "Primary Postgres",
    },
    warehouse: {
      url: process.env.WAREHOUSE_URL!,
      schema: "analytics",
      description: "Snowflake warehouse",
      rateLimit: { queriesPerMinute: 20, concurrency: 2 },
    },
  },

  // Agent tools
  tools: ["explore", "executeSQL"],

  // Auth mode (auto-detect from env vars)
  auth: "auto",

  // Semantic layer directory
  semanticLayer: "./semantic",

  // Connection pool cap
  maxTotalConnections: 50,

  // Plugins
  plugins: [
    snowflakePlugin({ connectionId: "warehouse" }),
  ],

  // Row-Level Security
  rls: {
    enabled: true,
    policies: [
      { tables: ["orders", "customers"], column: "tenant_id", claim: "org_id" },
    ],
  },

  // Action framework
  actions: {
    defaults: { approval: "manual" },
    "email:send": {
      approval: "admin-only",
      credentials: {
        RESEND_API_KEY: { env: "RESEND_API_KEY" },
      },
    },
  },

  // Scheduler
  scheduler: {
    backend: "bun",
    maxConcurrentTasks: 3,
    taskTimeout: 120_000,
    tickIntervalSeconds: 30,
  },

  // Sandbox backend priority
  sandbox: {
    priority: ["sidecar", "nsjail", "just-bash"],
  },

  // Python import guard (allow HTTP clients for sandboxed internal API access)
  python: {
    allowModules: ["requests"],
    blockedModules: ["boto3"],
  },

  // Semantic index (pre-computed summary in agent prompt)
  semanticIndex: {
    enabled: true,
  },

  // Dynamic learning (offline audit log analysis)
  learn: {
    confidenceThreshold: 0.7,
  },

  // Enterprise features (commercial license, /ee directory)
  enterprise: {
    enabled: true,
    licenseKey: process.env.ATLAS_ENTERPRISE_LICENSE_KEY,
  },
});