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

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, 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 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). The store exposes setProvider() and setModel() methods that validate inputs against the current providersConfig and update the active inference pipeline.

Switching Between Providers

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:

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:

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 checks these variables to determine provider availability via hasUsableLLMProvider() and isLLMProviderConfigured().

Core Implementation Files

File	Function
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	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	React component rendering the provider selection UI based on available configurations.
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 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, 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 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, allowing dynamic provider switching during a session.

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