# Which AI Providers Does Fabric Support? Complete Vendor List and Integration Guide

> Discover which AI providers Fabric supports. Explore over 26 AI services including native plugins and OpenAI-compatible options with our comprehensive integration guide.

- Repository: [Daniel Miessler 🛡️/fabric](https://github.com/danielmiessler/fabric)
- Tags: api-reference
- Published: 2026-02-28

---

**Fabric supports two families of AI integrations: 9 native vendor-specific plugins and 17 OpenAI-compatible providers, totaling 26+ AI services accessible through a unified interface.**

Fabric, the open-source AI framework maintained by Daniel Miessler, implements a **plugin-based architecture** that abstracts AI provider differences behind a common `Vendor` interface. This design allows users to switch between commercial APIs and local models without changing their workflows.

## Native AI Providers (Vendor-Specific Plugins)

Fabric ships with **native integrations** for major AI vendors. Each implementation lives under `internal/plugins/ai/<vendor>/` and provides custom authentication, request building, and response parsing logic tailored to that provider's API.

As of version **v1.4.417**, the native provider list includes:

- **OpenAI** – GPT-4, GPT-3.5, and related models
- **Anthropic** – Claude 3.5 Sonnet, Claude 3 Opus, and Claude 3 Haiku
- **Google Gemini** – Gemini Pro and Gemini Pro Vision
- **Ollama** – Local model hosting for Llama, Mistral, and other open-weight models
- **Azure OpenAI** – Enterprise OpenAI deployments on Microsoft Azure
- **Amazon Bedrock** – AWS-managed foundation models including Claude, Llama, and Titan
- **Vertex AI** – Google Cloud's model hosting platform
- **LM Studio** – Local model server with OpenAI-compatible endpoints
- **Perplexity** – Conversational search and LLM API

These plugins implement the `Vendor` interface defined in the codebase, registering themselves during CLI startup through `registry.VendorsAll.SetupVendor` in [`internal/plugins/ai/vendors.go`](https://github.com/danielmiessler/fabric/blob/main/internal/plugins/ai/vendors.go).

## OpenAI-Compatible Providers (Generic Wrapper)

Beyond native integrations, Fabric includes a **generic OpenAI-compatible wrapper** that connects to any service exposing the OpenAI HTTP API specification. This architecture lives in `internal/plugins/ai/openai_compatible/` and enables rapid onboarding of new providers without custom code.

The wrapper's `NewClientCompatibleWithResponses` function creates clients that optionally support the newer **Responses API**, while [`providers_config.go`](https://github.com/danielmiessler/fabric/blob/main/providers_config.go) handles provider-specific configuration like base URLs and authentication tokens.

Supported OpenAI-compatible providers include:

- **Abacus**
- **AIML**
- **Cerebras**
- **DeepSeek**
- **DigitalOcean**
- **GitHub Models**
- **GrokAI**
- **Groq**
- **Langdock**
- **LiteLLM**
- **MiniMax**
- **Mistral**
- **Novita AI**
- **OpenRouter**
- **SiliconCloud**
- **Together**
- **Venice AI**
- **Z AI**

## How Fabric Discovers and Loads AI Providers

Fabric's provider discovery happens at runtime through a **plugin registry pattern** defined in [`internal/core/plugin_registry.go`](https://github.com/danielmiessler/fabric/blob/main/internal/core/plugin_registry.go).

### Vendor Registration Process

During CLI initialization, the `PluginRegistry` executes `registry.VendorsAll.SetupVendor`, which scans `internal/plugins/ai/*` and registers every detected vendor in the `VendorsManager`. Each native vendor (like [`openai/openai.go`](https://github.com/danielmiessler/fabric/blob/main/openai/openai.go) or [`anthropic/anthropic.go`](https://github.com/danielmiessler/fabric/blob/main/anthropic/anthropic.go)) implements the required `Vendor` interface methods for authentication and model enumeration.

### Case-Insensitive Vendor Selection

The system normalizes vendor names using `strings.ToLower` in [`internal/plugins/ai/vendors.go`](https://github.com/danielmiessler/fabric/blob/main/internal/plugins/ai/vendors.go) (lines 72-73). This means `--vendor OpenAI`, `--vendor openai`, and `--vendor OPENAI` all resolve to the same plugin, preventing configuration errors due to capitalization.

### Model Enumeration

The `VendorsManager.GetModels` routine aggregates available models from each active vendor—either by querying endpoints like `/v1/models` for OpenAI-compatible services or reading static configurations. The REST API server exposes this aggregated list at `/api/models`, consumed by the web interface ([`web/src/lib/api/models.ts`](https://github.com/danielmiessler/fabric/blob/main/web/src/lib/api/models.ts)) to populate model selection dropdowns.

## Using AI Providers in Fabric

### Listing Available Vendors

To see all registered providers in your Fabric installation:

```bash
fabric --listvendors

```

This command invokes `registry.VendorsAll.ListVendors()`, iterating over the populated `VendorsManager` map to display both native and OpenAI-compatible providers.

### Running Commands with Specific Providers

Select a provider using the `--vendor` flag or `FABRIC_VENDOR` environment variable:

```bash

# Use Anthropic Claude for a single command

FABRIC_VENDOR=Anthropic fabric -m claude-3-5-sonnet "Summarize this article."

# Alternative syntax using CLI flag

fabric --vendor Ollama -m llama3.2 "Explain quantum computing."

```

The CLI parses this flag in [`internal/cli/cli.go`](https://github.com/danielmiessler/fabric/blob/main/internal/cli/cli.go) (line 178) and passes the value to `PluginRegistry.GetChatter`, which retrieves the matching `Vendor` instance from the manager.

### Configuring OpenAI-Compatible Providers

Add new compatible providers through environment variables or the interactive `fabric --setup` wizard:

```bash

# ~/.config/fabric/.env

FABRIC_VENDOR=DeepSeek
FABRIC_DEEPSEEK_API_KEY=sk-your-key-here
FABRIC_DEEPSEEK_BASE_URL=https://api.deepseek.com/v1

```

The configuration system in [`internal/plugins/ai/openai_compatible/providers_config.go`](https://github.com/danielmiessler/fabric/blob/main/internal/plugins/ai/openai_compatible/providers_config.go) automatically reads `FABRIC_<PROVIDER>_BASE_URL` and `FABRIC_<PROVIDER>_API_KEY` variables, instantiating the client without requiring code changes.

### Programmatic Access (Go SDK)

For applications embedding Fabric's engine:

```go
import (
    "github.com/danielmiessler/fabric/internal/core"
    "fmt"
)

func main() {
    // Initialize registry (loads all native and compatible vendors)
    registry := core.NewPluginRegistry()
    
    // Find vendor by name (case-insensitive via strings.EqualFold)
    vendor := registry.VendorManager.FindByName("VertexAI")
    
    // Retrieve available models
    models, _ := vendor.GetModels()
    fmt.Println("Available VertexAI models:", models)
}

```

The `FindByName` method performs case-insensitive matching as implemented in [`internal/plugins/ai/vendors.go`](https://github.com/danielmiessler/fabric/blob/main/internal/plugins/ai/vendors.go).

## Summary

- **Fabric supports 26+ AI providers** through two architectural patterns: 9 native vendor plugins and 17 OpenAI-compatible wrappers.
- **Native integrations** reside in `internal/plugins/ai/<vendor>/` and implement custom logic for OpenAI, Anthropic, Gemini, Ollama, Azure, Bedrock, Vertex AI, LM Studio, and Perplexity.
- **OpenAI-compatible providers** use the generic wrapper in `internal/plugins/ai/openai_compatible/` to connect to services like DeepSeek, Groq, Mistral, and GitHub Models without custom code.
- **Runtime discovery** occurs via `PluginRegistry` and `VendorsManager`, with case-insensitive vendor name resolution (`strings.ToLower`) preventing configuration errors.
- **Unified interface** means switching between providers requires only changing the `--vendor` flag or `FABRIC_VENDOR` environment variable, with no pattern modifications needed.

## Frequently Asked Questions

### How do I add a custom AI provider that isn't in the official list?

Configure any OpenAI-compatible endpoint using environment variables. Set `FABRIC_VENDOR=YourProviderName`, `FABRIC_YOURPROVIDERNAME_BASE_URL`, and `FABRIC_YOURPROVIDERNAME_API_KEY` in your shell or `~/.config/fabric/.env` file. The generic wrapper in `internal/plugins/ai/openai_compatible/` will instantiate the client automatically.

### Does Fabric support local AI models without internet access?

Yes. The **Ollama** native integration and **LM Studio** provider both support entirely local inference. Configure Ollama with your local endpoint (typically `http://localhost:11434`), or point LM Studio at its local server address to run models like Llama 3 or Mistral without external API calls.

### Why does Fabric use both native plugins and OpenAI-compatible wrappers?

Native plugins in `internal/plugins/ai/` handle vendor-specific quirks like Anthropic's message format or Google's authentication flows, while the OpenAI-compatible wrapper maximizes extensibility. According to the source code in [`internal/plugins/ai/openai_compatible/providers_config.go`](https://github.com/danielmiessler/fabric/blob/main/internal/plugins/ai/openai_compatible/providers_config.go), this dual approach lets Fabric onboard new providers immediately when they launch OpenAI-compatible endpoints, without waiting for dedicated plugin development.

### How does Fabric handle authentication for different providers?

Each native vendor implements its own authentication logic—API keys for OpenAI, service account credentials for Vertex AI, or AWS signatures for Bedrock. For OpenAI-compatible providers, the wrapper reads standardized `FABRIC_<PROVIDER>_API_KEY` variables from [`providers_config.go`](https://github.com/danielmiessler/fabric/blob/main/providers_config.go). Run `fabric --setup` to interactively configure credentials for all detected providers.