Which LLM Providers Are Supported by OpenMAIC? A Complete Technical Guide

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:

• 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.

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:

# 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 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. This module exports the providersConfig interface and default implementations that map provider IDs to their request adapters.

In 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) 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:

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:

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 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:

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 defines available providers, while 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 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. 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 through the isLLMProviderConfigured and hasUsableLLMProvider functions. Unit tests in tests/store/settings-validation.test.ts verify that these functions correctly identify when providers have valid credentials and properly formed configuration objects.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}