Legal Assistant

Legal Assistant

When to Use

Trigger phrases:

• "legal assistant"

• "Legal assistant for BerkahKarya — contract review checklists, IP protection, Ind"

• Drafting legal documents (contracts, NDAs, agreements)

• Managing legal document templates

• Tracking legal compliance requirements

• Organizing legal document versions

• Automating legal document workflows

When NOT to Use

• For processes that change daily (too much overhead)
• When the team is too small to benefit from SOPs
• For one-time events that will not repeat

Overview

Legal Assistant streamlines operational efficiency for operational excellence.

Workflow

# Example: SOP execution tracker
def execute_sop(sop_name: str, steps: list[str]) -> dict:
    results = []
    for i, step in enumerate(steps, 1):
        try:
            result = execute_step(step)
            results.append({"step": i, "status": "ok", "result": result})
        except Exception as e:
            results.append({"step": i, "status": "error", "error": str(e)})
            break
    return {"sop": sop_name, "steps": results}

1. Assess — Evaluate current state and identify gaps
2. Design — Plan improved processes and workflows
3. Implement — Roll out changes with team alignment
4. Measure — Track operational KPIs
5. Iterate — Continuous improvement based on data
6. Document — Record templates, decisions, and evidence for audit readiness
7. Review — Schedule periodic legal health checks and update templates for regulatory changes

SOP Template

• Purpose — Why this process exists
• Scope — Who and what it covers
• Procedure — Step-by-step instructions
• Escalation — When and how to escalate
• Review — Schedule for periodic updates

Key Metrics

• Process completion time
• Error/rework rate
• Team satisfaction scores
• Cost per operation
• SLA compliance rate

Anti-Rationalization Table

Process

1. Prepare — Gather requirements, verify prerequisites, set up environment
2. Execute — Run legal assistant workflow with configured parameters
3. Verify — Validate output meets requirements, document results

Verification

• All steps executed successfully
• Results validated against acceptance criteria
• Error handling tested with edge cases
• Documentation updated with findings

Code Examples

Contract Review Checklist Validator

"""Validate contract review checklist for common omissions."""
from dataclasses import dataclass, field


@dataclass
class ContractClause:
    name: str
    present: bool = False
    notes: str = ""


@dataclass
class ContractReview:
    title: str
    clauses: list[ContractClause] = field(default_factory=list)
    jurisdiction: str = ""
    parties: list[str] = field(default_factory=list)

    def missing_clauses(self) -> list[str]:
        return [c.name for c in self.clauses if not c.present]

    def score(self) -> float:
        if not self.clauses:
            return 0.0
        return sum(1 for c in self.clauses if c.present) / len(self.clauses)


# Essential clauses for a software services agreement
ESSENTIAL_CLAUSES = [
    "Scope of Work", "Payment Terms", "IP Ownership",
    "Confidentiality", "Limitation of Liability", "Termination",
    "Data Processing", "Warranty Disclaimer", "Indemnification",
    "Dispute Resolution / Governing Law",
]


def review_contract(title: str, parties: list[str], present: list[str],
                    jurisdiction: str = "") -> ContractReview:
    clauses = [ContractClause(name=c, present=c in present) for c in ESSENTIAL_CLAUSES]
    review = ContractReview(title=title, clauses=clauses,
                            jurisdiction=jurisdiction, parties=parties)
    missing = review.missing_clauses()
    print(f"Contract: {review.title}")
    print(f"Score: {review.score():.0%} ({len(ESSENTIAL_CLAUSES) - len(missing)}/{len(ESSENTIAL_CLAUSES)})")
    if missing:
        print(f"Missing clauses: {', '.join(missing)}")
    if not jurisdiction:
        print("WARNING: No governing law/jurisdiction specified")
    return review

GDPR Compliance Checker

"""Check a digital product's GDPR compliance posture."""
from dataclasses import dataclass, field


@dataclass
class GDPRCheck:
    requirement: str
    met: bool = False
    evidence: str = ""


@dataclass
class GDPRStatus:
    product_name: str
    checks: list[GDPRCheck] = field(default_factory=list)

    def compliance_pct(self) -> float:
        if not self.checks:
            return 0.0
        return sum(1 for c in self.checks if c.met) / len(self.checks) * 100

    def gaps(self) -> list[str]:
        return [c.requirement for c in self.checks if not c.met]


GDPR_REQUIREMENTS = [
    ("Lawful basis documented (Art. 6)", "Record of processing activity"),
    ("Privacy notice provided (Art. 13-14)", "Published privacy policy"),
    ("Data retention schedule defined (Art. 5(1)(e))", "Retention policy"),
    ("Data Subject Access Request process (Art. 15)", "DSAR workflow"),
    ("Consent mechanism auditable (Art. 7)", "Consent records"),
    ("Data Processing Agreement with subprocessors (Art. 28)", "DPA signed"),
    ("Security measures documented (Art. 32)", "Security policy"),
    ("Breach notification procedure (Art. 33-34)", "Incident response plan"),
]


def assess_gdpr(product_name: str, met_requirements: list[str]) -> GDPRStatus:
    checks = [GDPRCheck(req, met=req in met_requirements, evidence=ev)
              for req, ev in GDPR_REQUIREMENTS]
    status = GDPRStatus(product_name=product_name, checks=checks)
    print(f"GDPR Assessment: {status.product_name}")
    print(f"Compliance: {status.compliance_pct():.0f}%")
    if gaps := status.gaps():
        print(f"Gaps ({len(gaps)}):")
        for g in gaps:
            print(f"  [ ] {g}")
    return status

DMCA Takedown Notice Generator

"""Generate a DMCA takedown notice for infringing content."""
from datetime import date


def generate_dmca_notice(
    copyright_holder: str,
    infringing_url: str,
    original_work_url: str,
    platform_name: str,
    platform_agent: str = "Copyright Agent",
    email: str = "",
) -> str:
    today = date.today().isoformat()
    notice = f"""
DATE: {today}

TO: {platform_name}
ATTN: {platform_agent}

DMCA TAKEDOWN NOTICE — 17 U.S.C. § 512(c)

1. IDENTIFICATION OF COPYRIGHTED WORK:
   {original_work_url}

2. IDENTIFICATION OF INFRINGING MATERIAL:
   {infringing_url}

3. CONTACT INFORMATION:
   Name: {copyright_holder}
   Email: {email or '[email required]'}

4. GOOD FAITH STATEMENT:
   I hereby state that I have a good faith belief that the disputed use
   is not authorized by the copyright owner, its agent, or the law.

5. ACCURACY STATEMENT UNDER PENALTY OF PERJURY:
   The information in this notification is accurate, and I swear under
   penalty of perjury that I am the copyright owner or authorized to
   act on behalf of the owner of an exclusive right that is infringed.

SIGNATURE: _________________________
"""
    return notice.strip()

Software License Compatibility Checker

"""Check compatibility between two open-source licenses."""

# SPDX license expression compatibility matrix (simplified)
_COMPATIBLE = {
    ("MIT", "MIT"): True,
    ("MIT", "Apache-2.0"): True,
    ("MIT", "GPL-2.0-only"): True,
    ("MIT", "GPL-3.0-only"): True,
    ("Apache-2.0", "MIT"): True,
    ("Apache-2.0", "Apache-2.0"): True,
    ("Apache-2.0", "GPL-3.0-only"): True,  # Apache 2.0 → GPL 3.0 (compatible one-way)
    ("Apache-2.0", "GPL-2.0-only"): False,  # NOT compatible
    ("GPL-3.0-only", "MIT"): True,
    ("GPL-3.0-only", "Apache-2.0"): True,
    ("GPL-3.0-only", "GPL-3.0-only"): True,
    ("GPL-2.0-only", "MIT"): True,
    ("GPL-2.0-only", "GPL-2.0-only"): True,
    ("GPL-2.0-only", "Apache-2.0"): False,
}


def check_license_compatibility(license_a: str, license_b: str,
                                combined_license: str = "") -> str:
    key = (license_a, license_b)
    if key in _COMPATIBLE:
        ok = _COMPATIBLE[key]
        if ok:
            return f"✓ {license_a} and {license_b} are compatible"
        else:
            return f"✗ {license_a} and {license_b} are NOT compatible — review obligations"
    # Try reverse
    rev_key = (license_b, license_a)
    if rev_key in _COMPATIBLE:
        ok = _COMPATIBLE[rev_key]
        if ok:
            return f"✓ {license_a} and {license_b} are compatible (reverse direction)"
        else:
            return f"✗ {license_a} and {license_b} are NOT compatible — review obligations"
    return f"? No known compatibility data for {license_a} × {license_b}"


# Example: npm package using MIT code inside an Apache-2.0 project
result = check_license_compatibility("MIT", "Apache-2.0")
print(result)

Setup / Configuration

Requirements

# core requirements
jinja2>=3.1        # template rendering for contracts
python-docx>=1.1   # .docx contract generation
weasyprint>=60     # PDF generation from HTML templates
cryptography>=41   # signature verification / document hashing

Directory Structure

legal-assistant/
├── templates/          # Contract and notice templates (Jinja2)
│   ├── nda.j2
│   ├── services-agreement.j2
│   ├── dmca-notice.j2
│   └── privacy-policy.j2
├── checks/             # Compliance checklists
│   ├── gdpr.yaml
│   ├── dmca.yaml
│   └── licensing.yaml
├── output/             # Generated documents
└── config.yaml         # Jurisdiction defaults, company info

Configuration

Create config.yaml with your base settings:

# config.yaml
company:
  name: "Your Company"
  jurisdiction: "ID"            # ISO country code for default governing law
  registered_address: ""
  tax_id: ""

compliance:
  gdpr_representative: ""       # EU representative if outside EEA
  dpo_email: ""                 # Data Protection Officer contact
  dmca_agent_name: ""           # Registered DMCA agent name
  dmca_agent_email: ""          # DMCA agent email for filings

templates:
  default_language: "en"
  signature_lines: 2
  include_recitals: true

Common Issues / Troubleshooting

Monetization