ContractGuard

Upload any contract → get red flags, unfair terms, and plain-English explanations in seconds.

English · 中文  ·  Demo · Quick Start · How It Works

Why ContractGuard?

Every year, millions of people sign contracts they don’t fully understand — apartment leases with hidden penalties, employment agreements with overly broad non-competes, NDAs that silently strip away your rights. Hiring a lawyer costs $300-500/hour. Most people just sign and hope for the best.

ContractGuard changes that. It’s an open-source AI agent that reads every clause of your contract, flags problems in plain language, and tells you exactly what to negotiate — all in under 30 seconds.

What makes it different from ChatGPT?

• Structured analysis, not a wall of text — you get categorized red flags, warnings, protections, and a fairness score
• Actionable suggestions for every issue found — not just “this is bad” but “change it to this”
• Consistent output format via Pydantic models — easy to integrate into other tools
• CLI-first design — one command, beautiful terminal output, no browser needed
• Works with any LLM — OpenRouter, OpenAI, Ollama (fully local/private)

Demo

contractguard scan my-lease.pdf

✔ Parsed my-lease.pdf (4,521 characters)

⬤ RED FLAGS (5 found)
==================================================

  1. Non-refundable security deposit
     Clause: Section 3
     "The security deposit is non-refundable and shall
      be retained by Landlord upon termination"
     Most states require deposits to be refundable.
     This clause is likely illegal in California.
     Suggestion: Remove "non-refundable" language.

  2. Unlimited landlord access without notice
     Clause: Section 5
     "Landlord shall have the right to enter the Property
      at any time, with or without notice"
     California law requires 24-hour written notice.
     Suggestion: Add "with 24 hours written notice"

  … 3 more red flags, 3 warnings, 2 protections, 4 missing protections …

FAIRNESS SCORE: D (28/100)
  5 red flags  3 warnings  2 protections  4 missing

Quick Start

1. Install

pip install contractguardian

2. Set up your API key

ContractGuard works with any OpenAI-compatible API. Pick one:

Option A: OpenRouter (recommended) — access to Claude, GPT-4, DeepSeek, Gemini, and 100+ models through a single API key:

export OPENROUTER_API_KEY=sk-or-...

Option B: OpenAI directly:

export OPENAI_API_KEY=sk-...
export OPENAI_BASE_URL=https://api.openai.com/v1

Option C: Local models via Ollama — your contract data never leaves your machine:

export OPENAI_BASE_URL=http://localhost:11434/v1
export OPENAI_API_KEY=ollama

3. Scan a contract

contractguard scan my-contract.pdf

That’s it. Three steps, under 60 seconds.

Usage

# Scan a PDF, DOCX, or TXT
contractguard scan lease.pdf

# Pick any OpenRouter / OpenAI / Ollama model
contractguard scan contract.pdf --model openai/gpt-4o

# Export a markdown report, a clean PDF, or structured JSON for scripting
contractguard scan contract.pdf --output report.md
contractguard scan contract.pdf --output report.pdf
contractguard scan contract.pdf --json --output report.json

# Scan a whole folder, or diff two versions of a contract
contractguard batch ./contracts/ --output-dir reports/
contractguard compare lease-v1.pdf lease-v2.pdf

# Force a jurisdiction for the statute checks (default is auto-detect)
contractguard scan lease.pdf --jurisdiction us-ca

# Web UI: LLM analysis plus the deterministic statute-check panel
contractguard web

Python API

from contractguard.analyzer import analyze_contract
from contractguard.parser import extract_text

result = analyze_contract(extract_text("my-lease.pdf"))
print(f"{result.fairness_grade} ({result.fairness_score}/100)")
for flag in result.red_flags:
    print(f"- {flag.title} ({flag.clause}): {flag.suggestion}")

--json emits the full structured result — contract type, parties, key terms, red flags, warnings, protections, and fairness score — as a Pydantic-backed object ready to pipe into other tools.

Supported File Formats

Supported Contract Types

ContractGuard automatically detects the contract type and tailors its analysis accordingly. Each type has specific red flags and industry-standard protections it checks for:

How It Works

1. Parse — Extracts text from your document (PDF, DOCX, TXT). For PDFs, uses pdfplumber to handle complex layouts. For DOCX, uses python-docx to read all paragraphs.

2. Detect — Sends the extracted text to the LLM, which automatically identifies the contract type (lease, NDA, employment, etc.) and adjusts its analysis strategy.

3. Analyze — The AI agent reviews every clause and categorizes findings into four groups:

   • Red Flags — Serious issues that could cause financial harm, legal liability, or loss of rights. These are things you should push back on before signing.
   • Warnings — Moderate concerns that are worth discussing but aren’t necessarily deal-breakers. Common in many contracts but still worth knowing about.
   • Protections — Good clauses that protect your interests. These are things the contract got right.
   • Missing Protections — Standard clauses that are absent from the contract. Their absence may leave you exposed.

4. Score — Generates an overall fairness grade from A+ (excellent, fair to both parties) to F (heavily one-sided, many red flags). The score is based on the number and severity of issues found, balanced against protections present.

5. Verify — A deterministic statute checklist runs alongside the LLM, checking the rules where a wrong answer is a violation, not an opinion. The checklist is jurisdiction-aware (--jurisdiction auto by default, or force cn / us-ca). Chinese-language contracts get probation length and pay caps, penalty scope, non-compete duration and compensation, the 150/200/300% overtime pay floors (PRC labor law), earnest-money ratio and lease-term caps (PRC Civil Code), and the private-lending rules: the enforceable rate cap at 4x the 1-year LPR at signing (SPC interpretation art. 25) and the ban on pre-deducted interest (Civil Code art. 670). Leases anchored in California get the residential-lease rules of the California Civil Code: the one-month security-deposit cap and the refundability requirement (§1950.5, as amended by AB 12), the 24-hour landlord-entry notice floor (§1954), and the 21-day deposit-return deadline with an itemized statement (§1950.5(g)). Each check returns violation / ok / unknown, and “unknown” is reported honestly when the clause is missing or the jurisdiction cannot be determined, instead of passing as compliance. Disable with --no-checklist.

6. Report — Outputs results as a beautiful Rich-formatted terminal report, or exports to Markdown/JSON/HTML for sharing or further processing.

Configuration

LLM Providers

ContractGuard uses the OpenAI-compatible API format, so it works with virtually any LLM provider:

Default model is anthropic/claude-sonnet-4. google/gemini-2.5-pro handles very long contracts (1M context), deepseek/deepseek-chat is the budget pick, and any Ollama model keeps your data local.

FAQ

Is this legal advice? No. ContractGuard is an educational tool for understanding contract terms in plain language, not a substitute for a licensed attorney.

Is my contract data sent to the cloud? Only to the LLM provider you configure. For full privacy, use a local model via Ollama — the text never leaves your machine. ContractGuard itself stores and logs nothing.

What’s the maximum contract length? About 30,000 tokens (~60 pages); longer documents are truncated. Use a large-context model like google/gemini-2.5-pro for very long contracts.

Can I use it in CI/CD? Yes. --json gives parseable output; exit code is 0 on success, 1 on error. E.g. contractguard scan contract.pdf --json | jq '.red_flags | length'.

Roadmap

Shipped: batch scanning (analyze many contracts in one run), contract comparison (diff two versions and surface what changed, clause by clause), clause-level negotiation drafts (each red flag can carry suggested replacement wording, ready to paste into a negotiation email), jurisdiction-aware statute checks (PRC labor and civil law, plus California residential leases; one US state so far), and a Gradio web UI (contractguard web) that shows the LLM analysis alongside the deterministic statute-check panel. Reports export to a clean PDF — statute citations with official links and risk levels included — via --output report.pdf or the web download button; weasyprint renders when its system libraries exist, and the bundled pure-python fallback covers hosts where they do not. Scanned/image-only PDFs go through OCR (pip install "contractguardian[ocr]" plus the Tesseract engine — brew install tesseract tesseract-lang on macOS, apt install tesseract-ocr tesseract-ocr-chi-sim on Debian/Ubuntu; Chinese and English are both read when the language pack is present). Pre-built templates live in templates/ — loan and NDA starters with inline usage notes and watch lists of the same red flags the scanner checks. A release corpus (corpus/, gated by tests/test_corpus.py) pins checklist verdicts on full-length sample contracts, so rule and parser changes cannot quietly alter real outcomes.

Planned:

• SaaS terms template — templates/ now covers loan, NDA, and freelance/contracting starters, each with a machine-checked watch list; a SaaS terms-of-service starter is the next family to grow alongside its deterministic rules.

Related Projects

ContractGuard is one of my applied agent projects. A few others worth a look:

• CoreCoder — want to understand how a coding agent really works? Read the whole ~1k-line engine end to end, not a black box.
• RepoWiki — dropped into an unfamiliar codebase? It gives you a guided wiki and a where-to-start reading path, a self-hostable DeepWiki alternative.
• FindJobs-Agent — stop sifting job boards by hand: it ranks postings against your resume and runs mock interviews.
• GitSense — want to contribute to open source? It finds issues worth your time and gauges whether your PR will get merged.
• CodeABC — understand any codebase even if you don’t code, built for non-programmers.

Contributing

Contributions are welcome! Here’s how you can help:

• Report bugs — Open an issue with the contract type and expected behavior
• Add contract samples — More sample contracts for testing (with intentional red flags)
• Improve prompts — Better LLM prompts for more accurate analysis
• Add languages — Test with contracts in different languages and report results
• Build integrations — MCP server, VS Code extension, Slack bot, etc.

License

MIT — use it however you want.