# What LLM Providers Are Supported by deepwiki-rs? A Complete Guide

> Discover the LLM providers supported by deepwiki-rs including OpenAI, Anthropic, Google Gemini, Mistral, and more. Get the complete guide to integrating your favorite models.

- Repository: [Sopaco/deepwiki-rs](https://github.com/sopaco/deepwiki-rs)
- Tags: how-to-guide
- Published: 2026-02-16

---

**deepwiki-rs supports nine LLM providers: OpenAI, Anthropic, Google Gemini, Mistral, DeepSeek, Moonshot, OpenRouter, and Ollama for local models.**

The deepwiki-rs Rust library provides a unified abstraction layer that allows developers to switch between different Large Language Model (LLM) backends without rewriting application logic. By implementing a consistent client interface across nine major providers, deepwiki-rs enables flexible AI integrations while maintaining type-safe Rust patterns.

## Supported LLM Providers in deepwiki-rs

The library currently integrates with the following nine providers, each accessible through a unified configuration interface:

- **OpenAI** – Standard OpenAI API including GPT-4, GPT-4o, and GPT-4o-mini models
- **Anthropic** – Claude series models via the Anthropic Messages API
- **Gemini** – Google Gemini models through the Google AI API
- **Mistral** – Mistral AI platform models
- **DeepSeek** – DeepSeek AI models
- **Moonshot** – Moonshot AI platform
- **OpenRouter** – OpenRouter gateway providing access to multiple underlying models
- **Ollama** – Local self-hosted models running on Ollama servers

Each provider is defined as a variant in the `LLMProvider` enum located in [`src/config.rs`](https://github.com/sopaco/deepwiki-rs/blob/main/src/config.rs), allowing compile-time safety when specifying backend targets.

## Architecture: How Provider Abstraction Works

deepwiki-rs implements a two-layer abstraction strategy that separates configuration from runtime implementation.

### Configuration Layer

The `LLMProvider` enum in **src/config.rs** (lines 11-27) defines the nine selectable backends that users configure via TOML files or programmatically:

```rust
// src/config.rs
pub enum LLMProvider {
    OpenAI,
    Anthropic,
    Gemini,
    Mistral,
    DeepSeek,
    Moonshot,
    OpenRouter,
    Ollama,
}

```

### Runtime Layer

The `ProviderClient` enum in **src/llm/client/providers.rs** maps each configuration variant to a concrete `rig` client implementation. This enum implements the client trait methods that handle authentication, request formatting, and response parsing specific to each provider's API.

This architecture ensures that switching from OpenAI to Anthropic requires changing only the `provider` field in your configuration, while all agent creation and prompt execution code remains identical.

## Configuring and Using LLM Providers

To instantiate a specific provider, configure the `LLMConfig` struct with your chosen `LLMProvider` variant and API credentials:

```rust
use deepwiki_rs::config::{LLMConfig, LLMProvider};
use deepwiki_rs::llm::client::ProviderClient;

// Configure for OpenAI (example)
let llm_cfg = LLMConfig {
    provider: LLMProvider::OpenAI,
    api_key: std::env::var("OPENAI_API_KEY")?,
    api_base_url: "https://api.openai.com/v1".into(),
    model_efficient: "gpt-4o-mini".into(),
    model_powerful: "gpt-4o".into(),
    max_tokens: 8192,
    temperature: Some(0.7),
    ..Default::default()
};

// Build the concrete client
let client = ProviderClient::new(&llm_cfg)?;

// Create an agent for a specific model tier
let agent = client.create_agent(
    "gpt-4o-mini",
    "You are a helpful documentation assistant.",
    &llm_cfg,
);

// Execute a prompt
let response = agent.prompt("Explain the architecture of deepwiki-rs.").await?;
println!("{}", response);

```

The `ProviderClient::new()` method inspects the `provider` field in your configuration and instantiates the appropriate underlying client for API communication.

## Switching Between Providers

Changing LLM providers requires modifying only the `provider` variant and corresponding API credentials:

```rust
// Switch to Anthropic Claude
let llm_cfg = LLMConfig {
    provider: LLMProvider::Anthropic,
    api_key: std::env::var("ANTHROPIC_API_KEY")?,
    api_base_url: "https://api.anthropic.com/v1".into(),
    model_efficient: "claude-3-haiku-20240307".into(),
    model_powerful: "claude-3-opus-20240229".into(),
    ..Default::default()
};

// Or use local Ollama instance
let llm_cfg = LLMConfig {
    provider: LLMProvider::Ollama,
    api_key: "ollama".into(),  // Ollama typically doesn't require auth
    api_base_url: "http://localhost:11434".into(),
    model_efficient: "llama3.2".into(),
    model_powerful: "llama3.1:70b".into(),
    ..Default::default()
};

```

All agent creation and prompt execution code remains identical regardless of the selected provider, enabling seamless A/B testing or fallback strategies between different LLM services.

## Summary

- **deepwiki-rs supports nine LLM providers**: OpenAI, Anthropic, Gemini, Mistral, DeepSeek, Moonshot, OpenRouter, and Ollama.
- **Provider abstraction** is implemented through the `LLMProvider` enum in [`src/config.rs`](https://github.com/sopaco/deepwiki-rs/blob/main/src/config.rs) and the `ProviderClient` enum in [`src/llm/client/providers.rs`](https://github.com/sopaco/deepwiki-rs/blob/main/src/llm/client/providers.rs).
- **Configuration-driven switching** allows changing providers by modifying only the `provider` field and API credentials, with all execution code remaining unchanged.
- **Local deployment support** via Ollama enables self-hosted models alongside commercial API providers.

## Frequently Asked Questions

### How do I add a new LLM provider to deepwiki-rs?

To add a new provider, you must extend both the `LLMProvider` enum in [`src/config.rs`](https://github.com/sopaco/deepwiki-rs/blob/main/src/config.rs) and the `ProviderClient` enum in [`src/llm/client/providers.rs`](https://github.com/sopaco/deepwiki-rs/blob/main/src/llm/client/providers.rs). You will also need to implement the client trait methods for the new provider's specific API authentication and request formatting. The modular architecture in the `src/llm/client/` directory facilitates adding new backends without modifying existing provider implementations.

### Does deepwiki-rs support local LLM models?

Yes, deepwiki-rs supports local models through the **Ollama** provider. Configure `LLMProvider::Ollama` with `api_base_url` pointing to your local Ollama server (typically `http://localhost:11434`). This allows you to run self-hosted models like Llama 3, Mistral, or other Ollama-compatible models without sending data to external APIs.

### What is the difference between `LLMProvider` and `ProviderClient`?

`LLMProvider` is a configuration enum defined in [`src/config.rs`](https://github.com/sopaco/deepwiki-rs/blob/main/src/config.rs) that represents the user's selection of which LLM service to use. `ProviderClient` is a runtime enum defined in [`src/llm/client/providers.rs`](https://github.com/sopaco/deepwiki-rs/blob/main/src/llm/client/providers.rs) that contains the actual instantiated clients capable of making API calls. When you call `ProviderClient::new(&llm_cfg)`, the function matches the `LLMProvider` variant from your configuration and returns the corresponding `ProviderClient` variant wrapped with the appropriate authentication and endpoint settings.