# Contract Review Prover MCP > Contract Review Prover forces a high-level analysis of legal documents instead of generating simple summaries. This MCP scores risk per clause (1-5), identifies missing protections like IP ownership or liability caps, and quantifies financial exposure in specific currencies. It maps negotiation leverage points, ensuring you see the true gaps in any agreement. ## Overview - **Category:** productivity - **Price:** Free - **Tags:** contract-review, legal-analysis, risk-scoring, clause-analysis, financial-exposure, negotiation, jurisdiction, due-diligence ## Description Basic AI models just summarize contracts; they don't analyze them for hidden risks. This MCP changes that. Instead of giving you a high-level overview, it forces rigorous analysis by checking critical clauses one by one. It assigns a risk score to every material clause and tells you exactly why. You can verify if standard protections—like data processing rules or IP ownership—are actually present in the text. The tool also checks for jurisdiction conflicts across borders, making sure the governing law matches your operational reality. Best of all, it turns vague warnings like 'significant risk' into quantifiable numbers, calculating worst-case financial exposure based on specific currencies. Because Vinkius hosts this MCP in their catalog, you connect once and get access to structured analysis support for every deal type. ## Tools ### validate_contract_review Performs a mandatory review of the contract, scoring every clause for risk and checking all required legal protections and financial gaps. ## Prompt Examples **Prompt:** ``` This SaaS contract looks standard. The vendor says everyone signs it as-is. ``` **Response:** ``` Verdict: RISK_UNSCORED + LEVERAGE_UNMAPPED. 'Standard' is not a risk assessment. Score each clause 1-5. 'Everyone signs it' is a negotiation tactic, not a fact. Which clauses are genuinely non-negotiable? What are your alternatives? Map your BATNA. ``` **Prompt:** ``` The liability clause caps damages at the fees paid in the last 12 months. ``` **Response:** ``` Verdict: EXPOSURE_UNQUANTIFIED. What ARE the fees in the last 12 months? If annual contract is $50K but a breach causes $2M in damages, the cap exposes you to $1.95M uncovered risk. Quantify: 'Annual fees: $50K. Worst-case exposure: $2M. Gap: $1.95M. Risk score: 5/5.' ``` **Prompt:** ``` The contract is governed by the laws of Delaware but our company is in Germany. ``` **Response:** ``` Verdict: JURISDICTION_UNVERIFIED. Delaware vs. Germany creates a jurisdiction conflict. Key questions: (1) Is the venue clause exclusive or non-exclusive? (2) Does GDPR override Delaware law for data processing? (3) What are enforcement costs of litigating in Delaware from Germany? (4) Are arbitration clauses available as alternative? ``` ## Capabilities ### Score clause risk Assigns a quantified risk score (1-5) to each major contract clause, requiring specific justification. ### Identify missing protections Checks for the presence of ten standard legal safeguards, such as liability caps and confidentiality clauses. ### Analyze jurisdiction conflict Compares governing laws and dispute venues to flag potential cross-border enforcement gaps. ### Quantify financial exposure Calculates the maximum potential financial damage, providing specific currency figures for risk assessment. ### Map negotiation leverage Determines which clauses are negotiable and outlines alternative strategies or switching costs for both parties. ## Use Cases ### Evaluating a new vendor agreement A company receives an NDA from a foreign partner. Instead of trusting the vague 'standard' language, they run it through `validate_contract_review`. The result immediately flags a jurisdiction conflict and shows that the data protection clauses are insufficient for their operational needs. ### Due diligence on an acquisition target Legal teams need to quickly assess all material contracts. They use the tool to run a bulk review, identifying common patterns of uncapped liability or missing force majeure protections across dozens of agreements simultaneously. ### Revising SaaS terms with a vendor The contract's limitation of liability is capped at annual fees paid. The team uses `validate_contract_review` to quantify the gap between their actual potential losses and that low cap, forcing a negotiation on exposure. ### Reviewing multi-state partnership agreements A partnership spans three states with different laws. The tool flags which governing law mismatches exist and whether the arbitration venue is enforceable from all three locations. ## Benefits - You stop guessing at legal risks. The tool forces specific quantification, turning 'high risk' into '$2M+ uncapped damages.' - It ensures you don't miss standard protections. Running the `validate_contract_review` checks for things like IP ownership and liability caps that are often overlooked. - You avoid jurisdictional nightmares. The MCP analyzes governing law versus your company’s location, flagging conflicts before they become international headaches. - Negotiations get strategic. Instead of just accepting terms, you map negotiation leverage by knowing which clauses genuinely matter to both parties. - The process is faster than manual review. It automates the intensive effort required to score every single clause and track down missing legal text. ## How It Works The bottom line is you get a detailed, actionable risk assessment that goes far beyond simple summarization. 1. Upload the contract document and initiate a review using this MCP. 2. The system performs deep, clause-by-clause analysis across risk scoring, protections, jurisdiction, financial exposure, and negotiation strategy. 3. You receive a structured report detailing every gap, quantified in dollars and identifying specific actions needed. ## Frequently Asked Questions **Is this a substitute for legal counsel?** No. This tool structures your analysis before you meet with legal counsel. It ensures you identify risky clauses, missing protections, and financial exposure — so your lawyer meeting is productive, not exploratory. **How does risk scoring work?** Each clause gets a 1-5 score: 1=standard/favorable, 2=acceptable, 3=review recommended, 4=unfavorable/risky, 5=critical/potentially harmful. The score MUST include justification — not just a number. **What are the 10 standard protections checked?** Limitation of liability, IP ownership, termination rights, indemnification, confidentiality/NDA, data processing/GDPR, force majeure, audit rights, warranty/representations, and dispute resolution mechanism. **What clients can I use with the `validate_contract_review` tool?** You connect through any MCP-compatible client. Vinkius handles the connection, so it doesn't matter if you prefer using Claude, Cursor, or Windsurf to run this analysis. **Does running `validate_contract_review` compromise my contract privacy?** No. The data is processed securely within the Vinkius ecosystem. We do not store your contracts after the session ends, ensuring client confidentiality for every review. **If my contract lacks necessary details, how does `validate_contract_review` handle it?** The tool detects missing or vague information and flags it as a risk. For example, if you omit financial figures, the tool will specifically report an EXPOSURE_UNQUANTIFIED verdict. **Are there rate limits when running the `validate_contract_review` tool?** Vinkius manages resource allocation to ensure stability. While heavy usage is subject to platform guidelines, the architecture supports high-volume, continuous contract reviews. **Can `validate_contract_review` analyze niche industry contracts (like crypto or biotech)?** The tool focuses on structured legal analysis, not industry expertise. As long as you provide the full text, it will rigorously check for standard clauses like IP ownership and data protection across any domain.