Model Configuration

Models define the AI providers and model IDs used by agents. Examples were checked on September 10, 2026 against the OpenAI catalog, Claude catalog, Gemini catalog, and OpenRouter catalog. Provider-specific IDs can differ for the same model.

Supported Providers

• anthropic - Claude models (Anthropic)
• bedrock_claude - Anthropic Claude models on Amazon Bedrock
• azure - OpenAI models through Azure OpenAI deployments
• openai - GPT models and OpenAI-compatible endpoints
• codex or openai_codex - OpenAI models available through a local Codex CLI ChatGPT login
• kimi or kimi_code - Kimi models available through a local Kimi Code CLI login
• google or gemini - Google Gemini models
• vertexai_claude - Anthropic Claude models on Google Vertex AI
• ollama - Local models via Ollama
• llama_cpp - Local models through an OpenAI-compatible llama.cpp server
• groq - Groq-hosted models (fast inference)
• openrouter - OpenRouter-hosted models (access to many providers)
• cerebras - Cerebras-hosted models
• deepseek - DeepSeek models
• zai - Z.ai GLM models
• synthetic - Built-in Lorem Ipsum model for local conversations and load generation

Model Config Fields

Each model configuration supports the following fields:

For Azure OpenAI, id is the Azure deployment name, not the underlying base-model name. Provider credentials come from supported environment variables, stored credentials, CLI authentication, or deliberately supplied extra_kwargs; the top-level ModelConfig.api_key field is not used during model construction.

Presentation metadata is optional:

models:
  default:
    provider: openai
    id: gpt-6-astra
    display_name: Quick helper
    icon: icons/helper.png

display_name changes the label clients show, while the mapping key (default above) remains the stable name used by agents, teams, routing, and commands. For icon, use either a path relative to the directory containing the active config file or a Matrix media URI such as mxc://server/media. Blank metadata uses the client's default presentation. A missing or unreadable relative image also falls back at presentation time and does not prevent the runtime from starting. These fields are presentation-only and are not passed to the model provider.

The Matrix model picker publishes only model keys, display names, provider names, model IDs, and optional Matrix media URLs. Local icons must be valid PNG, JPEG, WebP, or GIF images no larger than 1 MiB. At publication, the resolved image target must remain inside the resolved config directory, including when the path contains parent components or symlinks. A contained path such as icons/../helper.png is accepted; an escaping target falls back to the client's provider icon. The runtime validates image bytes and uploads them to Matrix media; identical bytes reuse the upload within that runtime client. Changed bytes publish a new icon. Unsupported, missing, or unreadable images fall back to the client's provider icon. External image URLs are not fetched. Local paths, API keys, provider hosts, and extra provider settings never enter discovery responses. See Matrix model selection protocol for private discovery and confirmed thread changes.

Hot Reload

After a successful config reload, edits to a referenced definition under models apply to the next agent, team, or router response without restarting its Matrix bot. Response models, team members, and compaction budgets are resolved from the current config for each response. This includes changes to provider options, model IDs, and context_window, including definitions selected by compaction.model or compaction.fallback_model. Call-enabled agents can still restart because their call runtime retains configuration between responses.

Increasing context_window does not remove an explicit, smaller compaction.replay_window_tokens cap. Update that cap too if you want a larger replay window.

Claude Agent Prompt Caching

The anthropic, bedrock_claude, and vertexai_claude providers enable agent prompt caching with a one-hour lifetime by default. MindRoom places a cache boundary after the shared agent identity, role, workspace context files, and tool instructions. The current date and session context, including compaction summaries, learned context, and system-hook additions, follow that boundary while retaining system-message priority. Changing those later sections does not invalidate the shared instruction prefix; identical tool definitions and prefix content can be reused across conversations when the provider cache is available. The conversation cache boundaries still include the full system prompt, so repeated turns can reuse session context too. Set extra_kwargs.cache_system_prompt: false to disable MindRoom's automatic Claude cache boundaries, or extra_kwargs.extended_cache_time: false to use the five-minute lifetime.

OpenAI Responses Prompt Caching

The openai Responses API and codex providers send shared agent instructions as an initial developer message, followed by a separate developer message containing the current date and session context. Both messages retain system-instruction priority, and compaction summaries remain in the session-specific suffix. On the public OpenAI API, GPT-5.6 and later receive an explicit cache breakpoint at the end of the shared prefix, alongside the provider's default implicit caching. See OpenAI's prompt caching guide for cache eligibility and accounting.

Codex, older models, and custom OpenAI-compatible endpoints receive the same split without the explicit breakpoint field. The Codex backend currently rejects that field, so cache reuse there still depends on provider-managed caching; splitting messages alone does not guarantee cross-conversation cache hits. Set extra_kwargs.cache_system_prompt: false to preserve the original unsplit system message. This option applies to Responses models; Chat Completions providers keep their existing request format.

Configuration Examples

models:
  # Anthropic Claude
  sonnet:
    provider: anthropic
    id: claude-sonnet-5
    context_window: 1000000

  fable:
    provider: anthropic
    id: claude-fable-5-1
    context_window: 1000000

  opus:
    provider: anthropic
    id: claude-opus-5
    context_window: 1000000

  haiku:
    provider: anthropic
    id: claude-haiku-4-5
    context_window: 200000

  # Anthropic Claude on Amazon Bedrock
  bedrock_opus:
    provider: bedrock_claude
    id: anthropic.claude-opus-5
    context_window: 1000000

  # OpenAI
  gpt:
    provider: openai
    id: gpt-6-astra
    context_window: 1050000

  # Azure OpenAI
  azure:
    provider: azure
    id: your-azure-openai-deployment

  # OpenAI via a Codex CLI ChatGPT login
  codex:
    provider: codex
    id: gpt-6-astra
    context_window: 258000

  # Kimi K3 via a Kimi Code CLI login
  kimi:
    provider: kimi
    id: k3
    context_window: 1048576

  # Google Gemini (both 'google' and 'gemini' work as provider names)
  gemini:
    provider: google
    id: gemini-3.8-flash
    context_window: 1048576

  # Anthropic Claude on Vertex AI
  vertex_claude:
    provider: vertexai_claude
    id: claude-sonnet-5
    extra_kwargs:
      project_id: your-gcp-project
      region: us-central1

  # Local via Ollama
  local:
    provider: ollama
    id: qwen3.8:27b
    context_window: 256000
    host: http://localhost:11434  # Uses dedicated host field

  # OpenRouter (access to many model providers)
  openrouter:
    provider: openrouter
    id: anthropic/claude-sonnet-5

  # Groq (fast inference; Qwen3.8 is a preview model)
  groq:
    provider: groq
    id: qwen/qwen3.8-27b
    context_window: 131042

  # Cerebras (65,536 tokens on the free tier; paid plans support 131,072)
  cerebras:
    provider: cerebras
    id: qwen-3.8-27b
    context_window: 65536

  # DeepSeek
  deepseek:
    provider: deepseek
    id: deepseek-v4-pro
    context_window: 1048576

  # Z.ai GLM Coding Plan (OpenAI Chat Completions endpoint)
  glm:
    provider: zai
    id: glm-5.3
    context_window: 1048576
    extra_kwargs:
      base_url: https://api.z.ai/api/coding/paas/v4

  # Custom OpenAI-compatible endpoint (e.g., vLLM, llama.cpp server)
  custom:
    provider: openai
    id: my-model
    extra_kwargs:
      base_url: http://localhost:8080/v1

Claude Fable 5.1 uses claude-fable-5-1 on Anthropic, anthropic.claude-fable-5-1 on Bedrock, and anthropic/claude-fable-5.1 on OpenRouter. Its tool-choice rules allow auto and none; forcing any or a named tool returns an error. The Qwen3.8-27B model card and each hosting provider document their own context limits. GLM 5.3 is available through the GLM Coding Plan endpoint shown above. The direct DeepSeek API keeps the aliases deepseek-v4-flash and deepseek-v4-pro; OpenRouter exposes the newer Flash route as deepseek/deepseek-v4.1-flash.

Built-In Synthetic Model

Use provider: synthetic to exercise normal MindRoom conversations without an API key or model server. The model streams a seeded random amount of Lorem Ipsum at a fixed character rate. When the agent has the shell tool, the model occasionally calls run_shell_command with echo hi and then continues its response.

models:
  synthetic:
    provider: synthetic
    id: lorem-ipsum
    extra_kwargs:
      seed: 1
      min_response_chars: 320
      max_response_chars: 960
      chunk_chars: 40
      chars_per_second: 80
      tool_call_probability: 0.2

agents:
  load_test:
    display_name: Load Test
    role: Generate synthetic traffic.
    model: synthetic
    tools: [shell]
    rooms: [lobby]

Tag @load_test in Lobby to receive a streamed synthetic reply through the same Matrix path as any other agent. Set tool_call_probability: 1 to force the shell call on every turn, or 0 to disable tool calls. Changing seed changes the repeatable response length, split point, and tool-call choice for each conversation history.

OpenAI API Models

Set api: responses or api: chat_completions on an openai model to select the API independently of its model ID or endpoint. Use explicit selection for proxies and custom model aliases; the endpoint must support the selected API.

models:
  astra:
    provider: openai
    id: gpt-6-astra
    api: responses
    extra_kwargs:
      base_url: http://localhost:4000/v1
      reasoning_effort: high

GPT-6 Astra requires Responses for function calling. Responses continuation works independently of the model ID, including custom aliases. Set extra_kwargs.reasoning_effort or extra_kwargs.reasoning only when you want to customize reasoning. extra_kwargs.store: false remains respected; selecting Responses does not override it.

When api is unset, GPT 5.4 and newer models on the first-party OpenAI endpoint use Responses. Other routes, including all custom OpenAI-compatible endpoints, default to Chat Completions. If you previously relied on automatic Astra routing through a proxy, add api: responses before upgrading. Explicit Chat Completions disables native deferred-tool search and keeps MindRoom's dynamic-tool discovery. Selecting Responses on a custom endpoint does not enable OpenAI's hosted tool search; only supported first-party OpenAI and Codex routes use it.

OrcaRouter via the OpenAI-Compatible Endpoint

OrcaRouter works through MindRoom's existing openai provider; no dedicated provider or plugin is required. Configure its endpoint and an OrcaRouter API key on the model:

models:
  orcarouter:
    provider: openai
    id: orcarouter/auto
    api: chat_completions
    extra_kwargs:
      base_url: https://api.orcarouter.ai/v1
      api_key: your-orcarouter-api-key

The orcarouter/auto ID lets OrcaRouter choose a model per request; you can replace it with a model ID from its catalog. Set an agent's model: orcarouter, or select it for a thread with !model orcarouter.

To keep the key out of YAML, omit extra_kwargs.api_key and save the OrcaRouter key in the dashboard's Models editor, in this model's API Key field. That model-specific credential takes precedence over extra_kwargs.api_key and the shared OpenAI key, so OrcaRouter and direct OpenAI models can use separate keys. MindRoom does not automatically read ORCAROUTER_API_KEY for provider: openai.

Codex Models with ChatGPT Login

Use provider: codex when you want MindRoom to call models exposed through an authenticated local Codex CLI session instead of the regular OpenAI API. Run codex login first so ~/.codex/auth.json contains ChatGPT OAuth tokens. MindRoom refreshes the access token when needed and sends requests to the Codex Responses endpoint. Codex is included across ChatGPT plans, including Free and Go, but model access and usage limits depend on the logged-in account and current rollout. See the current Codex model catalog instead of assuming every account exposes the same slugs. MindRoom maps the gpt-5.6 alias to GPT-5.6 Sol and passes other slugs through unchanged.

Older or preview slugs can also work when the logged-in Codex account exposes them. The LLM-plugin-style form openai-codex/gpt-6-astra is accepted as an alternative to the bare alias. If you keep Codex state outside ~/.codex, pass extra_kwargs.codex_home; user-home prefixes such as ~/custom-codex are expanded. For starter config generation, use mindroom config init --provider codex.

models:
  default:
    provider: codex
    id: gpt-6-astra
    context_window: 258000
    # Related agent conversations share a prompt-cache key automatically.
    extra_kwargs:
      reasoning_effort: medium

The 258000 context window is the conservative effective budget used by the Codex ChatGPT surface, not the larger context window exposed by the separately billed OpenAI API. Set Codex reasoning effort through extra_kwargs.reasoning_effort. Agno maps this to the Responses API reasoning.effort field. Supported GPT-6 Astra effort values are low, medium, high, xhigh, and max. Codex clients also show Ultra, but Ultra adds Codex-managed subagent orchestration and is not reproduced by this model adapter. The starter Codex profile uses medium.

The Codex provider supports text and image input with text output; transcription, text-to-speech, and realtime speech are not supported.

This adapter follows the local Codex CLI authentication-file and backend contracts, so upstream Codex changes can require a MindRoom update. Use provider: openai when you want the public OpenAI API contract and API billing instead.

MindRoom derives the Codex prompt_cache_key from the storage-root path, tenant, account, channel, agent, and requester. Rooms, threads, and session IDs are excluded, so related conversations can share a cache group while different agents, requesters, and storage roots remain separate. The storage-root path is a local namespace, not a globally unique installation identifier; deployments with identical paths and execution scopes can share a cache group within the same provider account. Use explicit cache-key overrides if those deployments need separate cache accounting. Codex CLI session headers use a separate key for each conversation; changing the cache group does not combine session identities. Set extra_kwargs.prompt_cache_key to override the cache group, or set it to null to omit the key while retaining the conversation headers. Model calls without an execution identity do not receive a derived cache key or session headers. Identical prefixes and tools are still required for reuse, and provider routing and cache availability can produce misses even with a shared key. Live probes accepted separate cache keys and session headers and reported some repeated-request cache hits, but did not establish reliable cache reuse across conversations.

Kimi Models with Kimi Code Login

Use provider: kimi when you want MindRoom to call Kimi models through an authenticated local Kimi Code CLI session (Kimi Code subscription) instead of the billed Moonshot API. Run kimi and /login first so ~/.kimi-code/credentials/kimi-code.json contains OAuth tokens. MindRoom refreshes the access token when needed and sends requests to the Kimi Code OpenAI-compatible endpoint at https://api.kimi.com/coding/v1.

Kimi Code context limits depend on the subscription plan: k3 supports 1,048,576 tokens on Allegretto and higher plans, while Moderato is limited to 262,144 tokens. Set context_window: 262144 for Moderato, or use k3-256k for a fixed 256k window.

The CLI-config-style form kimi-code/k3 is accepted as an alternative to the bare slug. If you keep Kimi Code state outside ~/.kimi-code, set KIMI_CODE_HOME or pass extra_kwargs.kimi_home; user-home prefixes such as ~/custom-kimi are expanded. For starter config generation, use mindroom config init --provider kimi.

models:
  default:
    provider: kimi
    id: k3
    context_window: 1048576

Kimi K3 always reasons before replying, so responses include reasoning tokens even for short answers. This adapter follows the local Kimi Code CLI authentication-file and backend contracts, so upstream Kimi Code changes can require a MindRoom update.

Prompt caching is automatic on the Kimi Code endpoint: repeated request prefixes come back as cached_tokens with no opt-in. MindRoom uses the same agent-and-requester cache grouping as Codex, so rooms and threads share a prompt_cache_key within the same storage-root path, tenant, account, and channel. Set extra_kwargs.prompt_cache_key to override that group, or set it to null to omit the key.

OpenRouter Provider Routing

OpenRouter routes each request to one of several upstream providers serving the model, and upstream quality varies (we have seen a third-party host leak raw tool-call markup into a visible reply). Control routing by passing OpenRouter provider preferences through extra_kwargs.extra_body:

models:
  deepseek:
    provider: openrouter
    id: deepseek/deepseek-v4.1-flash
    context_window: 1048576
    extra_kwargs:
      extra_body:
        provider:
          sort: price                     # cheapest available endpoint
          # order: [fireworks, together]  # or pin specific upstreams, in order
          # allow_fallbacks: false        # fail instead of using unlisted upstreams

Provider slugs are in the tag field of https://openrouter.ai/api/v1/models/<model-id>/endpoints. Account-level OpenRouter settings (ignored providers, data-policy filters) still apply and cannot be overridden per request, so pinning an upstream your account excludes fails with No endpoints found. Verify a new pin with a direct API test request and check the provider field in the response.

Azure OpenAI

Use provider: azure when your model is deployed through Azure OpenAI. The id field should be your Azure OpenAI deployment name, not necessarily the upstream model name. MindRoom reads Azure OpenAI credentials and endpoint values from the config-adjacent .env file or exported environment.

models:
  default:
    provider: azure
    id: your-azure-openai-deployment

Azure deployment limits vary, so starter configs do not set context_window for Azure. Set context_window to the limit of your deployment when you know it. Set AZURE_OPENAI_API_VERSION only when you need to override Agno's default API version. For starter config generation, use mindroom config init --provider azure.

Amazon Bedrock Claude

Use provider: bedrock_claude when you want MindRoom to call Anthropic Claude through Amazon Bedrock. MindRoom uses Anthropic's Bedrock Mantle Messages client and auto-installs the aws_bedrock optional extra on first use unless MINDROOM_NO_AUTO_INSTALL_TOOLS=1 is set. The id field should be the Bedrock model ID or inference profile ID enabled in your AWS account and region. Bedrock lists Fable 5.1 as open access, while Opus 5 access can depend on the AWS account and region. The generated Bedrock starter config defaults to Opus 5, so confirm access or choose Fable 5.1 or Sonnet 5 instead.

models:
  default:
    provider: bedrock_claude
    id: anthropic.claude-opus-5
    context_window: 1000000

MindRoom reads AWS settings from the config-adjacent .env file, exported environment, local AWS profile, or runtime IAM role. For starter config generation, use mindroom config init --provider bedrock_claude.

Context Window

Set context_window to the model provider's actual limit. MindRoom uses it to budget persisted replay and required destructive compaction unless compaction config sets a smaller replay_window_tokens cap. MindRoom always applies a final replay-fit step when the active runtime model has a known context_window. That replay-fit step reduces or disables persisted replay for the current run when needed. On vertexai_claude models, a known context_window also enables a request-time guard inside the provider call. Before each asynchronous runtime request, including follow-up requests after tool results, MindRoom estimates the full provider payload and checks it against Vertex's exact token counter when it approaches the window. When a request would exceed the window, MindRoom drops the oldest replayed history turns for that request only and logs a warning. When the current turn alone cannot fit, the request fails with a clear provider error instead of being sent oversized. Automatic compaction is enabled by default through defaults.compaction. Supported routes use native compaction during ordinary requests. The portable text fallback runs before the reply when history exceeds the hard replay budget. Set enabled: false in defaults.compaction or a per-agent/per-team compaction override to disable automatic native and pre-reply text compaction.

You can tune compaction behavior with these settings:

• Use threshold_tokens or threshold_percent to set the native provider trigger, or the soft planning threshold on text-only routes.
• Use replay_window_tokens to keep persisted replay and required-compaction planning within a smaller operational window without presenting that smaller value as the provider's request limit.
• Use reserve_tokens to leave hard-budget headroom for the current prompt and output.
• Use model to choose the summary model, and fallback_model to name a different model config retried once when the summary model refuses for safeguards; the same input is reused when it fits, otherwise it is rebuilt under the fallback model's own context budget, and after success that model serves the remaining chunks.
• Use timeout_seconds to bound each primary, retry, or fallback summary request; it defaults to 600 seconds, while an explicitly shorter provider timeout remains the stricter cap.

When the active runtime model window is known, replay safety uses the smaller of it and replay_window_tokens. When that model window is unknown, an explicit replay_window_tokens still supplies the replay-planning window. Each compaction summary input chunk is sized independently from the selected compaction model's real context_window, after reserve, prompt overhead, and a safety margin. Destructive compaction requires the resolved summary input budget to exceed 2,000 tokens. With the default reserve_tokens, this makes destructive compaction unavailable when the compaction model's context window is roughly 10,000 tokens or smaller; lowering reserve_tokens restores availability for such small windows.

Manual compact_context records a durable request that runs before the next reply in the same conversation scope. Manual compact_context remains available when a compaction model and context window are configured and the resolved summary input budget exceeds 2,000 tokens. It still uses the active runtime window for the final replay-fit step, while an explicit compaction.model can supply the summary-generation window subject to the same minimum summary-input budget. If you set compaction.model, that summary model must also define its own context_window for the durable summary-generation pass. compaction.fallback_model must also name a configured model with its own context_window; a fallback naming the summary model's alias, or another alias resolving to the same provider and model ID, is ignored because it would resend the refused request to the same model. Required compaction runs before the reply with a Matrix lifecycle notice that is edited in place. Otherwise MindRoom preserves canonical history and applies the selected replay strategy.

Replay planning uses a chars/4 approximation and reserves headroom for the current prompt and output. Summary-input chunk sizing uses the model's tiktoken encoding when recognized. Direct Anthropic, Vertex AI Claude, and Bedrock Claude summary models without a recognized encoding use one token per UTF-8 byte as a conservative upper bound. Compaction chunk logs report summary_input_estimate, summary_input_estimate_kind, and summary_input_budget_tokens so tiktoken counts, o200k estimates, and UTF-8 byte upper bounds are never presented as the same measurement. MindRoom does not mutate configured num_history_runs to fit the window. Instead, it computes the replay plan that actually fits the current call and uses compaction to keep future replay healthy. If needed, that replay plan can reduce raw replay, fall back to summary-only replay, or disable persisted replay entirely for the run.

models:
  default:
    provider: anthropic
    id: claude-sonnet-5
    context_window: 1000000  # 1M tokens

defaults:
  compaction:
    replay_window_tokens: 200000  # Compact persisted replay around a smaller operational window

This is useful for models with smaller context windows or long-running conversations that accumulate persisted history.

Native compaction

MindRoom supports automatic OpenAI Responses compaction and Claude compaction. OpenAI native replay uses the official Responses endpoint or the Codex login backend with store: false. When native mode is disabled, the authored storage setting is restored; canonical replay retains stateless reasoning and never chains to a response the provider did not store. Automatic enablement covers GPT-5.3 Codex, GPT-5.4, and GPT-6 model families; other models retain the portable path. An explicitly configured store: true, background mode, alternate OpenAI endpoint, or custom context-management request stays on the portable path. Claude native compaction supports direct Anthropic and Vertex Claude on the supported Sonnet, Opus, Fable, and Mythos models; it is a provider beta and requires a trigger of at least 50,000 tokens. An authored Claude compact_20260112 policy keeps its own trigger and instructions; compatible checkpoints use the same replay and portable-fallback rules. Changing that policy affects future summaries; existing compatible checkpoints remain conversation history. Gemini, Chat Completions, and other provider adapters retain text compaction.

Native compaction requires automatic compaction to be enabled, all-history replay, no historical tool-call limit, and a trigger above the current prompt size and below the hard request limit. Explicit compaction.model, scheduled history limits, bounded replay, unsupported models, and requests already exceeding the hard budget use the portable path. Manual compact_context always requests portable text compaction. Native checkpoints are tied to their provider, model, endpoint, and current portable summary, so changing that route or rewriting the summary rebuilds context from canonical history. Native compaction itself never deletes canonical runs; storage therefore continues to grow until portable text compaction removes older runs.

Checkpoints and their following native output are persisted through the existing SQLite run storage and survive restarts. The system instructions keep their shared prompt-cache prefix. OpenAI checkpoints remain opaque; local budgeting conservatively estimates their serialized size rather than treating billed pre-compaction input as active context. Claude usage includes every compaction iteration while context occupancy uses the final iteration. Vertex token counting represents checkpoint contents as text and omits the compaction policy and beta header, which its counting endpoint rejects; generation still receives the native blocks and policy. Canonical fallback discards thinking bound to a removed checkpoint on adaptive-thinking routes, while preserving the unchanged thinking required by legacy manual-thinking tool turns. Claude pause_after_compaction: true is rejected because MindRoom's automatic path requires the provider to continue its response.

Extra Kwargs

The extra_kwargs field configures additional parameters on the underlying Agno model class. Common options include:

• base_url - Custom API endpoint (useful for OpenAI-compatible servers)
• temperature - Sampling temperature
• max_tokens - Maximum tokens in response
• extra_body - Extra JSON body fields for OpenAI-compatible providers (e.g., OpenRouter provider routing above)

Claude Fable 5.1, Opus 5, and Sonnet 5 reject non-default temperature, top_p, and top_k values, so MindRoom omits those controls on Anthropic, Bedrock, and Vertex requests. MindRoom also omits those deprecated controls for direct Gemini 3.8 Flash and Gemini 3.5 Flash-Lite requests. GPT-6 Astra does not support temperature, top_p, or top_logprobs; omit these from authored model options. Automatic thread summaries omit their temperature override for GPT-6 Astra, including its OpenRouter route. For Mem0 memory extraction with provider: openai, use GPT-5.6 Luna; the current Mem0 request builder does not support Astra's parameter requirements.

Environment Variables

API keys are read from environment variables:

ANTHROPIC_API_KEY=sk-ant-...
AZURE_OPENAI_API_KEY=...
AZURE_OPENAI_ENDPOINT=https://your-resource.openai.azure.com
# Optional, only when overriding Agno's default Azure OpenAI API version:
# AZURE_OPENAI_API_VERSION=2024-10-21
OPENAI_API_KEY=sk-...
GOOGLE_API_KEY=...
GROQ_API_KEY=...
OPENROUTER_API_KEY=...
CEREBRAS_API_KEY=...
DEEPSEEK_API_KEY=...
ZAI_API_KEY=...

For Amazon Bedrock Claude, use standard AWS credential resolution:

AWS_REGION=us-east-1
# Optional static credentials:
AWS_ACCESS_KEY_ID=...
AWS_SECRET_ACCESS_KEY=...
AWS_SESSION_TOKEN=...
# Optional local profile instead:
AWS_PROFILE=...

For Ollama, you can also set:

OLLAMA_HOST=http://localhost:11434

For Vertex AI Claude, set these instead of an API key:

ANTHROPIC_VERTEX_PROJECT_ID=your-gcp-project
CLOUD_ML_REGION=us-central1

Authenticate with gcloud auth application-default login or set GOOGLE_APPLICATION_CREDENTIALS to a service account key file.

File-based Secrets

For container environments (Kubernetes, Docker Swarm), supported API-key and secret variables can also use a _FILE suffix:

# Instead of setting the key directly:
ANTHROPIC_API_KEY=sk-ant-...

# Point to a file containing the key:
ANTHROPIC_API_KEY_FILE=/run/secrets/anthropic-api-key

This works for all API key environment variables (e.g., OPENAI_API_KEY_FILE, GOOGLE_API_KEY_FILE, etc.).