Build a Local AI Code Review Bot in Python: Run Reviews on Your Laptop Without Cloud Costs

I love AI code review tools. But I hate paying per-request for every `git push`.

Last month, my team ran up a $340 bill on a single repo just from API-based code review agents. That’s ridiculous. You’re essentially paying to get feedback you could get for free — if you know how to build it.

How We Cut $2.3M in Annual Costs with Enterprise AI Adoption: A Real Case Study

Let me tell you about a project that almost didn’t happen. Back in early 2024, I was sitting… ...

Read more

So I built a local AI code review bot. It runs on my laptop, uses open-source models, and costs exactly $0 in API fees. You can build yours in about an hour.

Here’s the exact playbook.

How We Tamed AI Code Generation: A Practical Workflow for Production-Ready AI-Assisted Development

How We Tamed AI Code Generation: A Practical Workflow for Production-Ready AI-Assisted Development AI coding tools are everywhere.… ...

Read more

Why Bother with a Local AI Code Review?

Three reasons:

1. Data privacy – Your code never leaves your machine. For regulated industries (fintech, healthcare), this is non-negotiable.
2. Zero latency – No round trips to an API server. The review starts instantly after `git diff`.
3. No token counting stress – Review a 2,000-line PR diff. You won’t get throttled or billed.

It’s not perfect — local models aren’t GPT-4 level yet. But they’re good enough for catching common bugs, style violations, and security gotchas.

What You’ll Build

A Python script that:

• Watches for commits or runs on demand
• Parses the `git diff` output
• Sends it to a local LLM (via Ollama)
• Returns a structured code review

You’ll run it as a pre-commit hook or a standalone CLI tool.

Prerequisites

• Python 3.10+
• Ollama installed
• A model pulled locally (I recommend `codellama:7b` or `qwen2.5-coder:7b` for code reviews)

Install Ollama and pull a model:

bash
curl -fsSL https://ollama.com/install.sh | sh
ollama pull qwen2.5-coder:7b

Step 1: Get the Git Diff

Your review bot needs to see what changed. Local repos have `git diff` — it’s the perfect input format.

python
import subprocess
import sys

def get_git_diff(staged=True):
    """Get the git diff. Defaults to staged (index) diff."""
    cmd = ['git', 'diff', '--cached'] if staged else ['git', 'diff']
    try:
        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
        return result.stdout
    except subprocess.CalledProcessError:
        print("Error: Not a git repo or no changes found.")
        sys.exit(1)

Simple. Unchanged lines don’t eat up your context window.

Step 2: Build the Review Prompt

This is where you control the quality. Don’t just dump the diff into the model. Structure it.

python
REVIEW_PROMPT_TEMPLATE = """You are an expert senior code reviewer. Review the following git diff for bugs, security issues, performance problems, and style violations.

Return your findings in this exact format:
- **Severity** (critical, major, minor)
- **File:line** 
- **Issue description**
- **Suggested fix**

Only comment on actual problems. Do not praise good code. Be direct and specific.

Diff:

{diff}

Review:"""

Honestly, prompt engineering matters more than the model size. A well-structured prompt on a 7B model beats a vague prompt on a 70B model every time.

Step 3: Call Ollama from Python

Ollama exposes a simple HTTP API. No SDK needed.

python
import requests
import json

def review_code(diff_text, model="qwen2.5-coder:7b"):
    """Send the diff to local Ollama and return the review."""
    prompt = REVIEW_PROMPT_TEMPLATE.format(diff=diff_text)
    
    response = requests.post(
        "http://localhost:11434/api/generate",
        json={
            "model": model,
            "prompt": prompt,
            "stream": False,
            "options": {
                "temperature": 0.2,  # Low temp for deterministic reviews
                "num_predict": 1024  # Limit output length
            }
        }
    )
    
    if response.status_code != 200:
        print(f"Ollama error: {response.status_code}")
        return "Error calling local model."
    
    return response.json()["response"]

Notice `temperature: 0.2`. You don’t want the model getting creative with code reviews. Keep it tight.

Step 4: Put It All Together

python
def main():
    import argparse
    
    parser = argparse.ArgumentParser(description="Local AI Code Review Bot")
    parser.add_argument("--staged", action="store_true", default=True, 
                        help="Review staged changes (default: True)")
    parser.add_argument("--model", default="qwen2.5-coder:7b",
                        help="Ollama model to use")
    args = parser.parse_args()
    
    diff = get_git_diff(staged=args.staged)
    
    if not diff.strip():
        print("No changes to review.")
        return
    
    print("Running local code review...")
    review = review_code(diff, model=args.model)
    print("\n" + "="*50)
    print("CODE REVIEW RESULTS")
    print("="*50)
    print(review)

if __name__ == "__main__":
    main()

Save this as `local_review.py` and run it:

bash
python local_review.py

Step 5: Wire It as a Pre-Commit Hook

This is where it gets practical. You want reviews to run automatically before every commit.

Create `.git/hooks/pre-commit`:

bash
#!/bin/bash
python /path/to/local_review.py --staged

Make it executable:

bash
chmod +x .git/hooks/pre-commit

Now every commit triggers a local review. If the model finds a critical issue, the reviewer (you) can abort the commit. I added a threshold check too — any “critical” severity finding blocks the commit.

Making It Actually Useful

A few hard-learned tips:

Filter unchanged code. Only send lines with `+` or `-` prefix. Reduces token usage by 60-70%.

Batch comments. The model tends to write a novel for a 50-line diff. Limit output with `num_predict`.

Use a dedicated review model. General-purpose models like Llama 3.1 often miss subtle bugs. `qwen2.5-coder` or `deepseek-coder` perform much better.

Add a cost display. Even though it’s local, show the number of tokens processed. Keeps you aware of context limits.

Real-World Example

We run this on a 50,000-line Python backend at ECOAAI’s Can Tho hub. The local bot catches about 70% of the issues our senior devs catch manually. Not perfect, but it frees up our Vietnamese engineers to focus on architecture instead of style nitpicks.

Recently, it flagged a SQL injection vector in a PR from a junior developer. The model spotted an f-string concatenation in a query parameter — classic rookie mistake. The fix took 3 minutes. Without the bot, that would have gone to staging.

Advanced: Multi-Model Orchestration

You can extend this to run different models for different review types:

• Small model (3B) for formatting and style checks
• Medium model (7B) for common bugs and logic errors
• Large model (14B or 30B) for security and architecture reviews

Run them as a pipeline. The small model finishes in 2 seconds, the large one takes 20. This is where ECOA AI Platform ACP’s orchestration shines — we used it to chain these models efficiently.

But even the basic single-model version will save you hours per week.

Final Thoughts

Local AI code review isn’t a replacement for human review. It’s a filter. It catches the dumb stuff — typos in variable names, missing error handling, SQL injection risks — so your team’s attention goes where it matters.

And you know what the best part is? No subscription. No surprise bills. No data leaking to a third-party API.

Build it. Tune it. Make it yours.

—

Frequently Asked Questions

How does this compare to GitHub Copilot’s code review feature?

Copilot’s review runs on Microsoft’s servers and costs $10-39/user/month for the Teams tier. Our local bot costs $0 in API fees but requires your own hardware (a laptop with 8GB+ VRAM works fine). Accuracy is lower on local models — expect ~70% catch rate vs Copilot’s ~85% on common issues. For sensitive codebases, local is the safer bet.

Can I use this with a remote Git repo or CI/CD pipeline?

Yes, but you’ll need to run Ollama on your CI runner. If you use GitHub Actions, you can spin up a self-hosted runner with Ollama installed. For large monorepos, you’ll need more RAM. Our team runs it on a dedicated server with 32GB RAM in Ho Chi Minh City.

What’s the best model for code review on a laptop?

`qwen2.5-coder:7b` gives the best balance of accuracy and speed on consumer GPUs (6-8GB VRAM). If you have more power (24GB+), `deepseek-coder:33b` catches significantly more bugs. For CPU-only machines, `codellama:7b` works but takes 30-60 seconds per review.

Does it work with languages other than Python?

Yes. The model and prompt are language-agnostic as long as the model supports the language in its training data. We’ve tested it on TypeScript, Go, Rust, and Java. Performance drops slightly for less common languages like Elixir or Haskell, but it still catches basic issues.

Related reading: Outsourcing Software in 2025: Why Smart CTOs Are Ditching the Old Playbook

Related reading: Why You Should Hire Vietnamese Developers: The Undisputed Truth for 2025