# OpenMAIC LLM Providers: Complete List of Supported AI Models and Configuration Guide

> Discover all eight LLM providers supported by OpenMAIC, including OpenAI, Anthropic, and Google Gemini. Learn how to configure any OpenAI-compatible endpoint with our comprehensive guide.

- Repository: [MAIC/OpenMAIC](https://github.com/THU-MAIC/OpenMAIC)
- Tags: api-reference
- Published: 2026-09-12

---

**OpenMAIC supports eight built-in LLM providers—OpenAI, Anthropic, Azure OpenAI, Google Gemini, MiniMax, Qwen, and Lemonade—plus extensible configuration for any OpenAI-compatible endpoint via the `providersConfig` system.**

OpenMAIC (THU-MAIC/OpenMAIC) is engineered as a provider-neutral framework that abstracts LLM interactions through a unified configuration layer. The platform recognizes providers based on environment variables and runtime settings stored in [`lib/store/settings.ts`](https://github.com/THU-MAIC/OpenMAIC/blob/main/lib/store/settings.ts), enabling seamless switching between cloud APIs and local development servers.

## Complete List of Supported LLM Providers

OpenMAIC automatically detects and initializes providers defined in `.env.example`. Each provider uses a specific string identifier referenced throughout the codebase:

- **openai** – Standard OpenAI API (GPT-4, GPT-4o, GPT-5.x series)
- **anthropic** – Claude models via Anthropic API (claude-3-haiku, claude-3-opus)
- **azure-openai** – Microsoft Azure-hosted OpenAI endpoints
- **gemini** – Google Gemini models (gemini-1.5-flash, gemini-1.5-pro)
- **minimax** – MiniMax LLM service (minimax-m3 and related models)
- **qwen** – Qwen series models (qwen-3.7-plus, qwen-3.7-max)
- **lemonade** – Local OpenAI-compatible mock server for development (no API key required)
- **custom** – User-defined providers added dynamically to `providersConfig`

## Provider Architecture and Configuration

### Cloud API Providers

OpenMAIC implements dedicated adapters in [`lib/ai/providers.ts`](https://github.com/THU-MAIC/OpenMAIC/blob/main/lib/ai/providers.ts) for each commercial service. These adapters handle authentication, request formatting, and model enumeration according to the provider's native protocol.

**Azure OpenAI** requires additional configuration beyond the standard API key, including the resource endpoint and deployment names. **Anthropic** and **Google Gemini** use their respective SDK signatures while conforming to OpenMAIC's internal `ProviderConfig` interface.

### Local Development with Lemonade

The **Lemonade** provider is specifically designed for offline development. As documented in the repository, Lemonade operates as a local, OpenAI-compatible server supporting LLMs, image generation, TTS, and ASR without requiring external API credentials. This provider maps to `localhost` endpoints and is automatically selected when `LEMONADE_BASE_URL` is present or explicitly chosen in settings.

### Custom Provider Extension

You can inject additional providers at runtime by extending the `providersConfig` object in the settings store. OpenMAIC accepts any provider implementing the OpenAI REST API specification, allowing integration with self-hosted models like Ollama, vLLM, or proprietary corporate endpoints.

## Configuring LLM Providers in Code

Provider selection persists through the settings store ([`lib/store/settings.ts`](https://github.com/THU-MAIC/OpenMAIC/blob/main/lib/store/settings.ts)). The store exposes `setProvider()` and `setModel()` methods that validate inputs against the current `providersConfig` and update the active inference pipeline.

### Switching Between Providers

```typescript
import { useSettingsStore } from '@/lib/store/settings';

// Configure OpenAI with a specific model
useSettingsStore.getState().setProvider('openai');
useSettingsStore.getState().setModel('openai', 'gpt-4o');

// Switch to MiniMax
useSettingsStore.getState().setProvider('minimax');
useSettingsStore.getState().setModel('minimax', 'minimax-m3');

// Enable Anthropic Claude
useSettingsStore.getState().setProvider('anthropic');
useSettingsStore.getState().setModel('anthropic', 'claude-3-haiku');

```

### Adding a Custom OpenAI-Compatible Endpoint

Extend the configuration to include private endpoints by modifying the `providersConfig` state:

```typescript
import { useSettingsStore } from '@/lib/store/settings';

useSettingsStore.setState(state => {
  state.providersConfig = {
    ...state.providersConfig,
    myEnterpriseLLM: {
      id: 'myEnterpriseLLM',
      type: 'openai',
      baseUrl: 'https://internal.company.com/v1',
      requiresApiKey: true,
      apiKey: process.env.ENTERPRISE_LLM_KEY,
      models: [
        { id: 'enterprise-model-1' },
        { id: 'enterprise-model-2' }
      ],
    },
  };
});

```

### Environment Variable Requirements

OpenMAIC reads API credentials from environment variables defined in `.env.example`:

```bash
OPENAI_API_KEY=sk-...
ANTHROPIC_API_KEY=sk-ant-...
AZURE_OPENAI_API_KEY=...
AZURE_OPENAI_ENDPOINT=https://...
GEMINI_API_KEY=...
MINIMAX_API_KEY=...
QWEN_API_KEY=...

```

The validation logic in [`tests/store/settings-validation.test.ts`](https://github.com/THU-MAIC/OpenMAIC/blob/main/tests/store/settings-validation.test.ts) checks these variables to determine provider availability via `hasUsableLLMProvider()` and `isLLMProviderConfigured()`.

## Core Implementation Files

| File | Function |
|------|----------|
| [`lib/ai/providers.ts`](https://github.com/THU-MAIC/OpenMAIC/blob/main/lib/ai/providers.ts) | Central adapter logic that routes requests to specific LLM implementations and resolves provider IDs to API clients. |
| [`lib/store/settings.ts`](https://github.com/THU-MAIC/OpenMAIC/blob/main/lib/store/settings.ts) | Zustand store containing `providersConfig`, `setProvider()`, and validation helpers like `hasUsableLLMProvider()`. |
| `.env.example` | Template defining required environment variables for each supported provider. |
| [`components/settings/provider-config-panel.tsx`](https://github.com/THU-MAIC/OpenMAIC/blob/main/components/settings/provider-config-panel.tsx) | React component rendering the provider selection UI based on available configurations. |
| [`tests/store/settings-validation.test.ts`](https://github.com/THU-MAIC/OpenMAIC/blob/main/tests/store/settings-validation.test.ts) | Unit tests verifying provider initialization logic and configuration state validation. |

## Summary

- OpenMAIC ships with **eight pre-configured LLM providers**: OpenAI, Anthropic, Azure OpenAI, Gemini, MiniMax, Qwen, Lemonade, and extensible custom endpoints.
- Provider configuration lives in **[`lib/store/settings.ts`](https://github.com/THU-MAIC/OpenMAIC/blob/main/lib/store/settings.ts)** and is validated through **`hasUsableLLMProvider()`** and **`isLLMProviderConfigured()`**.
- **Lemonade** enables local development without API keys, while cloud providers require corresponding `*_API_KEY` variables from `.env.example`.
- The **`providersConfig`** interface allows runtime addition of OpenAI-compatible endpoints for self-hosted or enterprise models.
- All provider routing logic is centralized in **[`lib/ai/providers.ts`](https://github.com/THU-MAIC/OpenMAIC/blob/main/lib/ai/providers.ts)**, ensuring consistent request handling across different LLM backends.

## Frequently Asked Questions

### Does OpenMAIC support local LLM models?

Yes. OpenMAIC includes first-class support for **Lemonade**, a local OpenAI-compatible server suitable for LLM inference and multimodal tasks (image generation, TTS, ASR) without external API dependencies. You can also configure any local endpoint (Ollama, vLLM, etc.) as a custom provider by setting `type: 'openai'` and pointing `baseUrl` to your local server.

### How do I add a custom OpenAI-compatible endpoint?

Extend the `providersConfig` object in the settings store at runtime. Define a unique ID, set the type to `'openai'`, specify the `baseUrl`, and provide an array of available models. The system automatically routes requests using the OpenAI request format, enabling compatibility with any API-compliant backend.

### Where are provider API keys configured?

API keys are sourced from environment variables listed in `.env.example` (e.g., `OPENAI_API_KEY`, `ANTHROPIC_API_KEY`). The settings store reads these during initialization and validates them through [`tests/store/settings-validation.test.ts`](https://github.com/THU-MAIC/OpenMAIC/blob/main/tests/store/settings-validation.test.ts) to determine which providers are marked as configured and usable.

### Can I switch between providers at runtime without restarting?

Yes. The **SettingsStore** exposes `setProvider()` and `setModel()` methods that immediately update the active LLM backend. These state changes trigger re-validation through `isLLMProviderConfigured()` and reflect instantly in the UI via [`components/settings/provider-config-panel.tsx`](https://github.com/THU-MAIC/OpenMAIC/blob/main/components/settings/provider-config-panel.tsx), allowing dynamic provider switching during a session.