# OpenMAIC LLM Backends: Complete Supported Provider Guide

> Explore OpenMAIC LLM backends including OpenAI, Claude, Gemini, Bedrock, and more. Discover compatible providers like DeepSeek and Qwen for seamless integration.

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

---

**OpenMAIC supports six categories of LLM backends through the Vercel AI SDK, including native OpenAI, Anthropic Claude, Amazon Bedrock, Google Gemini, Anthropic-compatible MiniMax, and any OpenAI-compatible provider such as DeepSeek, Qwen, and Kimi.**

OpenMAIC is an open-source AI framework developed by THU-MAIC that leverages the Vercel AI SDK to provide unified access to multiple large language model providers. The platform's provider architecture is defined in [`lib/ai/providers.ts`](https://github.com/THU-MAIC/OpenMAIC/blob/main/lib/ai/providers.ts), which implements adapters for both native APIs and generic compatibility layers. This extensibility allows developers to switch between cloud and custom endpoints without modifying application logic.

## Native Cloud Provider Support

OpenMAIC implements first-party adapters for four major cloud AI platforms. These providers are initialized through dedicated factory functions that handle authentication and request formatting, as documented in the comment block at lines 4-10 of [`lib/ai/providers.ts`](https://github.com/THU-MAIC/OpenMAIC/blob/main/lib/ai/providers.ts).

### OpenAI

The **OpenAI** provider serves as the default backend, supporting models including GPT-5.6, GPT-5.5, and GPT-4-o. The adapter is created via `createOpenAI` and referenced by the provider ID `'openai'`.

### Anthropic Claude

Native **Anthropic** integration supports Claude models such as `claude-3-5-sonnet-20240620`. This backend uses the `createAnthropic` factory function with the provider ID `'anthropic'`.

### Amazon Bedrock

OpenMAIC includes native support for **Amazon Bedrock** LLMs through the `createAmazonBedrock` adapter, enabling access to AWS-hosted foundation models without intermediate translation layers.

### Google Gemini

**Google Gemini** models are supported via the `createGoogleGenerativeAI` function, allowing direct integration with Google's Generative AI platform using native SDK patterns.

## Anthropic-Compatible Providers

### MiniMax

**MiniMax** implements the Anthropic API specification and is supported as a first-class provider within OpenMAIC. This allows MiniMax service endpoints to utilize the same adapter patterns as native Anthropic Claude, referenced by the provider ID `'minimax'`.

## Generic OpenAI-Compatible Providers

Beyond native integrations, OpenMAIC supports any provider implementing the OpenAI-compatible REST API through a generic adapter. This extensible approach enables integration with numerous Chinese and international model providers without requiring dedicated code changes.

Supported OpenAI-compatible providers include:

- **DeepSeek**
- **Qwen**
- **Kimi**
- **GLM**
- **SiliconFlow**
- **Doubao**
- **Tencent**
- **Xiaomi**
- **Lemonade**

These providers are configured using standard OpenAI SDK patterns with custom base URLs and API keys, referenced by their respective provider IDs in the `PROVIDERS` registry.

## Provider Resolution Architecture

The central registry in [`lib/ai/providers.ts`](https://github.com/THU-MAIC/OpenMAIC/blob/main/lib/ai/providers.ts) defines the `PROVIDERS` constant that maps provider IDs to their respective adapter factories (lines 29-34). When executing an inference request, the `callLLM` function in [`lib/ai/llm.ts`](https://github.com/THU-MAIC/OpenMAIC/blob/main/lib/ai/llm.ts) resolves the appropriate client based on the `providerId` parameter and injects configured API keys or base URLs from the application's settings store.

```typescript
import { callLLM } from '@/lib/ai/llm';

// Example: use OpenAI (default)
await callLLM({
  providerId: 'openai',
  modelId: 'gpt-5.6',
  prompt: 'Summarize the latest research on transformer architectures.',
});

// Example: switch to Anthropic Claude
await callLLM({
  providerId: 'anthropic',
  modelId: 'claude-3-5-sonnet-20240620',
  prompt: 'Explain the concept of chain-of-thought prompting.',
});

// Example: use a custom OpenAI-compatible endpoint (e.g., DeepSeek)
await callLLM({
  providerId: 'deepseek',
  modelId: 'deepseek-chat',
  prompt: 'Write a short poem about autumn.',
});

```

## Model Capabilities and Configuration

OpenMAIC enriches provider definitions with capability metadata through [`lib/ai/model-metadata.ts`](https://github.com/THU-MAIC/OpenMAIC/blob/main/lib/ai/model-metadata.ts), which tracks features like streaming, tool use, vision support, and reasoning capabilities. The [`lib/ai/thinking-config.ts`](https://github.com/THU-MAIC/OpenMAIC/blob/main/lib/ai/thinking-config.ts) module manages chain-of-thought ("thinking") configurations for models that support explicit reasoning parameters. For preserving reasoning across Server-Sent Events streams, [`lib/ai/reasoning-sse.ts`](https://github.com/THU-MAIC/OpenMAIC/blob/main/lib/ai/reasoning-sse.ts) provides middleware that maintains stateful reasoning context.

## Summary

- **OpenMAIC** supports six distinct provider categories through the Vercel AI SDK architecture
- **Native adapters** exist for OpenAI, Anthropic Claude, Amazon Bedrock, and Google Gemini in [`lib/ai/providers.ts`](https://github.com/THU-MAIC/OpenMAIC/blob/main/lib/ai/providers.ts)
- **MiniMax** integrates via Anthropic-compatible API patterns as a specialized provider
- **Generic OpenAI-compatible** support enables DeepSeek, Qwen, Kimi, GLM, SiliconFlow, and others without code changes
- Provider resolution occurs through the `PROVIDERS` registry (lines 29-34) which maps IDs to adapter factories like `createOpenAI` and `createAnthropic`
- The `callLLM` function in [`lib/ai/llm.ts`](https://github.com/THU-MAIC/OpenMAIC/blob/main/lib/ai/llm.ts) handles backend abstraction, request routing, and credential injection

## Frequently Asked Questions

### How do I configure a custom OpenAI-compatible endpoint in OpenMAIC?

Configure the base URL and API key in your application's settings store, then reference the custom provider ID in your `callLLM` invocation. The generic adapter in [`lib/ai/providers.ts`](https://github.com/THU-MAIC/OpenMAIC/blob/main/lib/ai/providers.ts) automatically handles OpenAI-compatible REST API formatting for any endpoint you specify.

### Does OpenMAIC support local or self-hosted LLMs?

Yes. Any self-hosted model exposing an OpenAI-compatible API—such as those served by vLLM, Ollama, or Text Generation Inference—can be integrated using the generic OpenAI-compatible adapter. No native code changes are required if the endpoint adheres to OpenAI's REST specification.

### Which file determines available model capabilities like tool use or vision?

Model capabilities including streaming, tool use, vision support, and reasoning modes are defined in [`lib/ai/model-metadata.ts`](https://github.com/THU-MAIC/OpenMAIC/blob/main/lib/ai/model-metadata.ts). This file enriches provider definitions with metadata that determines which features are exposed for each LLM backend supported by OpenMAIC.

### Can I switch between providers without changing my application code?

Yes. The `callLLM` function abstracts provider-specific implementation details. Changing only the `providerId` and `modelId` parameters is sufficient to switch between any registered backend, including transitions from native OpenAI to Anthropic-compatible or generic OpenAI-compatible endpoints.