> ## Documentation Index
> Fetch the complete documentation index at: https://personal-ce79cb71.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Configure LLM Providers for BugViper AI Code Reviews

> Connect BugViper to OpenRouter, Google Gemini, or MiniMax. Choose which LLM model powers review agents, the verifier, and deduplication.

BugViper supports multiple LLM providers and lets you assign a different model to each step of the review pipeline. You can use a powerful frontier model for deep code analysis while keeping a smaller, cheaper model for tasks like deduplication and summary synthesis — giving you full control over quality and cost.

## Provider Setup

Set the API key for whichever provider you want to use. You can configure more than one provider at a time and mix models from different providers across the different roles.

<Tabs>
  <Tab title="OpenRouter">
    [OpenRouter](https://openrouter.ai/) provides a single API key that unlocks
    access to hundreds of models from Anthropic, OpenAI, Google, DeepSeek,
    Mistral, and more. It is the most flexible option and is the recommended
    starting point for most self-hosters.

    Set your key in `.env`:

    ```env theme={null}
    OPENROUTER_API_KEY=sk-or-v1-xxxxxxxxxxxxxxxxxxxxxxxxxxxx
    ```

    Example model strings you can use with OpenRouter:

    ```
    anthropic/claude-sonnet-4-5
    openai/gpt-4o-mini
    deepseek/deepseek-v4-flash
    ```

    BugViper automatically routes to OpenRouter for any model string that does
    not start with `gemini/` or `MiniMax-`.
  </Tab>

  <Tab title="Google Gemini">
    To use Google Gemini models, set your Gemini API key. You can obtain one for
    free from [Google AI Studio](https://aistudio.google.com/).

    ```env theme={null}
    GEMINI_API_KEY=AIzaSy-xxxxxxxxxxxxxxxxxxxxxxxxxxxx
    ```

    Use Gemini model identifiers prefixed with `gemini/` when assigning models
    to roles:

    ```
    gemini/gemini-2.0-flash
    gemini/gemini-2.5-pro
    ```

    BugViper routes to the Gemini provider automatically for any model string
    that starts with `gemini/`.
  </Tab>

  <Tab title="MiniMax">
    To use MiniMax models, set your MiniMax API key:

    ```env theme={null}
    MINIMAX_API_KEY=your-minimax-api-key
    ```

    Use model identifiers that start with `MiniMax-` when assigning roles:

    ```
    MiniMax-Text-01
    ```

    BugViper routes to MiniMax automatically for any model string that starts
    with `MiniMax-`.
  </Tab>
</Tabs>

## Model Role Assignment

BugViper breaks the review pipeline into distinct steps, and you can assign a different model to each one. All model roles fall back to `DEEPAGENT_MODEL` if not explicitly set, so the minimum configuration is just one variable.

<ParamField path="DEEPAGENT_MODEL" type="string" default="deepseek/deepseek-v4-flash">
  The primary model used by the review agent(s). This is also the global
  fallback — if `ORCHESTRATOR_MODEL`, `SUBAGENT_MODEL`, `JUDGE_MODEL`, or
  `DEDUP_MODEL` are left unset, they all default to this value. Choose a model
  with strong code understanding for best results.
</ParamField>

<ParamField path="ORCHESTRATOR_MODEL" type="string" default="DEEPAGENT_MODEL">
  The model used by the orchestrator in Deep mode. The orchestrator is
  responsible for coordinating the three specialized sub-agents (correctness,
  security, and performance). Defaults to `DEEPAGENT_MODEL` if not set.
</ParamField>

<ParamField path="SUBAGENT_MODEL" type="string" default="DEEPAGENT_MODEL">
  The model used by each specialized sub-agent in Deep mode. You can set this to
  a different model than the orchestrator — for example, a faster model for
  sub-agents and a stronger model for orchestration. Defaults to
  `DEEPAGENT_MODEL` if not set.
</ParamField>

<ParamField path="JUDGE_MODEL" type="string" default="deepseek/deepseek-v4-flash">
  The model used by the verifier pass. After the review agents produce their
  findings, the judge validates each one against the actual PR diff, removes
  false positives, and classifies issues as `valid`, `nitpick`, or
  `outside_diff`. A strong reasoning model works best here.
</ParamField>

<ParamField path="DEDUP_MODEL" type="string" default="openai/gpt-4o-mini">
  The model used for deduplication. After all agents have run, this model merges
  duplicate findings that refer to the same underlying issue. Because this is a
  classification-style task, a smaller model is sufficient.
</ParamField>

<ParamField path="SYNTHESIS_MODEL" type="string" default="openai/gpt-4o-mini">
  The model used to generate the summary that is posted as the PR review body.
  This is a summarization task and does not require deep code reasoning, so a
  smaller model keeps costs down without affecting quality.
</ParamField>

<Tip>
  Use a smaller, cheaper model for `DEDUP_MODEL` and `SYNTHESIS_MODEL` — tasks
  like deduplication and summary generation don't require deep code reasoning.
  For example, `openai/gpt-4o-mini` via OpenRouter is fast and very
  cost-effective for these steps, freeing you to use a stronger model for
  `DEEPAGENT_MODEL` and `JUDGE_MODEL` where it matters most.
</Tip>