Which LLM Providers Are Currently Supported by Vane?

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 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 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/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/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/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/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/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/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 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:

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:

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:

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

The central registry at 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, which exports a mapping of provider keys to constructor classes.
• Runtime resolution uses getConfiguredModelProviderById from 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 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 file (e.g., src/lib/models/providers/openai/index.ts) to determine if loadEmbeddingModel is implemented for that backend.

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