> ## Documentation Index
> Fetch the complete documentation index at: https://docs.coderabbit.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Gemini integration

> Enable Gemini to execute CodeRabbit directly in your development workflow. Let AI code, review, and fix issues autonomously without human intervention.

## Overview

Use CodeRabbit with Google's Gemini CLI in a full agentic loop. Code with Gemini, review the changes with CodeRabbit, and fix the issues with Gemini. In this quick guide, you'll learn how to prompt Gemini, what CodeRabbit commands to run, and what to add to your Gemini.md file.

## Video demo

<iframe className="w-full aspect-video rounded-xl" src="https://www.youtube.com/embed/bUsotzld3CA" title="CodeRabbit CLI + Gemini integration demo" frameBorder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowFullScreen />

## Prerequisites

<Steps>
  <Step title="Install the Gemini CLI">
    Install the Gemini CLI following the [platform-specific instructions](https://geminicli.com/). Login in, and check that you can launch Gemini from your terminal.
  </Step>

  <Step title="Install CodeRabbit CLI">
    Install the CodeRabbit CLI globally on your system:

    <CodeGroup>
      ```bash Installation script theme={null}
      curl -fsSL https://cli.coderabbit.ai/install.sh | sh
      ```

      ```bash Homebrew theme={null}
      brew install coderabbit
      ```
    </CodeGroup>

    Restart your shell:

    ```bash Terminal command wrap theme={null}
    source ~/.zshrc
    ```
  </Step>

  <Step title="Log into CodeRabbit">
    Log into CodeRabbit by running the following command in your terminal:

    ```bash theme={null}
    coderabbit auth login
    ```

    A browser window opens automatically. Sign in to CodeRabbit and the authentication completes in the browser.

    <Tip>
      Authentication persists across Gemini instances - you only need to do this once per machine.
    </Tip>
  </Step>

  <Step title="Verify authentication">
    Test that login was successful by running the following command in your terminal:

    ```bash Terminal command wrap theme={null}
    coderabbit auth status
    ```

    Success shows your login status and confirms you're logged into CodeRabbit.
  </Step>
</Steps>

## Use CodeRabbit as part of building new features

<Steps>
  <Step title="CodeRabbit usage instructions for Gemini CLI">
    Add the following to your Gemini.md file:

    ```Text Prompt for Gemini.md file wrap theme={null}
    Run the CodeRabbit CLI by running the command: `coderabbit --agent -t uncommitted`. It's a long running task and may take up to 30 minutes. Check every 2 minutes if it's complete and once it's done review and validate critical fixes and recommended fixes, while ignoring nits or unnecessary changes. Then fix those and run CodeRabbit again. You can run this loop up to 3 times. Let the user know the outcomes.
    ```

    Feel free to customize the prompt to your needs. In general you want to convey:

    * How to run CodeRabbit, i.e. using the `--agent` flag and that it's a CLI tool already installed.
    * That it's a long running task and may take a while. Otherwise it may time out.
    * Any guidelines for how you want Gemini to review and implement the changes. i.e. fix only critical issues.
    * Some agents run CodeRabbit multiple times, so let them know the total number of times it should run.
  </Step>

  <Step title="Request implementation + review">
    Ask Gemini to implement a feature and run CodeRabbit analysis with issue fixes:

    ```Text Prompt for Gemini wrap theme={null}
    Please implement phase 7.3 of the planning doc and then run CodeRabbit
    ```

    <Tip> Because we added how to run CodeRabbit to your Gemini.md file, Gemini should run it correctly, but it's non-deterministic, so you may need to remind it to reference the Gemini.md file for the instructions.</Tip>
  </Step>

  <Step title="Agentic step: Gemini implements feature and runs CodeRabbit">
    Gemini: 1. Implements the requested feature 2. Runs `coderabbit --agent`
    3\. Checks CodeRabbit's progress periodically
  </Step>

  <Step title="Agentic step: CodeRabbit analysis and task creation">
    When CodeRabbit completes, Gemini:

    1. Reads the `--agent` output
    2. Reviews the issues CodeRabbit surfaced
    3. Implements the fixes
  </Step>

  <Step title="Agentic step: Loops to stop or resolution">
    Gemini will run CodeRabbit again to verify the fixes and to make sure no other issues were introduced. This loop will continue until all critical issues are resolved or the loop limit is reached.
  </Step>
</Steps>

## Optimization tips

### Output modes for agent integration

When running CodeRabbit for agent use, choose the output mode that best fits your workflow:

```bash theme={null}
# Structured JSON output
coderabbit --agent

# Detailed plain-text output
coderabbit --plain

# Browsable terminal UI
coderabbit --interactive
```

| Mode            | Best for                                                         |
| --------------- | ---------------------------------------------------------------- |
| `--agent`       | Gemini and other agent integrations that consume structured JSON |
| `--plain`       | Human-readable terminal output during manual workflows           |
| `--interactive` | Manual review in an interactive terminal UI                      |

All three modes include specific file locations, problem descriptions, and suggested fix approaches.

### Configure CodeRabbit for Gemini

CodeRabbit automatically reads your `gemini.md` file. Add context on how code reviews should run, your coding standards, and architectural preferences. Note this feature is only available on the Pro paid plan.

## Troubleshooting

### CodeRabbit not finding issues

If CodeRabbit isn't detecting expected issues:

1. **Check authentication status**: Run `coderabbit auth status` (authentication improves review quality but isn't required)
2. **Verify git status**: CodeRabbit analyzes tracked changes - check `git status`
3. **Consider review type**: Use the `--type` flag to specify what to review:
   * `coderabbit --type uncommitted` - only uncommitted changes
   * `coderabbit --type committed` - only committed changes
   * `coderabbit --type all` - both committed and uncommitted (default)
4. **Specify base branch**: If your main branch isn't `main`, use `--base`:
   * `coderabbit --base develop`
   * `coderabbit --base master`
5. **Review file types**: CodeRabbit focuses on code files, not docs or configuration

### Managing review duration

CodeRabbit reviews may take 7 to 30+ minutes depending on the scope of changes:

1. **Ensure background execution**: Configure Gemini to run CodeRabbit in the background so you can continue working
2. **Review smaller changesets**: Adjust what you're reviewing to reduce analysis time:
   * Use `--type uncommitted` to review only uncommitted changes
   * Work on smaller feature branches compared to main
   * Break large features into smaller, reviewable chunks
3. **Configure the diff scope**: Control what changes are analyzed:
   * **Review uncommitted changes only**: Use `--type uncommitted` to analyze just working directory changes
   * **Configure base branch**: Use `--base develop` or `--base main` to set the comparison point
   * **Use feature branches**: Work on focused feature branches instead of large staging branches