# How to Switch Between LLM Providers in Ax: A Complete Guide

> Easily switch between LLM providers in Ax by modifying the ai factory function's name property. Our guide shows you how to update this setting for seamless provider changes.

- Repository: [Ax/ax](https://github.com/ax-llm/ax)
- Tags: how-to-guide
- Published: 2026-02-25

---

**Switch between LLM providers in Ax by changing the `name` property in the `ai` factory function, which instantiates the correct provider implementation through a type-safe switch statement in [`src/ax/ai/wrap.ts`](https://github.com/ax-llm/ax/blob/main/src/ax/ai/wrap.ts).**

The Ax library abstracts every supported LLM behind a unified interface, allowing you to switch between OpenAI, Anthropic, Google Gemini, and local models like Ollama without rewriting your application logic. This provider-agnostic architecture means you only change a string identifier and configuration object to migrate from one model to another. Understanding how to switch between LLM providers in Ax enables you to compare performance, optimize costs, or fall back to local inference with minimal code changes.

## The `ai` Factory and `AxAI` Abstraction

At the core of Ax's multi-provider support is the `ai` factory function exported from the main package. When you invoke `ai()`, it forwards your options to `AxAI.create()`, which calls the `AxAI` constructor.

Inside [`src/ax/ai/wrap.ts`](https://github.com/ax-llm/ax/blob/main/src/ax/ai/wrap.ts), the constructor uses a private `switch` statement to map the `name` string to the appropriate concrete implementation:

- `'openai'` → `AxAIOpenAI`
- `'anthropic'` → `AxAIAnthropic`
- `'google-gemini'` → `AxAIGoogleGemini`
- `'ollama'` → `AxAIOllama`
- `'aws-bedrock'` → `AxAIBedrock`

This design ensures that the public API methods—`chat()`, `embed()`, and others—remain identical regardless of which provider you select.

## Supported Providers and Configuration Patterns

Ax supports both commercial APIs and local inference servers. Each provider accepts a standard set of options including `apiKey`, `config` for model parameters, and `models` for custom aliases.

### OpenAI

The default provider for GPT-4 and GPT-3.5 models requires only an API key and optional model configuration.

```typescript
import { ai } from '@ax-llm/ax';

const openai = ai({
  name: 'openai',
  apiKey: process.env.OPENAI_APIKEY!,
});

const response = await openai.chat({
  messages: [{ role: 'user', content: 'Explain quantum entanglement.' }]
});

```

### Anthropic

Switch to Claude models by changing the `name` to `'anthropic'` and specifying your desired model in the `config` object.

```typescript
const claude = ai({
  name: 'anthropic',
  apiKey: process.env.ANTHROPIC_APIKEY!,
  config: { 
    model: 'claude-3-5-sonnet-20240620', 
    temperature: 0.5 
  },
});

await claude.chat({ 
  messages: [{ role: 'user', content: 'Write a haiku about autumn.' }] 
});

```

### Google Gemini

For Google's Gemini models, use the identifier `'google-gemini'`. You can also define named model aliases to switch between fast and capable models at runtime.

```typescript
const gemini = ai({
  name: 'google-gemini',
  apiKey: process.env.GOOGLE_APIKEY!,
  models: [
    { key: 'fast', model: 'gemini-2.0-flash' },
    { key: 'smart', model: 'gemini-1.5-pro' },
  ],
});

// Use the alias 'fast' instead of the full model name
await gemini.chat({ 
  model: 'fast', 
  messages: [{ role: 'user', content: 'Summarize this article.' }] 
});

```

### Local Ollama Models

For local development or privacy-sensitive applications, switch to `'ollama'` to point at your local inference server. No API key is required for local deployments.

```typescript
const ollama = ai({ 
  name: 'ollama', 
  config: { model: 'llama3.2' } 
});

await ollama.chat({ 
  messages: [{ role: 'user', content: 'Give me a recipe for pancakes.' }] 
});

```

## Complete Multi-Provider Implementation

The following example demonstrates switching between providers in the same codebase, as implemented in [`src/examples/image-arrays-multi-provider-test.ts`](https://github.com/ax-llm/ax/blob/main/src/examples/image-arrays-multi-provider-test.ts). Notice how the consumer code remains identical despite underlying provider differences:

```typescript
import { ai } from '@ax-llm/ax';

// Provider 1: OpenAI
const openai = ai({ 
  name: 'openai', 
  apiKey: process.env.OPENAI_APIKEY! 
});

// Provider 2: Ollama (local)
const ollama = ai({ 
  name: 'ollama', 
  config: { model: 'llama3.2' } 
});

// Identical invocation pattern
const [openaiResult, ollamaResult] = await Promise.all([
  openai.chat({ messages: [{ role: 'user', content: 'Hello' }] }),
  ollama.chat({ messages: [{ role: 'user', content: 'Hello' }] })
]);

```

## Advanced Configuration and Model Aliases

Beyond basic provider switching, Ax supports sophisticated configuration patterns through the `models` array. This allows you to abstract model names behind semantic keys like `'fast'`, `'smart'`, or `'coding'`, making it easier to switch models without hardcoding identifiers throughout your application.

According to the source code in [`src/ax/ai/wrap.ts`](https://github.com/ax-llm/ax/blob/main/src/ax/ai/wrap.ts), the `models` parameter accepts an array of objects with `key` and `model` properties. When calling `chat()`, you reference the `key` instead of the provider-specific model string, enabling runtime model selection based on context or user preference.

## Summary

- **Unified Interface**: Ax abstracts all LLM providers behind the `ai` factory and `AxAI` class, ensuring consistent `chat()` and `embed()` methods regardless of backend.
- **Simple Switching**: Change the `name` property to `'openai'`, `'anthropic'`, `'google-gemini'`, or `'ollama'` to instantiate different providers.
- **Type Safety**: The provider selection logic in [`src/ax/ai/wrap.ts`](https://github.com/ax-llm/ax/blob/main/src/ax/ai/wrap.ts) uses a TypeScript switch statement to guarantee valid provider instantiation.
- **Flexible Configuration**: Use the `config` object for parameters like `temperature` and `model`, and the `models` array for custom aliases.
- **Zero Refactoring**: Switching providers requires no changes to your chat invocation logic or response handling code.

## Frequently Asked Questions

### What LLM providers does Ax support?

Ax supports OpenAI, Anthropic Claude, Google Gemini, AWS Bedrock, and local Ollama servers. The [`src/ax/ai/wrap.ts`](https://github.com/ax-llm/ax/blob/main/src/ax/ai/wrap.ts) file contains the authoritative list of supported providers in its internal switch statement. Additional providers can be added by implementing the provider interface and adding a new case to the switch logic.

### How do I configure model aliases in Ax?

Pass a `models` array to the `ai` factory function with objects containing `key` (your alias) and `model` (the provider's model identifier). For example, `{ key: 'fast', model: 'gemini-2.0-flash' }` allows you to call `chat({ model: 'fast' })` instead of remembering the full provider-specific model name.

### Can I use multiple LLM providers in the same Ax application?

Yes. You can instantiate multiple AI instances with different `name` values in the same file or application. Each instance maintains its own configuration and API credentials, allowing you to route specific tasks to specific providers or implement fallback strategies between commercial and local models.

### Where is the provider switching logic implemented in the Ax source code?

The switching logic is implemented in [`src/ax/ai/wrap.ts`](https://github.com/ax-llm/ax/blob/main/src/ax/ai/wrap.ts) within the `AxAI` class constructor. This file contains the `switch` statement that maps the `name` parameter to concrete provider classes like `AxAIOpenAI` or `AxAIAnthropic`. The static `AxAI.create` method and the `ai` factory function both delegate to this constructor.