Supported LLM Providers for OpenMAIC: Complete Configuration Guide

OpenMAIC supports eight LLM providers out-of-the-box—OpenAI, Anthropic, Azure OpenAI, Google Gemini, MiniMax, Qwen, Lemonade, and custom OpenAI-compatible endpoints—each configurable via environment variables and the central providersConfig object.

OpenMAIC is designed as a provider-neutral AI platform that abstracts LLM interactions through a unified configuration layer. The supported LLM providers for OpenMAIC are defined in the core TypeScript files and validated through automated tests, ensuring seamless switching between cloud APIs and local deployments.

Built-in LLM Providers

OpenMAIC ships with predefined adapters for major commercial and local LLM services. These providers are automatically registered in the providersConfig object and become available in the UI when their corresponding environment variables are detected.

Provider	Config ID	Description
OpenAI	openai	Standard OpenAI API for GPT-4, GPT-4o, and GPT-5 series models
Anthropic	anthropic	Claude family of models (Claude 3, 3.5, etc.) accessed via Anthropic's API
Azure OpenAI	azure-openai	Microsoft Azure-hosted OpenAI endpoints with enterprise compliance
Google Gemini	gemini	Google's Gemini model family including Flash and Pro variants
MiniMax	minimax	MiniMax commercial LLM service including the MiniMax M3 model
Qwen	qwen	Alibaba's Qwen series (Qwen 2.5, Qwen Max, etc.)
Lemonade	lemonade	Local OpenAI-compatible mock server for offline development and testing
Custom	user-defined	Any OpenAI-compatible API endpoint via manual providersConfig extension

Configuration Architecture

Provider capabilities are centralized in lib/store/settings.ts, which exports the providersConfig TypeScript interface. This configuration object stores API keys, base URLs, and available model lists for each service.

The system exposes two critical validation functions in the same file:

• hasUsableLLMProvider() – Checks if at least one provider has valid credentials
• isLLMProviderConfigured(providerId) – Verifies that a specific provider ID has non-empty API keys and reachable endpoints

When the application initializes, lib/ai/providers.ts reads this configuration and constructs the appropriate request adapters for each enabled service.

Enabling Providers via Environment Variables

Each built-in provider maps to specific environment variables defined in .env.example. OpenMAIC uses these variables to populate the runtime providersConfig object.

# 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://...openai.azure.com/

# Google Gemini

GEMINI_API_KEY=...

# MiniMax

MINIMAX_API_KEY=...

# Qwen

QWEN_API_KEY=...

When these keys are present at runtime, the corresponding provider appears as selectable in components/settings/provider-config-panel.tsx.

Programmatic Provider Selection

Switch between LLM providers programmatically using the settings store. The setProvider() and setModel() methods update the global state and persist preferences.

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

// Switch to OpenAI GPT-4o
useSettingsStore.getState().setProvider('openai');
useSettingsStore.getState().setModel('openai', 'gpt-4o');

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

// Use local Lemonade for testing (no API key required)
useSettingsStore.getState().setProvider('lemonade');
useSettingsStore.getState().setModel('lemonade', 'gpt-4o-mini');

The store validates each selection against providersConfig to ensure the requested model exists for the selected provider ID.

Adding Custom Providers

Extend OpenMAIC to support self-hosted or niche OpenAI-compatible endpoints by mutating the providersConfig object at runtime.

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

useSettingsStore.setState((state) => {
  state.providersConfig = {
    ...state.providersConfig,
    customLocalLLM: {
      id: 'customLocalLLM',
      type: 'openai',
      baseUrl: 'https://localhost:8080/v1',
      requiresApiKey: true,
      apiKey: process.env.CUSTOM_API_KEY,
      models: [
        { id: 'llama-3-8b' },
        { id: 'llama-3-70b' }
      ],
    },
  };
});

Custom providers must specify type: 'openai' to use the OpenAI-compatible request formatting implemented in lib/ai/providers.ts.

Validation and Testing

The tests/store/settings-validation.test.ts file contains unit tests that verify provider configuration logic. These tests ensure that hasUsableLLMProvider() correctly identifies when credentials are missing and that isLLMProviderConfigured() returns accurate boolean states for each supported LLM provider for OpenMAIC.

When adding new providers, extending these tests validates that the provider integrates correctly with the settings store and AI abstraction layer.

Summary

• OpenMAIC supports eight LLM providers natively: OpenAI, Anthropic, Azure OpenAI, Google Gemini, MiniMax, Qwen, Lemonade, and custom endpoints.
• Provider configuration lives in lib/store/settings.ts within the providersConfig object, validated by hasUsableLLMProvider() and isLLMProviderConfigured().
• Environment variables defined in .env.example activate specific providers at runtime.
• Lemonade provides a local, keyless option for development environments.
• Custom OpenAI-compatible APIs can be added by extending providersConfig with a unique provider ID and base URL.

Frequently Asked Questions

How do I switch between OpenAI and Anthropic models in OpenMAIC?

Call useSettingsStore.getState().setProvider('anthropic') followed by setModel('anthropic', 'claude-3-opus-20240229'). The UI in components/settings/provider-config-panel.tsx reflects this change immediately, routing subsequent completions through Anthropic's API endpoint.

Can I use OpenMAIC with a local LLM like Ollama or LM Studio?

Yes. Add a custom provider entry with type: 'openai' and point baseUrl to your local OpenAI-compatible server (e.g., http://localhost:11434/v1 for Ollama's compatibility mode). OpenMAIC will treat it like a standard cloud provider.

What is the Lemonade provider used for?

Lemonade is a built-in local mock server provider that mimics OpenAI's API structure without requiring API keys or internet connectivity. It is ideal for automated testing, offline development, and CI/CD pipelines where external API costs must be avoided.

Where does OpenMAIC validate that my API keys are working?

The tests/store/settings-validation.test.ts file contains the validation suite, while runtime checks occur in lib/store/settings.ts via isLLMProviderConfigured(). These functions verify that API keys are non-empty strings and that required base URLs are defined before allowing the provider to be selected in the interface.

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