legal-contract-mcp

An MCP (Model Context Protocol) server that gives an LLM client (Claude, Claude Code, Claude Desktop, etc.) tools to do a first-pass review of contracts: load a .txt/.docx/.pdf, detect standard clause types, flag heuristic risk issues, generate a summary, and diff two contracts against each other.

This is not legal advice — it's a rules-based first pass meant to speed up human review, built to demonstrate a real, non-trivial MCP server (as opposed to a toy "add two numbers" example).

Why this exists

Most MCP server examples are thin wrappers around an API call. This one does actual work locally:

• Parses real document formats (txt/docx/pdf)
• Detects 12 standard clause types via a maintained pattern library, not a single regex
• Runs 8 explainable risk heuristics (e.g. indemnification without a liability cap, auto-renewal without a clear notice period, non-competes with no defined scope) — every flag cites the exact clause text it's based on
• Falls back gracefully to an extractive summary if no OPENAI_API_KEY is set, and upgrades to an LLM-generated summary if one is

Tools exposed

Tool	Description
load_contract(path)	Load a .txt/.docx/.pdf file, returns a doc_id
list_documents()	List contracts loaded in this session
extract_clauses(doc_id)	Detected clause types with snippets
missing_clauses(doc_id)	Standard clause types NOT found — gap check
flag_risks(doc_id)	Heuristic risk flags with severity + evidence
summarize_contract(doc_id)	Plain-English summary (LLM or extractive fallback)
compare_contracts(doc_id_a, doc_id_b)	Diff clause types and risk flags between two contracts
search_clause_library(query)	Look up a clause type's definition by keyword

Setup

python -m venv .venv
source .venv/bin/activate   # Windows: .venv\Scripts\activate
pip install -e ".[dev]"

Optional — enable LLM-powered summaries:

export OPENAI_API_KEY=sk-ant-...

Run it

Inspector (interactive dev UI):

mcp dev src/legal_contract_mcp/server.py

As a stdio server (for Claude Desktop / Claude Code config):

{
  "mcpServers": {
    "legal-contract-mcp": {
      "command": "python",
      "args": ["-m", "legal_contract_mcp.server"],
      "cwd": "/absolute/path/to/legal-contract-mcp",
      "env": { "OPENAI_API_KEY": "sk-ant-..." }
    }
  }
}

Then in a chat with the connected client:

Load the contract at tests/sample_contracts/weak_nda.txt and flag its risks.

Test

pytest                    # unit tests for clause detection + risk rules
python scripts/smoke_test.py   # spins up the real MCP server over stdio and calls every tool

Includes two sample contracts (tests/sample_contracts/weak_nda.txt and solid_msa.txt) chosen so the risk engine's output differs meaningfully between a weak and a well-drafted agreement — tests assert on that difference, not just "does it run."

Project structure

src/legal_contract_mcp/
  parsing.py         # txt/docx/pdf -> plain text, in-memory doc store
  clause_library.py  # 12 clause types: definitions + detection patterns
  clauses.py         # runs the library against a document
  risk_rules.py       # 8 heuristic risk rules, each with cited evidence
  llm.py              # optional Claude-powered summary, extractive fallback
  server.py           # FastMCP tool definitions
tests/
  sample_contracts/   # weak NDA vs. solid MSA fixtures
  test_clauses_and_risks.py

Extending it

• Add a clause type: add an entry to CLAUSE_LIBRARY in clause_library.py with a definition and one or more regex patterns.
• Add a risk rule: add a function block to evaluate_risks() in risk_rules.py — return a RiskFlag with rule, severity, message, and evidence.
• Swap the in-memory store in parsing.py for a database if you want documents to persist across server restarts.

Disclaimer

This tool provides automated, heuristic pattern-matching only. It is not a substitute for review by a licensed attorney and should not be relied on as legal advice.