> ## Documentation Index
> Fetch the complete documentation index at: https://langchain-5e9cc07a-preview-opensw-1772748614-696205f.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Custom model providers

> Configure any LangChain-compatible model provider for the Deep Agents CLI

The Deep Agents CLI supports any [chat model provider compatible with LangChain](/oss/python/langchain/models), unlocking use for virtually any LLM that supports tool calling. Any service that exposes an OpenAI-compatible or Anthropic-compatible API also works out of the box — see [Compatible APIs](#compatible-apis).

## Quick start

The CLI integrates automatically with the [following model providers](#provider-reference) — no extra configuration needed beyond installing the relevant provider package.

1. **Install provider packages**

   Each model provider requires installing its corresponding LangChain integration package. These are available as optional extras when installing the CLI:

   ```bash theme={null}
   # Quick install with chosen providers (OpenAI included automatically)
   DEEPAGENTS_EXTRAS="anthropic,groq" curl -LsSf https://raw.githubusercontent.com/langchain-ai/deepagents/main/scripts/install.sh | bash

   # Or install directly with uv
   uv tool install 'deepagents-cli[anthropic,groq]'

   # Add additional packages at a later date
   uv tool upgrade deepagents-cli --with langchain-ollama

   # All providers
   uv tool install 'deepagents-cli[anthropic,bedrock,cohere,deepseek,fireworks,google-genai,groq,huggingface,ibm,mistralai,nvidia,ollama,openai,openrouter,perplexity,vertexai,xai]'
   ```

2. **Set credentials**

   Most providers require an API key. Set the appropriate environment variable listed in the table below. Some providers use other credentials (for example, Vertex AI uses `GOOGLE_CLOUD_PROJECT` plus ADC). Refer to each integration package's docs for details.

### Provider reference

Using a provider not listed here? See [Arbitrary providers](#arbitrary-providers) — any LangChain-compatible provider can be used in the CLI with some additional setup.

| Provider             | Package                                                                                       | Credential env var                           | Model profiles |
| -------------------- | --------------------------------------------------------------------------------------------- | -------------------------------------------- | -------------- |
| OpenAI               | [`langchain-openai`](/oss/python/integrations/chat/openai)                                    | `OPENAI_API_KEY`                             | ✅              |
| Azure OpenAI         | [`langchain-openai`](/oss/python/integrations/chat/azure_chat_openai)                         | `AZURE_OPENAI_API_KEY`                       | ✅              |
| Anthropic            | [`langchain-anthropic`](/oss/python/integrations/chat/anthropic)                              | `ANTHROPIC_API_KEY`                          | ✅              |
| Google Gemini API    | [`langchain-google-genai`](/oss/python/integrations/chat/google_generative_ai)                | `GOOGLE_API_KEY`                             | ✅              |
| Google Vertex AI     | [`langchain-google-vertexai`](/oss/python/integrations/chat/google_generative_ai#credentials) | `GOOGLE_CLOUD_PROJECT`                       | ✅              |
| AWS Bedrock          | [`langchain-aws`](/oss/python/integrations/chat/bedrock)                                      | `AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY` | ✅              |
| AWS Bedrock Converse | [`langchain-aws`](/oss/python/integrations/chat/bedrock)                                      | `AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY` | ✅              |
| Hugging Face         | [`langchain-huggingface`](/oss/python/integrations/chat/huggingface)                          | `HUGGINGFACEHUB_API_TOKEN`                   | ✅              |
| Ollama               | [`langchain-ollama`](/oss/python/integrations/chat/ollama)                                    | Optional                                     | ❌              |
| Groq                 | [`langchain-groq`](/oss/python/integrations/chat/groq)                                        | `GROQ_API_KEY`                               | ✅              |
| Cohere               | [`langchain-cohere`](/oss/python/integrations/chat/cohere)                                    | `COHERE_API_KEY`                             | ❌              |
| Fireworks            | [`langchain-fireworks`](/oss/python/integrations/chat/fireworks)                              | `FIREWORKS_API_KEY`                          | ✅              |
| Together             | [`langchain-together`](/oss/python/integrations/chat/together)                                | `TOGETHER_API_KEY`                           | ❌              |
| Mistral AI           | [`langchain-mistralai`](/oss/python/integrations/chat/mistralai)                              | `MISTRAL_API_KEY`                            | ✅              |
| DeepSeek             | [`langchain-deepseek`](/oss/python/integrations/chat/deepseek)                                | `DEEPSEEK_API_KEY`                           | ✅              |
| IBM (watsonx.ai)     | [`langchain-ibm`](/oss/python/integrations/chat/ibm_watsonx)                                  | `WATSONX_APIKEY`                             | ❌              |
| Nvidia               | [`langchain-nvidia-ai-endpoints`](/oss/python/integrations/chat/nvidia_ai_endpoints)          | `NVIDIA_API_KEY`                             | ❌              |
| xAI                  | [`langchain-xai`](/oss/python/integrations/chat/xai)                                          | `XAI_API_KEY`                                | ✅              |
| Perplexity           | [`langchain-perplexity`](/oss/python/integrations/chat/perplexity)                            | `PPLX_API_KEY`                               | ✅              |
| OpenRouter           | [`langchain-openrouter`](/oss/python/integrations/chat/openrouter)                            | `OPENROUTER_API_KEY`                         | ✅              |

<Tip>
  A **[model profile](/oss/python/langchain/models#model-profiles)** is a bundle of metadata (model name, default parameters, capabilities, etc.) that ships with a provider package, largely powered by the [models.dev](https://models.dev/) project. Providers that include model profiles have their models listed automatically in the interactive `/model` switcher. Providers without model profiles require you to specify the model name directly.
</Tip>

### Switching models

To switch models in the CLI, either:

1. **Use the interactive model switcher** with the `/model` command. This displays a hardcoded list of known model profiles sourced from each LangChain provider package.

   <Note>
     Note that these profiles are not an exhaustive list of available models. If the model you want isn't shown, use option 2 instead (useful for newly released models that haven't been added to the profiles yet).
   </Note>
2. **Specify a model name directly** as an argument, e.g. `/model openai:gpt-4o`. You can use any model supported by the chosen provider, regardless of whether it appears in the list from option 1. The model name will be passed to the API request.
3. **Specify the model at launch** via `--model`, e.g.

   ```txt theme={null}
   deepagents --model openai:gpt-4o
   ```

### Setting a default model

You can set a persistent default model that will be used for all future CLI launches:

* **Via model selector:** Open `/model`, navigate to the desired model, and press `Ctrl+S` to pin it as the default. Pressing `Ctrl+S` again on the current default clears it.
* **Via command:** `/model --default provider:model` (e.g., `/model --default anthropic:claude-opus-4-6`)
* **Via config file:** Set `[models].default` in `~/.deepagents/config.toml` (see [Config file](#config-file)).
* **From the shell:**

  ```bash theme={null}
  deepagents --default-model anthropic:claude-opus-4-6
  ```

To view the current default:

```bash theme={null}
deepagents --default-model
```

To clear the default:

* **From the shell:**

  ```bash theme={null}
  deepagents --clear-default-model
  ```

* **Via command:** `/model --default --clear`

* **Via model selector:** Press `Ctrl+S` on the currently pinned default model.

Without a default, the CLI will default to the most recently used model.

### Model resolution order

When the CLI launches, it resolves which model to use in the following order:

1. **`--model` flag** always wins when provided.
2. **`[models].default`** in `~/.deepagents/config.toml` — The user's intentional long-term preference.
3. **`[models].recent`** in `~/.deepagents/config.toml` — The last model switched to via `/model`. Written automatically; never overwrites `[models].default`.
4. **Environment auto-detection** — Falls back to the first available startup credential, checked in order: `OPENAI_API_KEY`, `ANTHROPIC_API_KEY`, `GOOGLE_API_KEY`, `GOOGLE_CLOUD_PROJECT` (Vertex AI).

This startup fallback intentionally checks only those four credentials. Other supported providers (for example, Groq) are still available via `--model`, `/model`, and saved defaults (`[models].default` / `[models].recent`).

***

## Config file

The Deep Agents CLI offers extending and modifying individual model & provider config via `~/.deepagents/config.toml`.

Each provider is a TOML table under the `[models.providers]` namespace:

```toml theme={null}
[models.providers.<name>]
models = ["gpt-4o"]
api_key_env = "OPENAI_API_KEY"
base_url = "https://api.openai.com/v1"
class_path = "my_package.models:MyChatModel"

[models.providers.<name>.params]
temperature = 0
max_tokens = 4096

[models.providers.<name>.params."gpt-4o"]
temperature = 0.7
```

**Keys:**

<ResponseField name="models" type="string[]">
  A list of model names to show in the interactive `/model` switcher for this provider. For providers that already ship with model profiles, any names you add here appear alongside the bundled ones — useful for newly released models that haven't been added to the package yet. For [arbitrary providers](#arbitrary-providers), this list is the only source of models in the switcher.

  This key is optional. You can always pass any model name directly to `/model` or `--model` regardless of whether it appears in the switcher; the provider validates the name at request time.
</ResponseField>

<ResponseField name="api_key_env" type="string">
  Optionally override the environment variable name checked for credentials.
</ResponseField>

<ResponseField name="base_url" type="string">
  Optionally override the base URL used by the provider, if supported. Refer to your provider packages' [reference docs](https://reference.langchain.com/python/integrations/) for more info.
</ResponseField>

<ResponseField name="params" type="object">
  Extra keyword arguments forwarded to the model constructor. Flat keys (e.g., `temperature = 0`) apply to every model from this provider. Model-keyed sub-tables (e.g., `[params."gpt-4o"]`) override individual values for that model only; the merge is shallow (model wins on conflict).
</ResponseField>

<ResponseField name="profile" type="object">
  (Advanced) Override fields in the model's runtime [profile](/oss/python/langchain/models#model-profiles) (e.g., `max_input_tokens`). Flat keys apply to every model from this provider. Model-keyed sub-tables (e.g., `[profile."claude-sonnet-4-5"]`) override individual values for that model only; the merge is shallow (model wins on conflict). These overrides are applied after the model is created, so they take effect for context-limit display, auto-summarization, and any other feature that reads the profile.
</ResponseField>

<ResponseField name="class_path" type="string">
  Used for [arbitrary model](#arbitrary-providers) providers. Optional fully-qualified Python class in `module.path:ClassName` format. When set, the CLI imports and instantiates this class directly for provider `<name>`. The class must be a `BaseChatModel` subclass.
</ResponseField>

You can set a default model in `~/.deepagents/config.toml` — either by editing the file directly, using `/model --default`, or selecting a default in the interactive model switcher.

```toml theme={null}
[models]
default = "ollama:qwen3:4b"        # your intentional long-term preference
recent = "anthropic:claude-sonnet-4-5"  # last /model switch (written automatically)
```

`[models].default` always takes priority over `[models].recent`. The `/model` command only writes to `[models].recent`, so your configured default is never overwritten by mid-session switches. To remove the default, use `/model --default --clear` or delete the `default` key from the config file.

## Examples

### Model constructor params

Any provider can use the `params` table to pass extra arguments to the model constructor:

```toml theme={null}
[models.providers.ollama.params]
temperature = 0
num_ctx = 8192
```

#### Per-model overrides

If a specific model needs different params, add a model-keyed sub-table under `params` to override individual values without duplicating the entire provider config:

```toml theme={null}
[models.providers.ollama]
models = ["qwen3:4b", "llama3"]

[models.providers.ollama.params]
temperature = 0
num_ctx = 8192

[models.providers.ollama.params."qwen3:4b"]
temperature = 0.5
num_ctx = 4000
```

With this configuration:

* `ollama:qwen3:4b` gets `{temperature: 0.5, num_ctx: 4000}` — model overrides win.
* `ollama:llama3` gets `{temperature: 0, num_ctx: 8192}` — no override, provider-level params only.

The merge is shallow: any key present in the model sub-table replaces the same key from the provider-level params, while keys only at the provider level are preserved.

### Profile overrides

**(Advanced)**

Override fields in the model's runtime profile to change how the CLI interprets model capabilities. The most common use case is lowering `max_input_tokens` to trigger auto-summarization earlier — useful for testing or for constraining context usage:

```toml theme={null}
# Apply to all models from this provider
[models.providers.anthropic.profile]
max_input_tokens = 4096
```

Per-model sub-tables work the same way as `params` — the model-level value wins on conflict:

```toml theme={null}
[models.providers.anthropic.profile]
max_input_tokens = 4096

# This model gets a higher limit
[models.providers.anthropic.profile."claude-sonnet-4-5"]
max_input_tokens = 8192
```

Profile overrides are merged into the model's profile after creation. Any feature that reads the profile — context-limit display in the status bar, auto-summarization thresholds, capability checks — will see the overridden values.

#### CLI overrides with `--model-params`

For one-off adjustments without editing the config file, pass a JSON object via `--model-params`:

```bash theme={null}
deepagents --model ollama:llama3 --model-params '{"temperature": 0.9, "num_ctx": 16384}'

# In non-interactive mode
deepagents -n "Summarize this repo" --model ollama:llama3 --model-params '{"temperature": 0}'
```

These take the highest priority, overriding values from config file params.

#### CLI profile overrides with `--profile-override`

**(Advanced)**

To override model profile fields at runtime without editing the config file, pass a JSON object via `--profile-override`:

```bash theme={null}
deepagents --profile-override '{"max_input_tokens": 4096}'

# Combine with --model
deepagents --model anthropic:claude-sonnet-4-5 --profile-override '{"max_input_tokens": 4096}'

# In non-interactive mode
deepagents -n "Summarize this repo" --profile-override '{"max_input_tokens": 4096}'
```

These are merged on top of config file profile overrides (CLI wins). The priority chain is: model default \< config.toml profile \< CLI `--profile-override`.

### Specifying custom `base_url`

Some provider packages accept a `base_url` to override the default endpoint. For example, `langchain-ollama` defaults to `http://localhost:11434` via the underlying `ollama` client. To point it elsewhere, set `base_url` in your configuration:

```toml theme={null}
[models.providers.ollama]
base_url = "http://your-host-here:port"
```

Refer to your provider's reference documentation for compatibility information and additional considerations.

### Model routers and proxies

Model routers like [OpenRouter](https://openrouter.ai/) and [LiteLLM](https://docs.litellm.ai/) provide access to models from multiple providers through a single endpoint.

Use the dedicated integration packages for these services:

| Router     | Package                                                            | Config                                                                         |
| ---------- | ------------------------------------------------------------------ | ------------------------------------------------------------------------------ |
| OpenRouter | [`langchain-openrouter`](/oss/python/integrations/chat/openrouter) | `openrouter:<model>` (built-in, see [Provider reference](#provider-reference)) |

**OpenRouter** is a built-in provider — install the package and use it directly:

```bash theme={null}
uv tool install 'deepagents-cli[openrouter]'
```

### Compatible APIs

For providers that expose APIs that are wire-compatible with OpenAI or Anthropic, you can use the existing `langchain-openai` or `langchain-anthropic` packages by pointing `base_url` at the provider's endpoint:

```toml theme={null}
[models.providers.openai]
base_url = "https://api.example.com/v1"
api_key_env = "EXAMPLE_API_KEY"
models = ["my-model"]
```

```toml theme={null}
[models.providers.anthropic]
base_url = "https://api.example.com"
api_key_env = "EXAMPLE_API_KEY"
models = ["my-model"]
```

<Note>
  Any features added on top of the official spec by the provider will not be captured. If the provider offers a dedicated LangChain integration package, prefer that instead.
</Note>

### Adding models to the interactive switcher

Some providers (e.g. `langchain-ollama`) — don't bundle model profile data (see [Provider reference](#provider-reference) for full listing). When this is the case, the interactive `/model` switcher won't list models for that provider. You can fill in the gap by defining a `models` list in your config file for the provider:

```toml theme={null}
[models.providers.ollama]
models = ["llama3", "mistral", "codellama"]
```

The `/model` switcher will now include an Ollama section with these models listed.

This is entirely optional. You can always switch to any model by specifying its full name directly:

```txt theme={null}
/model ollama:llama3
```

### Arbitrary providers

You can use any [LangChain `BaseChatModel`](https://reference.langchain.com/python/langchain_core/language_models/#langchain_core.language_models.BaseChatModel) subclass using `class_path`. The CLI will import and instantiate it directly:

```toml theme={null}
[models.providers.my_custom]
class_path = "my_package.models:MyChatModel"
api_key_env = "MY_API_KEY"
base_url = "https://my-endpoint.example.com"

[models.providers.my_custom.params]
temperature = 0
max_tokens = 4096
```

The package must be installed in the same Python environment as `deepagents-cli`:

```bash theme={null}
# If deepagents-cli was installed with uv tool:
uv tool upgrade deepagents-cli --with my_package
```

When you switch to `my_custom:my-model-v1` (via `/model` or `--model`), the model name (`my-model-v1`) is passed as the `model` kwarg:

```python theme={null}
MyChatModel(model="my-model-v1", base_url="...", api_key="...", temperature=0, max_tokens=4096)
```

<Warning>
  `class_path` executes arbitrary Python code from your config file. This has the same trust model as `pyproject.toml` build scripts — you control your own machine.
</Warning>

Your provider package may optionally provide model profiles at a `_PROFILES` dict in `<package>.data._profiles` in lieu of defining them under the `models` key. See LangChain [model profiles](https://github.com/langchain-ai/langchain/tree/master/libs/model-profiles) for more info.

***

<div className="source-links">
  <Callout icon="edit">
    [Edit this page on GitHub](https://github.com/langchain-ai/docs/edit/main/src/oss/deepagents/cli/providers.mdx) or [file an issue](https://github.com/langchain-ai/docs/issues/new/choose).
  </Callout>

  <Callout icon="terminal-2">
    [Connect these docs](/use-these-docs) to Claude, VSCode, and more via MCP for real-time answers.
  </Callout>
</div>