The Agentic AI Code Reviewer is a Python-based autonomous agent that monitors a GitHub Pull Request, extracts the code diff, feeds it to a locally-running Large Language Model (Ollama), and posts an AI-generated code review directly as a comment on the PR — all without any manual intervention.

How It Works — System Architecture

What the AI Reviews

The agent instructs the LLM to focus on four pillars:

1 · Python 3.10+

The project uses async/await (asyncio) and modern type hints, requiring Python 3.10 or newer.

# Check your version
python --version
# Should show Python 3.10.x or higher

# Install on Ubuntu/Debian
sudo apt update && sudo apt install python3.11 python3-pip -y

# Install on macOS via Homebrew
brew install python@3.11

2 · Ollama — Local LLM Runtime

Ollama runs large language models locally on your machine. The project defaults to llama3.2:3b, a fast and capable 3-billion-parameter model.

# macOS / Linux (one-liner installer)
curl -fsSL https://ollama.com/install.sh | sh

# Windows
winget install Ollama.Ollama

ollama pull llama3.2:3b

ollama serve
# Server now runs at http://localhost:11434

curl http://localhost:11434/api/generate 
  -d '{"model":"llama3.2:3b","prompt":"hello","stream":false}'

3 · Python Dependencies

The requirements.txt only lists two packages, but you’ll also need python-dotenv (used in test files):

# Create and activate a virtual environment (recommended)
python -m venv venv
source venv/bin/activate        # macOS/Linux
venvScriptsactivate           # Windows

# Install required packages
pip install httpx PyGithub python-dotenv

4 · Git (optional but recommended)

# Clone the repository
git clone https://github.com/gauravsinghshl/agentic-code-reviewer.git
cd agentic-code-reviewer

This project requires exactly one external credential: a GitHub Personal Access Token. There is no cloud LLM key because all AI inference runs locally via Ollama.

Setting Up Your .env File

The project reads GITHUB_TOKEN from environment variables. Create a .env file in the project root:

# Create .env file in project root
touch .env

# Add your token
echo 'GITHUB_TOKEN=ghp_your_actual_token_here' >> .env

Or create the file manually with this content:

# .env — DO NOT commit this file to git
GITHUB_TOKEN=ghp_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

How the Token Is Consumed

import os
from github import Github

class GitHubService:
    def __init__(self):
        token = os.getenv("GITHUB_TOKEN")  # reads from environment
        if not token:
            raise Exception("GITHUB_TOKEN not set")
        self.github = Github(token)

All Variables At a Glance

Project Structure

class CodeReviewAgent:
    def __init__(self):
        self.llm = LocalLLM()          # instantiates Ollama client

    async def review_diff(self, diff: str):
        prompt = f"""
        You are a senior developer reviewing a GitHub pull request.
        ...
        GitHub Diff: {diff}
        Return feedback in bullet points."""

        review = await self.llm.generate(prompt)
        return review

class LocalLLM:
    def __init__(self, model="llama3.2:3b"):
        self.url = "http://localhost:11434/api/generate"
        self.model = model

    async def generate(self, prompt: str):
        async with httpx.AsyncClient(timeout=120) as client:
            response = await client.post(
                self.url,
                json={
                    "model": self.model,
                    "prompt": prompt,
                    "stream": False,
                    "options": {"temperature": 0}
                }
            )
        return response.json()["response"]

def get_pull_request_diff(self, repo_name, pr_number):
    repo = self.github.get_repo(repo_name)
    pr = repo.get_pull(pr_number)
    diff = ""
    for file in pr.get_files():
        diff += f"File: {file.filename}n"
        diff += file.patch + "n"
    return diff

def comment_on_pr(self, repo_name, pr_number, comment):
    repo = self.github.get_repo(repo_name)
    pr = repo.get_pull(pr_number)
    pr.create_issue_comment(comment)

You are a senior software engineer reviewing code.

Analyze the following code and provide:

1. Bugs
2. Code quality issues
3. Security risks
4. Suggested improvements

Code:
{code}

Return structured feedback.

Test & Runner Scripts

git clone https://github.com/gauravsinghshl/agentic-code-reviewer.git
cd agentic-code-reviewer

python -m venv venv
source venv/bin/activate      # macOS / Linux
venvScriptsactivate         # Windows PowerShell

pip install httpx PyGithub python-dotenv

# Install Ollama (macOS/Linux)
curl -fsSL https://ollama.com/install.sh | sh
# Windows
winget install Ollama.Ollama

# Pull the default model (~2GB download)
ollama pull llama3.2:3b

# Start the Ollama server (keep this terminal open)
ollama serve
# Verify: http://localhost:11434/api/tags

# In the project root directory
cat > .env << 'EOF'
GITHUB_TOKEN=ghp_your_github_personal_access_token
EOF

# 6a: Check token is loaded
python test_token.py
# Expected: prints your token (not None)

# 6b: Verify GitHub authentication
python test_github.py
# If certificate issue: pip install pip-system-certs
# Expected: prints your GitHub username

# 6c: Test the LLM (no GitHub needed)
python test_agent.py
# Expected: AI review printed to console

# Open test_pr_review.py and change these two lines:
repo_name = "YOUR_GITHUB_USERNAME/YOUR_REPO_NAME"
pr_number = 1  # the PR number you want reviewed

python test_pr_review.py

Troubleshooting Common Errors

Scenario

A developer opens PR #1 on the repository gauravsinghshl/genai-rag-document-qa. The PR changes a Python utility function. We run the agent to get an automated review.

Step 1 — The Pull Request Code Change

The PR modifies a function — here is what the diff looks like:

File: utils/calculator.py

- def calculate(x,y):
-  return x+y
+ def add_numbers(x: int, y: int) -> int:
+     return x + y

Step 2 — Running the Agent

Step 3 — The GitHub PR Comment (What It Looks Like)

After the script completes, a comment is automatically posted by your GitHub account on the Pull Request:

Testing with the Offline Mock (No GitHub Required)

To test just the LLM part without touching GitHub, run test_agent.py:

python test_agent.py

# Output:

AI PR Review

• Bugs:
  - No input validation on x and y parameters.

• Code Quality:
  - Good: added type hints and descriptive function name.
  - Missing docstring for the function.

• Performance:
  - No issues for this simple operation.

• Security:
  - No security concerns.

Customization Tips