Learn how to use DeepReview

Quick Start

Get up and running with DeepReview in under 5 minutes. This guide will walk you through the essential steps to integrate AI-powered code reviews into your GitHub workflow.

Prerequisites

• A GitHub account with admin access to at least one repository
• A DeepReview account (free tier available)

Step 1: Install the GitHub App

Click the button below to install the DeepReview GitHub App:

Select the repositories you want DeepReview to monitor. You can choose all repositories or specific ones.

Step 2: Configure Your Project

Create a .deepreview.yml file in your repository root:

# DeepReview Configuration
version: "1.0"

review:
  enabled: true
  auto_review: true
  languages:
    - typescript
    - python
    - go

rules:
  security: strict
  performance: moderate
  style: relaxed

ignore:
  - "**/*.test.ts"
  - "docs/**"

Step 3: Create Your First PR

Once configured, simply create a pull request as usual. DeepReview will automatically:

1. Analyze the code changes using the ReAct reasoning engine
2. Explore related files and dependencies for full context
3. Post review comments with actionable suggestions
4. Generate a summary report with severity levels

Installation

DeepReview offers multiple installation options to fit your team's needs.

Cloud (Recommended)

The fastest way to get started. No infrastructure management required.

1. Sign up at app.deepreview.ai
2. Connect your GitHub/GitLab account
3. Select repositories to monitor
4. Start receiving AI reviews on your PRs

Self-Hosted (Enterprise)

For teams with strict compliance requirements, DeepReview can be deployed in your own infrastructure.

# Pull the DeepReview image
docker pull deepreview/server:latest

# Run with your configuration
docker run -d \
  --name deepreview \
  -p 8080:8080 \
  -e DATABASE_URL=postgres://... \
  -e LLM_API_KEY=your-api-key \
  -e GITHUB_APP_ID=your-app-id \
  -e GITHUB_PRIVATE_KEY=your-private-key \
  deepreview/server:latest

Kubernetes Deployment

apiVersion: apps/v1
kind: Deployment
metadata:
  name: deepreview
spec:
  replicas: 3
  selector:
    matchLabels:
      app: deepreview
  template:
    spec:
      containers:
      - name: deepreview
        image: deepreview/server:latest
        ports:
        - containerPort: 8080

Configuration

DeepReview can be configured at multiple levels: repository, organization, and global.

Configuration File Reference

Environment Variables

ReAct Engine

The ReAct (Reasoning and Action) engine is the core of DeepReview's intelligent code review capability. Unlike traditional static analyzers that apply fixed rules, ReAct enables the AI to think, explore, and iterate until it fully understands the code changes.

How It Works

The ReAct engine operates in iterative cycles, similar to how a human reviewer would approach code:

Example ReAct Flow

# Thought 1
The PR modifies the authentication function. I need to understand 
how the password hashing is implemented.

# Action 1
read_file("src/auth/password.ts")

# Observation 1
File contains bcrypt implementation with salt rounds = 10

# Thought 2
I see a potential security issue - the salt rounds are hardcoded.
Let me check if there's a config file for security settings.

# Action 2
search_code("salt.*rounds", "src/", "*.ts")

# Observation 2
Found: config/security.ts defines SALT_ROUNDS constant

# Thought 3
The PR should reference the config constant instead of hardcoding.
I have enough context to generate the review.

Available Tools

The AI agent has access to the following tools during review:

Review Workflow

Understanding the complete flow from PR creation to review completion.

Synchronous vs Asynchronous Mode

Review Output Structure

Each review generates multiple outputs:

• Detailed Report: Full analysis with all findings
• Summary: Executive summary for quick overview
• Suggestions List: Actionable items with severity levels
• Inline Comments: Posted directly on PR lines

Severity Levels

Retry & Fault Tolerance

DeepReview implements multiple layers of fault tolerance to ensure reliable reviews.

Retry Strategy

Model Switching

When the context exceeds the primary model's limit, DeepReview automatically switches to a larger capacity model:

Primary:  gpt-4 (8K context)
    ↓ (if context > 8K)
Fallback: gpt-4-32k (32K context)
    ↓ (if context > 32K)  
Extended: claude-3-opus (200K context)

GitHub Integration

DeepReview provides native integration with GitHub through a GitHub App.

Permissions Required

• Read: Repository contents, metadata, pull requests
• Write: Pull request comments, checks

Webhook Events

DeepReview listens to the following GitHub events:

REST API

Integrate DeepReview into your custom workflows using our REST API.

Authentication

Authorization: Bearer YOUR_API_KEY

Create Review

POST /api/v1/reviews
Content-Type: application/json

{
  "repository": "owner/repo",
  "pull_request": 123,
  "base_ref": "main",
  "head_ref": "feature-branch",
  "async": true,
  "callback_url": "https://your-server/webhook"
}

Response

{
  "review_id": "rev_abc123",
  "status": "processing",
  "created_at": "2024-01-15T10:30:00Z"
}

Get Review Result

{
  "review_id": "rev_abc123",
  "status": "completed",
  "summary": "Found 3 issues: 1 critical, 2 warnings",
  "suggestions": [
    {
      "severity": "critical",
      "file": "src/auth.ts",
      "line": 42,
      "message": "SQL injection vulnerability",
      "suggestion": "Use parameterized queries"
    }
  ],
  "stats": {
    "files_analyzed": 15,
    "tool_calls": 23,
    "tokens_used": 45000
  }
}