# Which LLM Providers Are Currently Supported by Vane?

> Discover which LLM providers Vane supports including OpenAI, Ollama, Google Gemini, and more. Integrate seamlessly with popular models in your projects.

- Repository: [Kushagra Srivastava/Vane](https://github.com/ItzCrazyKns/Vane)
- Tags: faq
- Published: 2026-03-11

---

**Vane supports eight LLM providers: OpenAI, Ollama, Google Gemini, Hugging Face Transformers, Groq, Lemonade AI, Anthropic, and LM Studio**, each implemented as a modular provider class registered in the central [`src/lib/models/providers/index.ts`](https://github.com/ItzCrazyKns/Vane/blob/main/src/lib/models/providers/index.ts) registry.

The open-source Vane framework (ItzCrazyKns/Vane) abstracts AI backend integration through a provider-based architecture. Developers configure and switch between these large language models using a unified interface that handles authentication, model loading, and chat completions across diverse hosting environments.

## Complete List of Vane LLM Providers

Vane’s model layer maintains a strict registry mapping provider keys to their concrete implementations. The `providers` object exported from [`src/lib/models/providers/index.ts`](https://github.com/ItzCrazyKns/Vane/blob/main/src/lib/models/providers/index.ts) defines the following supported integrations:

- **OpenAI** (`openai`): GPT-4, GPT-4o, and other OpenAI models via `OpenAIProvider` ([[`src/lib/models/providers/openai/index.ts`](https://github.com/ItzCrazyKns/Vane/blob/main/src/lib/models/providers/openai/index.ts)](https://github.com/ItzCrazyKns/Vane/blob/master/src/lib/models/providers/openai/index.ts))
- **Ollama** (`ollama`): Local model hosting through `OllamaProvider` for running Llama, Mistral, and other open-weight models locally
- **Google Gemini** (`gemini`): Gemini 1.5 Pro and Flash models via `GeminiProvider` ([[`src/lib/models/providers/gemini/index.ts`](https://github.com/ItzCrazyKns/Vane/blob/main/src/lib/models/providers/gemini/index.ts)](https://github.com/ItzCrazyKns/Vane/blob/master/src/lib/models/providers/gemini/index.ts))
- **Hugging Face Transformers** (`transformers`): Direct model loading via `TransformersProvider` for local inference using the Transformers.js library
- **Groq** (`groq`): High-speed inference for Llama 3, Mixtral, and Gemma models through `GroqProvider` ([[`src/lib/models/providers/groq/index.ts`](https://github.com/ItzCrazyKns/Vane/blob/main/src/lib/models/providers/groq/index.ts)](https://github.com/ItzCrazyKns/Vane/blob/master/src/lib/models/providers/groq/index.ts))
- **Lemonade AI** (`lemonade`): Specialized AI models via `LemonadeProvider` ([[`src/lib/models/providers/lemonade/index.ts`](https://github.com/ItzCrazyKns/Vane/blob/main/src/lib/models/providers/lemonade/index.ts)](https://github.com/ItzCrazyKns/Vane/blob/master/src/lib/models/providers/lemonade/index.ts))
- **Anthropic** (`anthropic`): Claude 3 Opus, Sonnet, and Haiku models through `AnthropicProvider` ([[`src/lib/models/providers/anthropic/index.ts`](https://github.com/ItzCrazyKns/Vane/blob/main/src/lib/models/providers/anthropic/index.ts)](https://github.com/ItzCrazyKns/Vane/blob/master/src/lib/models/providers/anthropic/index.ts))
- **LM Studio** (`lmstudio`): Local AI model management and inference via `LMStudioProvider` ([[`src/lib/models/providers/lmstudio/index.ts`](https://github.com/ItzCrazyKns/Vane/blob/main/src/lib/models/providers/lmstudio/index.ts)](https://github.com/ItzCrazyKns/Vane/blob/master/src/lib/models/providers/lmstudio/index.ts))

Each provider implements the `BaseModelProvider` interface and registers both chat completion capabilities and optional embedding support.

## How Vane Resolves Providers at Runtime

Vane utilizes a three-stage resolution pipeline to instantiate and execute LLM providers:

1. **Configuration Schema**: Each provider defines a UI configuration schema specifying required fields such as API keys, base URLs, and model preferences.
2. **Server-Side Registry**: The [`src/lib/config/serverRegistry.ts`](https://github.com/ItzCrazyKns/Vane/blob/main/src/lib/config/serverRegistry.ts) module loads user-provided configurations and exposes them through `getConfiguredModelProviderById`.
3. **Dynamic Model Loading**: When processing chat requests, Vane invokes `loadChatModel(key)` on the selected provider class (e.g., `OpenAIProvider.loadChatModel`), which validates the model key against available options and returns an instantiated LLM object.

This architecture ensures type-safe provider selection while abstracting backend-specific initialization details.

## Working with LLM Providers in Code

### Listing Available Providers

Retrieve the complete provider catalog for UI rendering or validation using the `getModelProvidersUIConfigSection` function:

```typescript
import { getModelProvidersUIConfigSection } from '@/lib/models/providers';

const providerSections = getModelProvidersUIConfigSection();
console.log(providerSections);
/*
[
  { key: 'openai', name: 'OpenAI', fields: [...] },
  { key: 'ollama', name: 'Ollama', fields: [...] },
  { key: 'gemini', name: 'Google Gemini', fields: [...] },
  // ... remaining providers
]
*/

```

### Loading a Specific Chat Model

Instantiate a concrete LLM implementation for text generation by combining the server registry with the provider's `loadChatModel` method:

```typescript
import { getConfiguredModelProviderById } from '@/lib/config/serverRegistry';

// Retrieve the configured OpenAI provider instance
const provider = getConfiguredModelProviderById('openai')!;

// Load GPT-4o implementation
const llm = await provider.loadChatModel('gpt-4o');

// Generate response
const result = await llm.generateText({
  messages: [{ role: 'user', content: 'Explain quantum tunneling.' }],
});
console.log(result.content);

```

### Retrieving Supported Models

Query a provider's available chat models dynamically:

```typescript
import { getConfiguredModelProviderById } from '@/lib/config/serverRegistry';

const provider = getConfiguredModelProviderById('gemini')!;
const modelList = await provider.getModelList();
console.log('Available chat models:', modelList.chat);

```

## Configuration Architecture

Each provider implementation resides in its own directory under `src/lib/models/providers/` and exports:

- A constructor class extending `BaseModelProvider`
- A `loadChatModel(modelKey)` method returning an LLM instance
- An optional `loadEmbeddingModel()` method for vector operations
- UI configuration fields defined in [`src/lib/config/types.ts`](https://github.com/ItzCrazyKns/Vane/blob/main/src/lib/config/types.ts)

The central registry at [`src/lib/models/providers/index.ts`](https://github.com/ItzCrazyKns/Vane/blob/main/src/lib/models/providers/index.ts) aggregates these implementations into the `providers` record, enabling Vane to resolve any supported backend through a single import point.

## Summary

- Vane supports **eight LLM providers**: OpenAI, Ollama, Google Gemini, Hugging Face Transformers, Groq, Lemonade AI, Anthropic, and LM Studio.
- Provider registration occurs in **[`src/lib/models/providers/index.ts`](https://github.com/ItzCrazyKns/Vane/blob/main/src/lib/models/providers/index.ts)**, which exports a mapping of provider keys to constructor classes.
- Runtime resolution uses **`getConfiguredModelProviderById`** from [`serverRegistry.ts`](https://github.com/ItzCrazyKns/Vane/blob/main/serverRegistry.ts) followed by **`loadChatModel`** to instantiate specific models.
- Each provider implements **`BaseModelProvider`** and optionally supports embeddings alongside chat completions.
- Configuration schemas are provider-specific and loaded server-side to handle authentication and endpoint management.

## Frequently Asked Questions

### How many LLM providers does Vane currently support?

Vane supports **eight distinct LLM providers** as of the latest source code release. These include commercial APIs (OpenAI, Anthropic, Google Gemini, Groq), local hosting solutions (Ollama, LM Studio, Hugging Face Transformers), and specialized platforms (Lemonade AI).

### Can I use local LLMs with Vane without internet connectivity?

Yes. Vane supports three providers specifically designed for local inference: **Ollama**, **LM Studio**, and **Hugging Face Transformers**. These providers load models directly into your environment, enabling offline operation while maintaining the same chat completion interface as cloud-based APIs.

### How does Vane handle authentication for different LLM providers?

Each provider defines a UI configuration schema specifying required credentials such as API keys or base URLs. The [`serverRegistry.ts`](https://github.com/ItzCrazyKns/Vane/blob/main/serverRegistry.ts) module validates and stores these configurations server-side. When `getConfiguredModelProviderById` is called, it retrieves the authenticated provider instance ready for model loading.

### Does every Vane provider support both chat and embeddings?

No. While all eight providers support **chat completions** through `loadChatModel`, **embedding support is optional** and varies by implementation. Check the specific provider's [`index.ts`](https://github.com/ItzCrazyKns/Vane/blob/main/index.ts) file (e.g., [`src/lib/models/providers/openai/index.ts`](https://github.com/ItzCrazyKns/Vane/blob/main/src/lib/models/providers/openai/index.ts)) to determine if `loadEmbeddingModel` is implemented for that backend.