# How to Configure Multiple LLM Providers in TradingAgents

> Easily configure multiple LLM providers like OpenAI, Google, and Anthropic in TradingAgents with its flexible factory pattern. Switch seamlessly between providers for your trading bots.

- Repository: [Tauric Research/TradingAgents](https://github.com/TauricResearch/TradingAgents)
- Tags: how-to-guide
- Published: 2026-03-23

---

**TradingAgents uses a factory pattern in [`tradingagents/llm_clients/factory.py`](https://github.com/TauricResearch/TradingAgents/blob/main/tradingagents/llm_clients/factory.py) to dynamically instantiate provider-specific clients based on a configuration dictionary, enabling seamless switching between OpenAI, Google, Anthropic, and custom providers.**

The TradingAgents framework from TauricResearch abstracts Large Language Model (LLM) interactions behind a unified client interface. By configuring multiple LLM providers, you can optimize cost and performance by routing deep reasoning tasks to powerful models while delegating quick summarizations to lighter alternatives.

## Architecture Overview

The system isolates provider selection through three coordinated layers:

### Configuration Layer

A centralized `DEFAULT_CONFIG` dictionary in [`tradingagents/default_config.py`](https://github.com/TauricResearch/TradingAgents/blob/main/tradingagents/default_config.py) defines the active provider and model assignments. Key fields include `llm_provider` (the provider name), `deep_think_llm` (the model for complex reasoning), `quick_think_llm` (the model for fast responses), and provider-specific flags like `google_thinking_level` or `openai_reasoning_effort`.

### Factory Layer

The `create_llm_client()` function in [`tradingagents/llm_clients/factory.py`](https://github.com/TauricResearch/TradingAgents/blob/main/tradingagents/llm_clients/factory.py) receives the provider name, model identifier, optional `base_url`, and additional keyword arguments. It returns an instance of the appropriate subclass of `BaseLLMClient`. If the requested provider is not supported, the factory raises a `ValueError`.

### Graph Initialization Layer

The `TradingGraph` class in [`tradingagents/graph/trading_graph.py`](https://github.com/TauricResearch/TradingAgents/blob/main/tradingagents/graph/trading_graph.py) orchestrates the instantiation of both deep-thinking and quick-thinking LLMs. It extracts provider-specific kwargs via `_get_provider_kwargs()` and passes them to the factory, ensuring that each provider receives its required parameters (such as `thinking_level` for Gemini or `reasoning_effort` for OpenAI).

## Supported LLM Providers

TradingAgents includes specialized client implementations for major providers, all inheriting from `BaseLLMClient` in [`tradingagents/llm_clients/base_client.py`](https://github.com/TauricResearch/TradingAgents/blob/main/tradingagents/llm_clients/base_client.py).

### OpenAI and Compatible Services

The `OpenAIClient` in [`tradingagents/llm_clients/openai_client.py`](https://github.com/TauricResearch/TradingAgents/blob/main/tradingagents/llm_clients/openai_client.py) handles native OpenAI models as well as compatible services like Ollama, OpenRouter, and xAI. It can force the **Responses API** for native OpenAI models when `use_responses_api=True`. Provider-specific base URLs and API key environment variables are defined in the `_PROVIDER_CONFIG` mapping within the same file.

### Google Gemini

The `GoogleClient` in [`tradingagents/llm_clients/google_client.py`](https://github.com/TauricResearch/TradingAgents/blob/main/tradingagents/llm_clients/google_client.py) creates a `ChatGoogleGenerativeAI` instance. It maps the generic `thinking_level` configuration to the correct Gemini API parameter: `thinking_level` for Gemini 3 and `thinking_budget` for Gemini 2.5.

### Anthropic Claude

The `AnthropicClient` in [`tradingagents/llm_clients/anthropic_client.py`](https://github.com/TauricResearch/TradingAgents/blob/main/tradingagents/llm_clients/anthropic_client.py) builds a `ChatAnthropic` instance and forwards provider-specific kwargs such as `effort` to control reasoning intensity.

## Configuration Methods

You can configure multiple LLM providers either programmatically or through the interactive CLI.

### Custom Configuration Dictionary

Pass a dictionary to the `TradingGraph` constructor to switch providers dynamically:

```python
custom_config = {
    "llm_provider": "google",                # could be "openai", "anthropic", etc.

    "deep_think_llm": "gemini-1.5-pro",
    "quick_think_llm": "gemini-1.5-flash",
    "backend_url": None,                     # use default for the provider

    "google_thinking_level": "high",         # provider‑specific flag

    "openai_reasoning_effort": None,
    "anthropic_effort": None,
}

```

When `TradingGraph` processes this config, `_get_provider_kwargs` injects `thinking_level="high"` and the factory builds a `GoogleClient`. The deep-thinking LLM becomes a `NormalizedChatGoogleGenerativeAI` ready to generate Gemini responses.

### Interactive CLI Selection

When launching the CLI from [`cli/main.py`](https://github.com/TauricResearch/TradingAgents/blob/main/cli/main.py), the `select_llm_provider()` function in [`cli/utils.py`](https://github.com/TauricResearch/TradingAgents/blob/main/cli/utils.py) prompts you to choose from OpenAI, Google, Anthropic, xAI, OpenRouter, or Ollama. The selected provider name and backend URL are stored in the runtime configuration and passed to the graph construction.

## Implementation Examples

### Running Two Providers Simultaneously

You can instantiate different providers for different tasks within the same session:

```python
from tradingagents.llm_clients import create_llm_client

# Deep reasoning – OpenAI GPT‑5.2

deep_client = create_llm_client(
    provider="openai",
    model="gpt-5.2",
    base_url="https://api.openai.com/v1",
    reasoning_effort="high",
)
deep_llm = deep_client.get_llm()

# Quick summarisation – Anthropic Claude

quick_client = create_llm_client(
    provider="anthropic",
    model="claude-3-5-sonnet-20240620",
    effort="medium",
)
quick_llm = quick_client.get_llm()

# Use them independently

deep_response = deep_llm.invoke("Analyse the latest macro data.")
quick_response = quick_llm.invoke("Summarise the above analysis in three bullet points.")
print(deep_response.content)
print(quick_response.content)

```

Both `deep_llm` and `quick_llm` expose the same `.invoke()` interface, and each automatically normalizes response content to a plain string via `normalize_content()`.

### Adding a New Provider (Mistral)

To extend the system for a new provider like Mistral:

```python

# 1️⃣  tradingagents/llm_clients/mistral_client.py

from langchain_mistral import ChatMistral
from .base_client import BaseLLMClient, normalize_content
from .validators import validate_model

class NormalizedChatMistral(ChatMistral):
    def invoke(self, input, config=None, **kwargs):
        return normalize_content(super().invoke(input, config, **kwargs))

class MistralClient(BaseLLMClient):
    def get_llm(self):
        llm_kwargs = {"model": self.model}
        # Forward any user‑provided kwargs (e.g., timeout)

        llm_kwargs.update(self.kwargs)
        return NormalizedChatMistral(**llm_kwargs)

    def validate_model(self):
        return validate_model("mistral", self.model)


# 2️⃣  Update the factory (tradingagents/llm_clients/factory.py)

if provider_lower == "mistral":
    return MistralClient(model, base_url, **kwargs)

# 3️⃣  (Optional) expose a default URL via environment variable or _PROVIDER_CONFIG

```

After these additions, setting `"llm_provider": "mistral"` in your configuration dictionary will instantiate the new client automatically.

## Summary

- **TradingAgents** isolates LLM selection behind a **factory pattern** in [`tradingagents/llm_clients/factory.py`](https://github.com/TauricResearch/TradingAgents/blob/main/tradingagents/llm_clients/factory.py).
- Configuration is centralized in [`tradingagents/default_config.py`](https://github.com/TauricResearch/TradingAgents/blob/main/tradingagents/default_config.py) using the `llm_provider` key and provider-specific flags like `google_thinking_level` or `openai_reasoning_effort`.
- The `TradingGraph` class in [`tradingagents/graph/trading_graph.py`](https://github.com/TauricResearch/TradingAgents/blob/main/tradingagents/graph/trading_graph.py) uses `_get_provider_kwargs()` to inject the correct parameters for each provider when building deep-thinking and quick-thinking LLM instances.
- Supported providers include **OpenAI**, **Google Gemini**, **Anthropic Claude**, and compatible services (Ollama, OpenRouter, xAI) via the `OpenAIClient`.
- Adding a new provider requires subclassing `BaseLLMClient`, updating the factory, and optionally exposing configuration in `TradingGraph`.

## Frequently Asked Questions

### How do I switch between OpenAI and Google Gemini in TradingAgents?

Modify the `llm_provider` value in your configuration dictionary to `"openai"` or `"google"`, and set the corresponding model identifiers in `deep_think_llm` and `quick_think_llm`. For Google, ensure you include `google_thinking_level` in your config; for OpenAI, use `openai_reasoning_effort` to control reasoning intensity.

### Can I use multiple LLM providers simultaneously in the same trading session?

Yes. You can bypass the `TradingGraph` initialization and directly call `create_llm_client()` from `tradingagents/llm_clients` multiple times with different provider names. Each call returns an independent client instance with a normalized `get_llm()` interface, allowing you to route complex analysis to one provider and quick summaries to another.

### Where are provider-specific parameters like `thinking_level` defined?

Provider-specific parameters are stored in the `DEFAULT_CONFIG` dictionary in [`tradingagents/default_config.py`](https://github.com/TauricResearch/TradingAgents/blob/main/tradingagents/default_config.py). The `TradingGraph` class extracts these via the `_get_provider_kwargs()` method and forwards them to the factory. For example, `google_thinking_level` becomes `thinking_level` when building a `GoogleClient`, while `openai_reasoning_effort` is passed directly to `OpenAIClient`.

### How do I add support for a new LLM provider like Mistral?

Create a new client class in `tradingagents/llm_clients/` that subclasses `BaseLLMClient` and implements `get_llm()` and `validate_model()`. Wrap the provider's LangChain chat model with `normalize_content()` to ensure consistent output. Then add a new branch in `create_llm_client()` in [`tradingagents/llm_clients/factory.py`](https://github.com/TauricResearch/TradingAgents/blob/main/tradingagents/llm_clients/factory.py) to instantiate your class when the provider name matches. Finally, update `_get_provider_kwargs()` in [`tradingagents/graph/trading_graph.py`](https://github.com/TauricResearch/TradingAgents/blob/main/tradingagents/graph/trading_graph.py) if your provider requires special configuration flags.