# Which LLM Providers Are Supported by OpenMAIC? A Complete Technical Guide > Explore LLM providers supported by OpenMAIC: OpenAI, Anthropic, Azure OpenAI, Gemini, and more. Discover how to integrate custom endpoints easily. - Repository: [MAIC/OpenMAIC](https://github.com/THU-MAIC/OpenMAIC) - Tags: how-to-guide - Published: 2026-09-11 --- **OpenMAIC supports OpenAI, Anthropic (Claude), Azure OpenAI, Google Gemini, MiniMax, Qwen, and the local Lemonade mock server, with extensible architecture allowing custom OpenAI-compatible endpoints via the `providersConfig` object.** OpenMAIC is an open-source multimodal AI client designed to be provider-agnostic. Understanding which large language model (LLM) providers are supported out-of-the-box—and how to extend them—is essential for configuring your deployment. This guide examines the source code in the `THU-MAIC/OpenMAIC` repository to document every supported provider and the configuration mechanisms that enable them. ## Built-In LLM Providers in OpenMAIC The default `providersConfig` object in the OpenMAIC codebase recognizes the following providers by their string identifiers. Each maps to specific environment variables defined in `.env.example` and specific adapter logic in [`lib/ai/providers.ts`](https://github.com/THU-MAIC/OpenMAIC/blob/main/lib/ai/providers.ts): - **OpenAI** (`openai`): Native support for GPT-4, GPT-4o, and GPT-3.5-turbo models via the standard OpenAI REST API. - **Anthropic** (`anthropic`): Supports Claude model family including `claude-3-haiku`, `claude-3-sonnet`, and `claude-3-opus` through the Anthropic Messages API. - **Azure OpenAI** (`azure-openai`): Enterprise support for Azure-hosted OpenAI endpoints using Azure API key authentication and custom base URLs. - **Google Gemini** (`gemini`): Native integration for Gemini 1.5 Flash and Gemini 1.5 Pro models via the Google Generative Language API. - **MiniMax** (`minimax`): Support for the MiniMax M3 model and other MiniMax-hosted LLMs. - **Qwen** (`qwen`): Integration for Qwen series models including `qwen-3.7-plus` and `qwen-3.7-max`. - **Lemonade** (`lemonade`): A local, OpenAI-compatible mock server included for offline development and testing without API costs. These providers are automatically instantiated when their corresponding `*_API_KEY` environment variables are detected, as validated by the `hasUsableLLMProvider` and `isLLMProviderConfigured` functions in [`lib/store/settings.ts`](https://github.com/THU-MAIC/OpenMAIC/blob/main/lib/store/settings.ts). ## Configuration via Environment Variables OpenMAIC uses a convention-based environment configuration system. The `.env.example` file at the repository root defines the expected variables for each provider: ```bash # OpenAI OPENAI_API_KEY=sk-... OPENAI_BASE_URL=https://api.openai.com/v1 # Anthropic (Claude) ANTHROPIC_API_KEY=sk-ant-... # Azure OpenAI AZURE_OPENAI_API_KEY=... AZURE_OPENAI_ENDPOINT=https://your-resource.openai.azure.com/ # Google Gemini GEMINI_API_KEY=... # MiniMax MINIMAX_API_KEY=... # Qwen QWEN_API_KEY=... ``` The settings validation logic in [`tests/store/settings-validation.test.ts`](https://github.com/THU-MAIC/OpenMAIC/blob/main/tests/store/settings-validation.test.ts) verifies that a provider is only considered "usable" when its required API key is present and non-empty. ## Provider Registration Architecture The central registry for LLM providers lives in [`lib/ai/providers.ts`](https://github.com/THU-MAIC/OpenMAIC/blob/main/lib/ai/providers.ts). This module exports the `providersConfig` interface and default implementations that map provider IDs to their request adapters. In [`lib/store/settings.ts`](https://github.com/THU-MAIC/OpenMAIC/blob/main/lib/store/settings.ts), the global state store maintains the active provider configuration through methods like `setProvider(providerId: string)` and `setModel(providerId: string, modelId: string)`. The store also exposes utility functions: - **`hasUsableLLMProvider()`**: Returns true if at least one configured provider has valid credentials. - **`isLLMProviderConfigured(providerId: string)`**: Validates that a specific provider exists in `providersConfig` and has required authentication. The UI selection panel ([`components/settings/provider-config-panel.tsx`](https://github.com/THU-MAIC/OpenMAIC/blob/main/components/settings/provider-config-panel.tsx)) renders the list of available providers by iterating over this configuration object, ensuring the interface always reflects the currently supported set. ## Switching Providers Programmatically You can change the active LLM provider at runtime using the settings store. This is useful for building provider-agnostic features or testing multiple models: ```typescript import { useSettingsStore } from '@/lib/store/settings'; // Switch to Anthropic Claude useSettingsStore.getState().setProvider('anthropic'); useSettingsStore.getState().setModel('anthropic', 'claude-3-haiku'); // Switch to Google Gemini useSettingsStore.getState().setProvider('gemini'); useSettingsStore.getState().setModel('gemini', 'gemini-1.5-flash'); // Check if configuration is valid const isReady = useSettingsStore.getState().hasUsableLLMProvider(); ``` Each call updates the `providersConfig` state and triggers validation against the environment variables. ## Adding Custom OpenAI-Compatible Providers OpenMAIC supports arbitrary OpenAI-compatible endpoints by extending the `providersConfig` object. This pattern allows integration with self-hosted models (like Ollama or vLLM) or third-party APIs that mirror the OpenAI schema: ```typescript import { useSettingsStore } from '@/lib/store/settings'; useSettingsStore.setState((state) => ({ providersConfig: { ...state.providersConfig, custom_llm: { id: 'custom_llm', type: 'openai', // Uses OpenAI request format baseUrl: 'https://my-llm.internal/api/v1', requiresApiKey: true, apiKey: process.env.CUSTOM_LLM_KEY, models: [ { id: 'custom-model-1' }, { id: 'custom-model-2' } ], }, }, })); ``` The `type: 'openai'` designation instructs the request builder in [`lib/ai/providers.ts`](https://github.com/THU-MAIC/OpenMAIC/blob/main/lib/ai/providers.ts) to use standard OpenAI SDK patterns for chat completions, ensuring compatibility without custom adapter code. ## Local Development with Lemonade For offline development, OpenMAIC includes support for **Lemonade**, a lightweight local server that mocks OpenAI-compatible endpoints for LLMs, image generation, TTS, and ASR. To use Lemonade, set the provider to `lemonade` without requiring an API key: ```typescript useSettingsStore.getState().setProvider('lemonade'); useSettingsStore.getState().setModel('lemonade', 'gpt-4o-mini'); ``` This configuration routes requests to `http://localhost:8000` (or your configured Lemonade port), enabling full-stack testing without external API calls or quota consumption. ## Summary - OpenMAIC natively supports **OpenAI, Anthropic, Azure OpenAI, Google Gemini, MiniMax, and Qwen** through environment variable configuration. - The **`providersConfig`** object in [`lib/store/settings.ts`](https://github.com/THU-MAIC/OpenMAIC/blob/main/lib/store/settings.ts) defines available providers, while [`lib/ai/providers.ts`](https://github.com/THU-MAIC/OpenMAIC/blob/main/lib/ai/providers.ts) handles request adaptation. - **Lemonade** provides a local, OpenAI-compatible mock server for development environments. - Custom providers can be added at runtime by extending `providersConfig` with `type: 'openai'` for any OpenAI-compatible endpoint. - Validation logic in [`tests/store/settings-validation.test.ts`](https://github.com/THU-MAIC/OpenMAIC/blob/main/tests/store/settings-validation.test.ts) ensures providers are only marked usable when properly authenticated. ## Frequently Asked Questions ### What is the complete list of supported LLM providers in OpenMAIC? According to the `THU-MAIC/OpenMAIC` source code, the officially supported providers are OpenAI (`openai`), Anthropic (`anthropic`), Azure OpenAI (`azure-openai`), Google Gemini (`gemini`), MiniMax (`minimax`), Qwen (`qwen`), and the local development server Lemonade (`lemonade`). Each provider is defined in the `providersConfig` schema and requires specific environment variables to activate. ### How do I add a custom LLM provider to OpenMAIC? You can add a custom provider by mutating the `providersConfig` state in [`lib/store/settings.ts`](https://github.com/THU-MAIC/OpenMAIC/blob/main/lib/store/settings.ts). Define a new entry with a unique `id`, set `type: 'openai'` for compatibility, and provide the `baseUrl` and `apiKey`. The system will automatically use OpenAI SDK patterns to communicate with your endpoint. ### Does OpenMAIC support local LLM inference? Yes. OpenMAIC supports local inference through the **Lemonade** provider, which acts as a local OpenAI-compatible mock server. Additionally, you can configure any self-hosted OpenAI-compatible endpoint (such as Ollama or vLLM) by adding it as a custom provider with `type: 'openai'` and pointing the `baseUrl` to your local server address. ### Where are the provider configurations validated in the OpenMAIC codebase? Provider configurations are validated in [`lib/store/settings.ts`](https://github.com/THU-MAIC/OpenMAIC/blob/main/lib/store/settings.ts) through the `isLLMProviderConfigured` and `hasUsableLLMProvider` functions. Unit tests in [`tests/store/settings-validation.test.ts`](https://github.com/THU-MAIC/OpenMAIC/blob/main/tests/store/settings-validation.test.ts) verify that these functions correctly identify when providers have valid credentials and properly formed configuration objects.