Configuration

llm:
  defaultProvider: ollama
  defaultModel: ollama/llama3.2
  providers:
    ollama:
      baseUrl: http://localhost:11434
    openai:
      apiKey: ${OPENAI_API_KEY}
    anthropic:
      apiKey: ${ANTHROPIC_API_KEY}
    google:
      apiKey: ${GOOGLE_API_KEY}

limits:
  maxConcurrentRuns: 10
  defaultTimeout: 120000

memory:
  adapter: redis
  redis:
    url: redis://localhost:6379
  embedding:
    provider: ollama
    model: nomic-embed-text

import { Cogitator } from '@cogitator-ai/core';
import { loadConfig } from '@cogitator-ai/config';

const config = loadConfig();
const cogitator = new Cogitator(config);

const config = loadConfig({
  configPath: './config/cogitator.yml', // must exist, or loadConfig throws
  skipEnv: false, // true: ignore environment variables
  skipYaml: false, // true: ignore config files
  overrides: { limits: { maxConcurrentRuns: 4 } },
});

memory:
  adapter: redis
  redis:
    host: localhost
    port: 6379
  qdrant:
    url: http://localhost:6333
    collection: cogitator
    dimensions: 768
  embedding:
    provider: ollama
    model: nomic-embed-text
  contextBuilder:
    strategy: hybrid
    includeSemanticContext: true

import { Cogitator } from '@cogitator-ai/core';
import { SQLiteAdapter } from '@cogitator-ai/memory';

const memory = new SQLiteAdapter({ provider: 'sqlite', path: './data/memory.db' });
const connected = await memory.connect();
if (!connected.success) throw new Error(connected.error);

const cogitator = new Cogitator({ llm: { defaultModel: 'ollama/llama3.2' } });
cogitator.memory = memory;

logging:
  level: warn
  destination: file
  filePath: ./logs/cogitator.log

import { createLogger, createLoggerFromConfig, setLogger } from '@cogitator-ai/core';

setLogger(createLoggerFromConfig({ level: 'debug', destination: 'file', filePath: './debug.log' }));
setLogger(createLogger({ level: 'debug', format: 'json' }));

OPENAI_API_KEY=sk-xxx
OPENAI_BASE_URL=https://proxy.example.com/v1
ANTHROPIC_API_KEY=sk-ant-xxx
GOOGLE_API_KEY=xxx            # or GEMINI_API_KEY
OLLAMA_URL=http://localhost:11434   # or OLLAMA_HOST (scheme optional)
OLLAMA_API_KEY=xxx            # Ollama Cloud; URL defaults to https://ollama.com unless set in env or YAML
AZURE_OPENAI_API_KEY=xxx      # with AZURE_OPENAI_ENDPOINT, optional AZURE_OPENAI_DEPLOYMENT
AWS_REGION=us-east-1          # AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY for Bedrock
MISTRAL_API_KEY=xxx
GROQ_API_KEY=xxx
TOGETHER_API_KEY=xxx
DEEPSEEK_API_KEY=xxx

llm:
  providers:
    openai:
      apiKey: ${OPENAI_API_KEY}
      baseUrl: ${OPENAI_BASE_URL:-https://api.openai.com/v1}

import { Cogitator } from '@cogitator-ai/core';
import { defineConfig } from '@cogitator-ai/config';

const config = defineConfig({
  llm: {
    defaultModel: 'openai/gpt-6.1-sol',
    providers: {
      openai: {
        apiKey: process.env.OPENAI_API_KEY!,
      },
    },
  },
  memory: {
    adapter: 'postgres',
    postgres: {
      connectionString: process.env.DATABASE_URL!,
    },
    embedding: {
      provider: 'openai',
      apiKey: process.env.OPENAI_API_KEY!,
      model: 'text-embedding-3-small',
    },
  },
});

const cogitator = new Cogitator(config);

const config = loadConfig();
const cogitator = new Cogitator({
  ...config,
  prompts: { ...config.prompts, score: (result) => (result.output.length > 0 ? 1 : 0) },
});

llm:
  providers:
    ollama:
      baseUrl: http://localhost:11434 # default; https://ollama.com when only apiKey is set
      apiKey: xxx # optional, Ollama Cloud or an authenticated server

llm:
  providers:
    openai:
      apiKey: sk-xxx
      baseUrl: https://api.openai.com/v1 # optional, for proxies
      api: responses # optional: responses | chat-completions

llm:
  providers:
    anthropic:
      apiKey: sk-ant-xxx

llm:
  providers:
    google:
      apiKey: xxx

llm:
  providers:
    azure:
      apiKey: xxx
      endpoint: https://your-resource.openai.azure.com
      apiVersion: '2024-02-15-preview' # optional
      deployment: gpt-6.1-sol # optional

llm:
  providers:
    bedrock:
      region: us-east-1 # optional, can use AWS config chain
      accessKeyId: xxx # optional, uses AWS credentials chain
      secretAccessKey: xxx # optional

llm:
  providers:
    mistral:
      apiKey: xxx
    groq:
      apiKey: xxx
    together:
      apiKey: xxx
    deepseek:
      apiKey: xxx
    vllm:
      baseUrl: http://localhost:8000/v1

llm:
  retry:
    maxRetries: 2 # attempts after the first one
    baseDelay: 1000 # ms before the first retry, doubled each time
    maxDelay: 30000 # backoff cap, ms
    maxRetryAfter: 60000 # a longer Retry-After fails the call at once

llm:
  promptCache:
    ttl: 1h # Anthropic keeps the cache for an hour instead of 5 minutes
  # promptCache: false   — turn it off

security:
  pii:
    mode: mask # mask | redact | block
    detect: [email, phone, credit_card, iban, ssn, ip_address, api_key]
    custom:
      - type: customer_id
        pattern: 'CUS-\d{6}'

security:
  promptInjection:
    action: block # block | warn | log
    threshold: 0.7
    patterns:
      - '[Rr]eveal (the|your) system prompt'
    failMode: secure # secure (default): a throwing classifier fails the check; open: the input passes
    allowlist:
      - ignore the previous search

sandbox:
  allowNativeFallback: false # default true: Docker tools run on the host when Docker is unavailable
  defaults:
    image: cogitator/sandbox:base
    env:
      PYTHONUNBUFFERED: '1'
    mounts:
      - source: /srv/data
        target: /workspace/data
        readOnly: true
  pool:
    maxSize: 5
    reuseContainers: false # default; true reuses containers, so one execution's files reach the next