# What LLM Providers Are Supported by OmniRoute? Complete Registry Guide

> Discover the LLM providers supported by OmniRoute. Explore integrations with OpenAI, Gemini, Azure, Ollama, and more in this comprehensive registry guide.

- Repository: [Diego Rodrigues de Sa e Souza/OmniRoute](https://github.com/diegosouzapw/OmniRoute)
- Tags: api-reference
- Published: 2026-08-30

---

**OmniRoute supports over 20 LLM providers including OpenAI, Anthropic, Google Gemini, Azure OpenAI, and local inference engines like Ollama and LLaMA.cpp, all centralized in the `REGISTRY` map within [`open-sse/config/providerRegistry.ts`](https://github.com/diegosouzapw/OmniRoute/blob/main/open-sse/config/providerRegistry.ts).**

OmniRoute is an open-source intelligent routing layer designed to unify access to diverse large language model APIs and local inference backends. Understanding what LLM providers are supported by OmniRoute enables developers to configure resilient multi-provider architectures with automatic failover. At release **v3.8.51**, the platform maintains a comprehensive Provider Registry that defines supported upstream services, authentication methods, and routing capabilities.

## Provider Registry Architecture

The canonical source of truth for supported providers resides in **[`open-sse/config/providerRegistry.ts`](https://github.com/diegosouzapw/OmniRoute/blob/main/open-sse/config/providerRegistry.ts)**. This file exports a constant `REGISTRY` map where each key represents a unique provider identifier string (e.g., `"openai"`, `"anthropic"`, `"ollama"`).

Every entry in the registry includes metadata that drives routing decisions, authentication handling, and model discovery. You can retrieve the complete list of supported providers at runtime using the **`getRegisteredProviders()`** helper function, which returns an array of all registered provider identifiers.

## Complete List of Supported LLM Providers

As of release **v3.8.51**, OmniRoute officially supports the following provider categories:

### Cloud API Providers (API-Key Authentication)

These providers require standard API key headers for authentication:

- **`openai`** – OpenAI GPT-4, ChatGPT, and embedding models
- **`anthropic`** – Claude family (Claude-3, Claude-2, Claude Instant)
- **`cohere`** – Command-R, Command-R-plus, and embedding models
- **`mistral`** – Mistral-7B, Mixtral, and OpenMixtral variants
- **`groq`** – Groq-hosted Llama-3.1 and Mixtral implementations
- **`xai`** – xAI Titan model series
- **`together`** – Together.ai hosted models (Llama-2, MPT, and others)
- **`deepseek`** – DeepSeek-Chat and DeepSeek-Coder
- **`openrouter`** – OpenRouter aggregation service covering many third-party models
- **`ai21`** – Jurassic-2 series models
- **`alephalpha`** – Aleph Alpha Luminous models
- **`fireworks`** – Fireworks AI hosted models
- **`perplexity`** – Perplexity AI chat models

### Cloud Providers (OAuth Authentication)

These providers use OAuth flows or service-specific authentication schemes:

- **`google`** – Gemini models (Gemini-1.5-Flash, Gemini-1.5-Pro)
- **`azure`** – Azure OpenAI Service deployment-specific models
- **`huggingface`** – Hugging Face Inference API for any Hub model

### AWS Bedrock Integration

OmniRoute supports model access through Amazon Bedrock using OAuth-based credentials:

- **`anthropic/bedrock`** – Anthropic models via AWS Bedrock
- **`google/bedrock`** – Google models via AWS Bedrock
- **`azure/bedrock`** – Azure-hosted Bedrock providers

### Local and Self-Hosted Inference

For on-premises or development environments:

- **`ollama`** – Ollama server integration for any locally available model
- **[`llama.cpp`](https://github.com/diegosouzapw/OmniRoute/blob/main/llama.cpp)** – LLaMA.cpp static binary integration

## Querying Providers at Runtime

Retrieve all supported providers programmatically to build dynamic UIs or validation logic:

```typescript
import { getRegisteredProviders } from "@omniroute/open-sse/config/providerRegistry";

const providers = getRegisteredProviders();
console.log("Supported providers:", providers);
// Output: ['openai', 'anthropic', 'google', 'ollama', ...]

```

### Checking Provider Authentication Types

Determine whether a provider uses OAuth or API-key authentication using **`getProviderCategory()`**:

```typescript
import { getProviderCategory } from "@omniroute/open-sse/config/providerRegistry";

function isOAuth(provider: string): boolean {
  return getProviderCategory(provider) === "oauth";
}

console.log(isOAuth("google"));   // true
console.log(isOAuth("openai"));   // false
console.log(isOAuth("ollama"));   // false

```

### Provider Validation in API Routes

When handling requests, validate providers against the registry before routing:

```typescript
// src/app/api/v1/providers/[provider]/chat/completions/route.ts
import { getRegistryEntry } from "@omniroute/open-sse/config/providerRegistry";

export async function POST(
  req: Request, 
  { params }: { params: { provider: string } }
) {
  const { provider } = params;
  const entry = getRegistryEntry(provider);
  
  if (!entry) throw new Error(`Unknown provider: ${provider}`);
  
  // Use entry.metadata to build HTTP requests, auth headers, etc.
}

```

## Integration Architecture and Key Files

OmniRoute's provider support extends across several critical system components:

- **[`open-sse/config/providerRegistry.ts`](https://github.com/diegosouzapw/OmniRoute/blob/main/open-sse/config/providerRegistry.ts)** – Defines `REGISTRY` and lookup utilities (`getRegisteredProviders`, `getProviderCategory`, `getRegistryEntry`)

- **`src/lib/providers/validation/*.ts`** – Provider-specific validation logic that checks model constraints against registry metadata (e.g., [`openaiFormat.ts`](https://github.com/diegosouzapw/OmniRoute/blob/main/openaiFormat.ts))

- **`src/app/api/v1/providers/[provider]/chat/completions/route.ts`** – Dynamic API route that dispatches requests by consulting the registry at runtime

- **[`src/lib/proxyHealth/providerProbeTarget.ts`](https://github.com/diegosouzapw/OmniRoute/blob/main/src/lib/proxyHealth/providerProbeTarget.ts)** – Health monitoring system that uses `getRegisteredProviders()` to build probing targets for resilience checking

- **[`src/lib/usage/comboScoringInspector.ts`](https://github.com/diegosouzapw/OmniRoute/blob/main/src/lib/usage/comboScoringInspector.ts)** – Combo-routing logic that filters providers based on registry metadata for quota management and scoring

Adding a new LLM provider requires only extending the `REGISTRY` map in the configuration file—surrounding systems automatically recognize and validate the new entry.

## Summary

- OmniRoute maintains a centralized **Provider Registry** in [`open-sse/config/providerRegistry.ts`](https://github.com/diegosouzapw/OmniRoute/blob/main/open-sse/config/providerRegistry.ts) that defines all supported LLM providers as of v3.8.51.
- The platform supports **20+ providers** ranging from cloud APIs (OpenAI, Anthropic, Google) to local inference (Ollama, LLaMA.cpp) and AWS Bedrock integrations.
- Providers are categorized by authentication type: **API-key**, **OAuth**, or **Local** access.
- Use **`getRegisteredProviders()`** to retrieve the full list at runtime for dynamic routing interfaces.
- The registry architecture enables automatic validation, health checking, and failover across all supported providers without code changes to core routing logic.

## Frequently Asked Questions

### How do I add a custom LLM provider to OmniRoute?

Create a new entry in the `REGISTRY` map within [`open-sse/config/providerRegistry.ts`](https://github.com/diegosouzapw/OmniRoute/blob/main/open-sse/config/providerRegistry.ts). Define the provider ID, authentication category (`api-key`, `oauth`, or `local`), and any provider-specific metadata. Once added, `getRegisteredProviders()` automatically includes the new provider, and validation utilities in `src/lib/providers/validation/` will recognize it for request processing.

### What authentication methods does OmniRoute support for LLM providers?

OmniRoute supports three authentication categories as defined in the registry: **API-key** authentication for most cloud providers (sent via headers), **OAuth** flows for services like Google Gemini and Azure OpenAI, and **Local** connections for self-hosted Ollama or LLaMA.cpp instances requiring no remote authentication. Check specific provider requirements using `getProviderCategory(providerId)`.

### Does OmniRoute support local LLM inference without cloud dependencies?

Yes. OmniRoute natively supports **`ollama`** for Ollama server integration and **[`llama.cpp`](https://github.com/diegosouzapw/OmniRoute/blob/main/llama.cpp)** for direct binary execution. These providers are categorized as "Local" in the registry and do not require API keys, enabling fully offline or on-premises LLM deployments alongside cloud providers.

### How does OmniRoute handle routing to unsupported providers?

Requests to providers not present in the `REGISTRY` map return validation errors before reaching external APIs. The `getRegistryEntry()` function returns `undefined` for unknown providers, allowing middleware in routes like `src/app/api/v1/providers/[provider]/chat/completions/route.ts` to throw descriptive errors and prevent misconfigured requests from consuming resources.