Automate NDA Review with AI: Flag Risk Clauses Before You Sign

pip install requests python-dotenv PyMuPDF

# .env
APIVULT_API_KEY=YOUR_API_KEY

import os
import fitz  # PyMuPDF
import requests
from dotenv import load_dotenv
 
load_dotenv()
 
API_KEY = os.getenv("APIVULT_API_KEY")
BASE_URL = "https://apivult.com/api/legalguard"
 
def extract_text_from_pdf(pdf_path: str) -> str:
    """Extract raw text from a PDF NDA."""
    doc = fitz.open(pdf_path)
    text = ""
    for page in doc:
        text += page.get_text()
    return text
 
def extract_nda_clauses(document_text: str) -> dict:
    """
    Extract key NDA clauses by category.
    Returns structured clause data with positions and text.
    """
    headers = {
        "X-RapidAPI-Key": API_KEY,
        "Content-Type": "application/json"
    }
 
    payload = {
        "document": document_text,
        "document_type": "nda",
        "extract_clauses": [
            "confidentiality_definition",
            "term_and_duration",
            "permitted_disclosures",
            "obligations_of_receiving_party",
            "exclusions",
            "return_of_information",
            "remedies",
            "governing_law",
            "assignment",
            "entire_agreement"
        ]
    }
 
    response = requests.post(
        f"{BASE_URL}/extract",
        json=payload,
        headers=headers,
        timeout=30
    )
    response.raise_for_status()
    return response.json()
 
# Load and extract from an NDA
nda_text = extract_text_from_pdf("vendor_nda.pdf")
clauses = extract_nda_clauses(nda_text)
 
for clause in clauses["extracted_clauses"]:
    print(f"\n[{clause['clause_type'].upper()}]")
    print(f"  Text: {clause['text'][:200]}...")
    print(f"  Confidence: {clause['confidence']:.0%}")

def analyze_clause_risk(clauses: dict) -> dict:
    """
    Score each extracted clause for risk level.
    Returns CRITICAL, HIGH, MEDIUM, or LOW for each clause.
    """
    headers = {
        "X-RapidAPI-Key": API_KEY,
        "Content-Type": "application/json"
    }
 
    payload = {
        "document_type": "nda",
        "clauses": clauses["extracted_clauses"],
        "analysis_perspective": "receiving_party",  # or "disclosing_party"
        "risk_factors": [
            "overbroad_scope",
            "perpetual_obligations",
            "unlimited_remedies",
            "unfavorable_assignment",
            "one_sided_obligations",
            "jurisdiction_risk"
        ]
    }
 
    response = requests.post(
        f"{BASE_URL}/analyze",
        json=payload,
        headers=headers,
        timeout=30
    )
    response.raise_for_status()
    return response.json()
 
risk_analysis = analyze_clause_risk(clauses)
 
# Display flagged clauses
for clause in risk_analysis["analyzed_clauses"]:
    if clause["risk_level"] in ["CRITICAL", "HIGH"]:
        print(f"\n🚨 {clause['risk_level']}: {clause['clause_type']}")
        print(f"   Issue: {clause['risk_description']}")
        print(f"   Recommendation: {clause['recommendation']}")

def generate_nda_summary(
    document_text: str,
    risk_analysis: dict,
    parties: dict
) -> dict:
    """
    Generate a plain-English NDA summary with key points and risk flags.
    """
    headers = {
        "X-RapidAPI-Key": API_KEY,
        "Content-Type": "application/json"
    }
 
    payload = {
        "document": document_text,
        "document_type": "nda",
        "risk_analysis": risk_analysis,
        "metadata": {
            "disclosing_party": parties.get("disclosing"),
            "receiving_party": parties.get("receiving")
        },
        "summary_format": "business_brief",  # or "legal_memo"
        "include_sections": [
            "what_this_covers",
            "how_long_it_lasts",
            "what_you_can_share",
            "key_obligations",
            "top_risks",
            "recommended_changes"
        ]
    }
 
    response = requests.post(
        f"{BASE_URL}/summarize",
        json=payload,
        headers=headers,
        timeout=30
    )
    response.raise_for_status()
    return response.json()
 
summary = generate_nda_summary(
    nda_text,
    risk_analysis,
    parties={"disclosing": "Acme Corp", "receiving": "Your Company"}
)
 
print(summary["plain_english_summary"])

import json
from pathlib import Path
from datetime import datetime
 
class NDAReviewPipeline:
    def __init__(self, api_key: str):
        self.api_key = api_key
 
    def review(
        self,
        pdf_path: str,
        parties: dict,
        auto_approve_threshold: str = "LOW"
    ) -> dict:
        """
        Run full NDA review pipeline.
        Returns review result with risk level and recommended action.
        """
        # 1. Extract text
        nda_text = extract_text_from_pdf(pdf_path)
 
        # 2. Extract clauses
        clauses = extract_nda_clauses(nda_text)
 
        # 3. Analyze risk
        risk_analysis = analyze_clause_risk(clauses)
 
        # 4. Generate summary
        summary = generate_nda_summary(nda_text, risk_analysis, parties)
 
        # 5. Determine routing decision
        max_risk = risk_analysis.get("overall_risk_level", "LOW")
        critical_issues = [
            c for c in risk_analysis["analyzed_clauses"]
            if c["risk_level"] == "CRITICAL"
        ]
 
        if max_risk == "LOW" or (max_risk == "MEDIUM" and not critical_issues):
            action = "auto_approve"
        else:
            action = "legal_review_required"
 
        result = {
            "reviewed_at": datetime.utcnow().isoformat(),
            "file": Path(pdf_path).name,
            "parties": parties,
            "overall_risk": max_risk,
            "critical_issues": len(critical_issues),
            "action": action,
            "summary": summary["plain_english_summary"],
            "full_analysis": risk_analysis
        }
 
        # Save review report
        output_path = f"nda_review_{Path(pdf_path).stem}_{datetime.utcnow().strftime('%Y%m%d')}.json"
        with open(output_path, "w") as f:
            json.dump(result, f, indent=2)
 
        return result
 
# Run a review
pipeline = NDAReviewPipeline(API_KEY)
result = pipeline.review(
    "vendor_nda.pdf",
    parties={"disclosing": "Vendor Corp", "receiving": "My Company"}
)
 
print(f"Risk Level: {result['overall_risk']}")
print(f"Action Required: {result['action']}")
print(f"Critical Issues: {result['critical_issues']}")