> ## Documentation Index
> Fetch the complete documentation index at: https://docs.cynative.com/llms.txt
> Use this file to discover all available pages before exploring further.

# LLM Provider Overview: 30 Backends Supported by Cynative

> Cynative supports 30+ LLM providers via the Bifrost SDK. Configure your provider with two environment variables or a YAML file for advanced options.

Cynative routes every LLM call through the embedded [Bifrost](https://github.com/maximhq/bifrost) SDK, which provides a uniform chat interface over all supported backends. This means you **bring your own model** (BYOM): point Cynative at any provider you already have access to — a cloud API, a managed inference endpoint, or a GPU on your desk — and Cynative adapts to it. No provider is hard-wired; the model selection is entirely yours.

## Quick start

Three environment variables are all you need for the most common case:

```bash theme={null}
export CYNATIVE_LLM_PROVIDER=openai           # provider id — see the catalog below
export CYNATIVE_LLM_MODEL=gpt-5               # model id string, passed verbatim to the provider
export OPENAI_API_KEY=sk-...                  # canonical API key env var (provider-specific; see table)
cynative -p "list IAM users in my AWS account that have console access"
```

No `~/.cynative/config.yaml` file is needed for the simple path. Write YAML only when you need fields the env-var surface does not cover (e.g. `extra_headers`, multi-key load balancing, or advanced provider configs).

## Provider catalog

| Provider id | Canonical env var | Guide |
| - | - | - |
| `openai` | `OPENAI_API_KEY` | [/providers/openai](/providers/openai) |
| `anthropic` | `ANTHROPIC_API_KEY` | [/providers/anthropic](/providers/anthropic) |
| `azure` | `AZURE_OPENAI_API_KEY` | azure |
| `bedrock` | (AWS credential chain) | [/providers/bedrock](/providers/bedrock) |
| `bedrock_mantle` | (AWS credential chain or `api_key`) | [/providers/bedrock](/providers/bedrock) |
| `vertex` | (none — needs `project_id` + `region`) | [/providers/vertex](/providers/vertex) |
| `gemini` | `GEMINI_API_KEY` | [/providers/vertex](/providers/vertex) |
| `cohere` | `COHERE_API_KEY` | cohere |
| `mistral` | `MISTRAL_API_KEY` | mistral |
| `groq` | `GROQ_API_KEY` | groq |
| `perplexity` | `PERPLEXITY_API_KEY` | perplexity |
| `cerebras` | `CEREBRAS_API_KEY` | cerebras |
| `openrouter` | `OPENROUTER_API_KEY` | openrouter |
| `xai` | `XAI_API_KEY` | xai |
| `huggingface` | `HUGGINGFACE_API_KEY` | huggingface |
| `nebius` | `NEBIUS_API_KEY` | nebius |
| `parasail` | `PARASAIL_API_KEY` | parasail |
| `fireworks` | `FIREWORKS_API_KEY` | fireworks |
| `replicate` | `REPLICATE_API_TOKEN` | replicate |
| `runware` | `RUNWARE_API_KEY` | runware |
| `deepseek` | `DEEPSEEK_API_KEY` | deepseek |
| `sarvam` | `SARVAM_API_KEY` | sarvam |
| `wafer` | `WAFER_API_KEY` | wafer |
| `databricks` | `DATABRICKS_TOKEN` | databricks |
| `opencode-go` | `OPENCODE_API_KEY` | opencode-go |
| `opencode-zen` | `OPENCODE_API_KEY` | opencode-zen |
| `ollama` | (none — local endpoint) | [/providers/local](/providers/local) |
| `vllm` | (none — local endpoint) | [/providers/local](/providers/local) |
| `sgl` | (none — local endpoint) | [/providers/local](/providers/local) |
| `github-copilot` | (none — needs `api_key` + `base_url`) | github-copilot |

## Shared YAML reference

Every provider uses the same flat `llm:` block in `~/.cynative/config.yaml`. Fields marked optional may be omitted; Cynative and Bifrost supply sensible defaults.

```yaml theme={null}
llm:
  provider: <provider-id>          # required — one of the ids in the catalog above
  model: <model-id>                # required — passed verbatim to the provider
  api_key: env.YOUR_KEY            # optional; falls back to the canonical env var for the provider
  reasoning_effort: high           # optional; none | minimal | low | medium | high
  reasoning_max_tokens: 2048       # optional; explicit reasoning/thinking token budget
  network_config:                  # optional; any field on Bifrost's NetworkConfig schema
    base_url: https://...                          # optional; override the provider's default endpoint
    default_request_timeout_in_seconds: 60         # optional; integer seconds (default 300)
    max_retries: 3                                 # optional; default 3 (0 disables retries)
    extra_headers:                                 # optional; map — must be set in YAML, no env form
      x-custom: value
    insecure_skip_verify: false                    # optional; skip TLS verification
  openai_config: {...}             # optional; top-level provider config (OpenAI-family options)
  azure: {...}                     # optional; per-provider identity block
  vertex: {...}                    # optional; per-provider identity block
  bedrock: {...}                   # optional; per-provider identity block
  bedrock_mantle: {...}            # optional; per-provider identity block
  vllm: {...}                      # optional; per-provider identity block
  ollama: {...}                    # optional; per-provider identity block
  sgl: {...}                       # optional; per-provider identity block
  replicate: {...}                 # optional; per-provider identity block
  databricks: {...}                # optional; per-provider identity block
  github_copilot: {...}            # optional; per-provider identity block
  keys: [...]                      # optional; advanced: multi-key load balancing
```

**Reasoning fields** are provider-portable: providers without reasoning support silently ignore them, though a model that doesn't support reasoning may still reject the parameter upstream on providers that forward it for every model (e.g. OpenAI-style APIs). `reasoning_effort` maps to the provider's native effort knob; `reasoning_max_tokens` sets an explicit thinking budget (Anthropic-style providers use it directly; OpenAI-style providers convert it to an estimated effort level). Gemini additionally validates an explicit budget against a per-model range at request time. Setting `reasoning_effort: none` together with `reasoning_max_tokens` is rejected at config validation.

## Common environment variables

Every YAML config field is settable via a `CYNATIVE_*` environment variable. Maps and slices require YAML (e.g. `network_config.extra_headers`, `keys[]`). Everything else — including all identity selectors — is env-bindable.

### Core selectors

| Environment variable | Description |
| - | - |
| `CYNATIVE_LLM_PROVIDER` | **Required.** Provider id string (e.g. `openai`, `anthropic`). |
| `CYNATIVE_LLM_MODEL` | **Required.** Model id, passed verbatim to the provider. |
| `CYNATIVE_LLM_API_KEY` | Generic API key; equivalent to `llm.api_key` in YAML. Falls back to the provider's canonical var if unset. |

### Network and timeout

| Environment variable | Description |
| - | - |
| `CYNATIVE_LLM_NETWORK_CONFIG_BASE_URL` | Override the provider's default API endpoint. |
| `CYNATIVE_LLM_NETWORK_CONFIG_DEFAULT_REQUEST_TIMEOUT_IN_SECONDS` | Per-request timeout in seconds (integer). Cynative default: `300`. |
| `CYNATIVE_LLM_NETWORK_CONFIG_MAX_RETRIES` | Number of retry attempts. Cynative default: `3`. Set to `0` to disable retries. |
| `CYNATIVE_LLM_NETWORK_CONFIG_INSECURE_SKIP_VERIFY` | Skip TLS certificate verification (`true`/`false`). |

### Reasoning

| Environment variable | Description |
| - | - |
| `CYNATIVE_LLM_REASONING_EFFORT` | Reasoning effort level: `none`, `minimal`, `low`, `medium`, or `high`. |
| `CYNATIVE_LLM_REASONING_MAX_TOKENS` | Explicit reasoning/thinking token budget (integer). |

### Provider-specific identity fields

| Environment variable | Provider | Description |
| - | - | - |
| `CYNATIVE_LLM_AZURE_ENDPOINT` | Azure | Azure OpenAI resource endpoint URL. |
| `CYNATIVE_LLM_VERTEX_PROJECT_ID` | Vertex | GCP project id. |
| `CYNATIVE_LLM_VERTEX_REGION` | Vertex | GCP region (e.g. `us-central1`). |
| `CYNATIVE_LLM_BEDROCK_REGION` | Bedrock | AWS region (e.g. `us-east-1`). |
| `CYNATIVE_LLM_BEDROCK_MANTLE_REGION` | Bedrock Mantle | AWS region for the Bedrock Mantle endpoint. |
| `CYNATIVE_LLM_OLLAMA_URL` | Ollama | Base URL of the Ollama server (e.g. `http://localhost:11434`). |
| `CYNATIVE_LLM_VLLM_URL` | vLLM | Base URL of the vLLM server (e.g. `http://localhost:8000`). |
| `CYNATIVE_LLM_VLLM_MODEL_NAME` | vLLM | Per-key model name for vLLM routing. |
| `CYNATIVE_LLM_SGL_URL` | SGLang | Base URL of the SGLang server (e.g. `http://localhost:30000`). |
| `CYNATIVE_LLM_DATABRICKS_WORKSPACE_URL` | Databricks | Databricks workspace URL. |
| `CYNATIVE_LLM_DATABRICKS_API_FORMAT` | Databricks | API format for the Databricks endpoint. |
| `CYNATIVE_LLM_DATABRICKS_CLIENT_ID` | Databricks | OAuth client id. |
| `CYNATIVE_LLM_DATABRICKS_CLIENT_SECRET` | Databricks | OAuth client secret. |

Any nested Bifrost field is reachable by upper-snake-casing its JSON path: `CYNATIVE_LLM_<PATH>` — for example, `CYNATIVE_LLM_NETWORK_CONFIG_MAX_CONNS_PER_HOST` or `CYNATIVE_LLM_OPENAI_CONFIG_DISABLE_STORE`.

## Prompt caching

Cynative always marks the stable prefix of every request with ephemeral cache breakpoints — the tool schemas, the system prompt, and the last two conversation turns.

**Anthropic-family providers** (`anthropic`, `bedrock`, `vertex` with Claude) cache that prefix and bill cached reads at a large discount. The cache window is Anthropic's default **five-minute ephemeral TTL**, so back-to-back calls (e.g. `--auto-approve` runs) benefit most; long human-approval pauses between tool calls may let the cache expire and re-pay the write cost.

**All other providers:** Bifrost's converters strip or ignore the cache markers. Providers that auto-cache server-side (OpenAI, Gemini) continue to do so regardless — Cynative's markers don't interfere.

**There is nothing to configure.** Prompt caching is on for all providers and inert where unsupported.

<Note>
  Bifrost exposes two additional knobs — `CYNATIVE_LLM_PROMPT_CACHE_AUTO_INJECT` and `CYNATIVE_LLM_PROMPT_CACHE_TTL` — which synthesize breakpoints for clients that emit none. Both are off by default and do nothing for Cynative, because Bifrost skips auto-injection once the caller has already marked the request, which Cynative always does.
</Note>

## Troubleshooting

### Request timeouts

Non-streaming LLM calls default to a **300-second** per-request timeout — Cynative's default, replacing Bifrost's 30-second default, which is too short for the long, reasoning-heavy completions a research run produces.

Override the timeout with the YAML field:

```yaml theme={null}
llm:
  network_config:
    default_request_timeout_in_seconds: 120   # integer seconds
```

Or via environment variable:

```bash theme={null}
export CYNATIVE_LLM_NETWORK_CONFIG_DEFAULT_REQUEST_TIMEOUT_IN_SECONDS=120
```

<Note>
  On a timeout, the underlying error message comes from Bifrost and references `default_request_timeout_in_seconds`, `network_config`, and a "Providers > Provider Name > Network Config" UI. That wording is Bifrost's internal copy (it even hard-codes "30 seconds" regardless of the effective timeout). Cynative has no such UI — the knob you want is `network_config.default_request_timeout_in_seconds` as shown above.
</Note>

### Rate limits and retries

LLM calls automatically retry retryable failures — HTTP 429/500/502/503/504, provider-level rate-limit errors, and transient network errors — up to **3 times** with exponential backoff (500 ms initial delay, 5 s maximum). This is Cynative's default, replacing Bifrost's 0-retry default, under which a single rate-limit blip fails the whole turn.

Request timeouts are **not** retried.

Override the retry count:

```yaml theme={null}
llm:
  network_config:
    max_retries: 5              # integer; 0 disables retries entirely
    retry_backoff_initial: 1s   # optional; duration string
    retry_backoff_max: 10s      # optional; duration string
```

Or via environment variable:

```bash theme={null}
export CYNATIVE_LLM_NETWORK_CONFIG_MAX_RETRIES=5
```

If a run still ends with a "rate limited / out of quota (HTTP 429)" error after retries, the provider account's quota or billing limit was reached. Check your provider dashboard, or wait and retry later.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.