> ## 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.

# Integrate MCP servers

> Connect CodeRabbit to external tools and data sources through the Model Context Protocol (MCP) for enhanced code reviews with richer contextual understanding.

export const ProPlusPlanBadge = ({tip = "This feature is available as part of the Pro+ plan and Enterprise plan. Please refer to our pricing page for more information about our plans and features.", title = "Pro+ Plan", cta = "Read more", href = "https://coderabbit.ai/pricing", disabled = false}) => {
  return <Tooltip tip={tip} cta={cta} href={href}>
        <Badge icon="shield-plus" disabled={disabled || undefined}>
            {title}
        </Badge>
    </Tooltip>;
};

export const ProPlanBadge = ({tip = "This feature is available as part of the Pro, Pro+ and Enterprise plans. Please refer to our pricing page for more information about our plans and features.", title = "Pro Plan", cta = "Read more", href = "https://coderabbit.ai/pricing", disabled = false}) => {
  return <Tooltip tip={tip} cta={cta} href={href}>
        <Badge icon="shield-check" disabled={disabled || undefined}>
            {title}
        </Badge>
    </Tooltip>;
};

export const AllPlatformsBadge = ({tip = "This feature is available on all supported platforms: GitHub, GitLab, Azure DevOps, and Bitbucket.", title = "All Platforms", cta, href, disabled = false}) => {
  return <Tooltip tip={tip} cta={cta} href={href}>
        <Badge icon="globe" disabled={disabled || undefined}>
            {title}
        </Badge>
    </Tooltip>;
};

<AllPlatformsBadge /> | <ProPlanBadge /> <ProPlusPlanBadge />

Connect CodeRabbit to external tools and data sources through the Model Context Protocol (MCP) integration. This allows CodeRabbit to serve as the MCP client and provides richer contextual understanding for enhanced code reviews.

<Info>
  The number of MCP server connections depends on your plan: **Pro** supports up to 5 MCP servers, **Pro+** supports up to 15, and **Enterprise** supports up to 20.
</Info>

## What MCP integration enables

<CardGroup cols={3}>
  <Card title="Code reviews">
    Enhanced analysis with external context and documentation
  </Card>

  <Card title="Code suggestions">
    Improved validation using your organization's knowledge
  </Card>

  <Card title="PR chat">
    Access to relevant documentation and project information
  </Card>
</CardGroup>

## Supported integrations

Access your documentation, project management tools, knowledge bases, Figma designs, and more through MCP servers.

## Considerations

<CardGroup cols={1}>
  <Card>
    <Info>
      **CodeRabbit as MCP client**: CodeRabbit acts as the MCP client, not the
      server. It ingests data from your connected MCP servers.
    </Info>

    <Warning>
      **Data relevance**: Consider what MCP data will be helpful for code
      reviews. CodeRabbit uses this data for analysis, validation, and chat
      interactions.
    </Warning>

    <Tip>
      **Faster integrations**: This approach unlocks integrations without
      waiting for formal CodeRabbit support. If a tool has an MCP server,
      CodeRabbit can connect to it.
    </Tip>
  </Card>
</CardGroup>

## Setup

<Steps>
  <Step title="Navigate to integrations">
    Go to the Integrations page within your CodeRabbit app settings: [app.coderabbit.ai/integrations](https://app.coderabbit.ai/integrations?tab=mcp)
  </Step>

  <Step title="Add MCP integration">
    Click **New MCP Server** and provide your server connection details
    along with a descriptive name.

    It's also recommended to fill the `User guidance` field. See [User guidance](#user-guidance) for details.
  </Step>

  <Step title="Complete authentication">
    Complete the authentication process for your MCP server following the
    prompts.
  </Step>

  <Step title="Configure tools">
    Enable or disable individual MCP tools for each server based on your needs.
  </Step>
</Steps>

## How it works

<Tabs>
  <Tab title="During code reviews">
    CodeRabbit automatically calls relevant MCP tools during analysis to:

    <CardGroup cols={2}>
      <Card title="Gather context">
        Collects additional review context from your connected data sources
      </Card>

      <Card title="Enhance comments">
        Validates and enriches suggested review comments with relevant information
      </Card>
    </CardGroup>

    <Info>
      Enhanced review comments will include enriched insights while maintaining your existing workflow. Tools used during analysis are listed under **"Additional context used."**
    </Info>
  </Tab>

  <Tab title="In chat interactions">
    MCP integration enhances chat by providing access to:

    <CardGroup cols={2}>
      <Card title="Contextual information">
        Retrieves relevant information based on discussion topics
      </Card>

      <Card title="External documentation">
        Accesses your organization's knowledge bases and documentation
      </Card>
    </CardGroup>
  </Tab>
</Tabs>

## User guidance

The **User guidance** field is free-text instructions that CodeRabbit's AI agent reads before using your MCP server. Use it to tell the agent what information is available, what to look for, and why it matters for code reviews.

Some MCP servers need no additional guidance—the agent can figure out how to use their tools on its own. But many servers benefit from explicit context, especially when:

* The server stores a wide variety of content (for example, a Notion workspace covering engineering specs, meeting notes, HR policies, and runbooks)
* The server uses internal naming conventions or project keys that the agent can't guess
* The server is a custom in-house tool whose purpose isn't obvious from its tool names alone
* Resources are organized in non-standard hierarchies that the agent can't automatically navigate

### What to include in user guidance

Good user guidance answers three questions for the agent:

1. **What is stored here?** Describe the kind of information available on this MCP server.
2. **What should CodeRabbit look for?** Narrow the scope to what's relevant for code reviews.
3. **How is it organized?** Provide naming conventions, key formats, or URL patterns the agent needs to find the right resources.

### Example configurations

<Tabs>
  <Tab title="Notion">
    Notion workspaces can contain many different types of content. Tell the agent which pages or databases are relevant to code reviews:

    ```text wrap theme={null}
    This Notion workspace contains our engineering documentation.
    For code reviews, look in the "Engineering" space—specifically:
    - "Architecture Decisions" for design rationale
    - "API Contracts" for interface specifications
    - "Service Runbooks" for operational context

    Do not pull content from HR, Finance, or Company-wide spaces.
    ```
  </Tab>

  <Tab title="Custom in-house MCP server">
    For internal tools, explain what the server exposes and why it's useful for reviews:

    ```text wrap theme={null}
    This is our internal quality gate service. It provides:
    - Static analysis results for each pull request
    - Security scan findings from our custom ruleset
    - Architecture compliance checks against our approved patterns

    Always fetch the quality gate report for the current PR before commenting
    on code quality or security issues. Results are indexed by repository name
    and PR number.
    ```
  </Tab>

  <Tab title="Jenkins">
    If your Jenkins jobs are organized in folders that CodeRabbit can't automatically discover:

    ```text wrap theme={null}
    Jenkins builds are located at:
    https://jenkins.company.com/job/{workspace}/job/{repo}/job/PR-{pr}/

    Use getBuild or getBuildLog to fetch build results directly from this path.
    ```

    <Tip>
      This is particularly useful for Jenkins Organization Folders, where jobs are nested under workspace/repo/PR structures that aren't searchable via the standard Jenkins API.
    </Tip>
  </Tab>

  <Tab title="SonarQube">
    If your SonarQube project keys follow a naming convention:

    ```text wrap theme={null}
    SonarQube project key format: {org}_{repo}
    Dashboard: https://sonar.company.com/dashboard?id={org}_{repo}
    ```
  </Tab>

  <Tab title="Azure DevOps">
    For Azure DevOps pipelines using project-specific paths:

    ```text wrap theme={null}
    Pipeline runs: https://dev.azure.com/{org}/{project}/_build?definitionId=1&branchName=refs/pull/{pr}/merge
    ```
  </Tab>
</Tabs>

### URL template placeholders

When guidance includes URLs that change per pull request, use **placeholders** that CodeRabbit automatically expands with values from the current PR:

```text theme={null}
https://jenkins.company.com/job/{workspace}/job/{repo}/job/PR-{pr}/
```

#### Available placeholders

| Placeholder                             | Description                   | Example value |
| --------------------------------------- | ----------------------------- | ------------- |
| `{repo}`, `{repo name}`, `{repository}` | Repository name               | `my-backend`  |
| `{pr}`, `{pr number}`                   | Pull request number           | `42`          |
| `{mr}`, `{mr number}`                   | Merge request number (GitLab) | `42`          |
| `{workspace}`, `{owner}`, `{org}`       | Organization or workspace     | `acme-corp`   |
| `{project}`                             | Project name (Azure DevOps)   | `MyProject`   |

<Info>
  Placeholders are case-insensitive. `{repo}`, `{REPO}`, and `{Repo}` all work the same way.
</Info>