Promptmønstre til juridiske domæner

EXTRACTION_PROMPT = '''Extract the following clauses from the contract below.
For each clause, provide:
- clause_type: one of [governing_law, limitation_of_liability, indemnification,
  termination, intellectual_property, confidentiality, arbitration, force_majeure]
- section_number: as it appears in the contract
- verbatim_text: exact text of the clause (do not paraphrase)
- jurisdiction_specific_notes: any NY-law-specific observations

If a clause is absent, set verbatim_text to null and note "Not found".
Return a JSON array.

Contract:
{contract_text}'''

import json

def extract_clauses(contract_text):
    response = client.messages.create(
        model='claude-opus-4-5',
        max_tokens=4096,
        system=LEGAL_SYSTEM_PROMPT,
        messages=[{'role': 'user', 'content':
            EXTRACTION_PROMPT.format(contract_text=contract_text)}]
    )
    return json.loads(response.content[0].text)

RISK_PROMPT = '''Perform a legal risk analysis of the following contract
under New York law. Identify up to 10 risks.

For each risk output:
1. Risk title (concise, max 8 words)
2. Severity: CRITICAL | HIGH | MEDIUM | LOW
3. Clause reference (section number)
4. Risk description (2-3 sentences)
5. Recommended mitigation (1-2 sentences)

Prioritize: limitation of liability caps, indemnification exposure,
unlimited IP assignment, auto-renewal traps, one-sided termination rights.

Contract:
{contract_text}

Format as a numbered list with clear labels.'''

def identify_risks(contract_text):
    response = client.messages.create(
        model='claude-opus-4-5',
        max_tokens=3000,
        system=LEGAL_SYSTEM_PROMPT,
        messages=[{'role': 'user', 'content':
            RISK_PROMPT.format(contract_text=contract_text)}]
    )
    return response.content[0].text

JURISDICTION_COMPARE_PROMPT = '''The contract below is governed by {governing_law} law.
I am a New York-based company. Analyze:

1. Key differences between {governing_law} and New York law that affect this contract.
2. Provisions that are enforceable under {governing_law} but may not be under NY law.
3. Choice-of-law risks if we add a NY-law addendum.
4. Recommended: should we negotiate to change governing law to NY? Why or why not?

Contract:
{contract_text}'''

def compare_jurisdictions(contract_text, governing_law):
    response = client.messages.create(
        model='claude-opus-4-5',
        max_tokens=2000,
        system=LEGAL_SYSTEM_PROMPT,
        messages=[{'role': 'user', 'content':
            JURISDICTION_COMPARE_PROMPT.format(
                governing_law=governing_law,
                contract_text=contract_text
            )}]
    )
    return response.content[0].text

PRIVILEGED_SYSTEM_PROMPT = '''You are a legal research assistant for
{firm_name}, a licensed law firm.

CONFIDENTIALITY NOTICE:
- All documents shared in this session are attorney-client privileged.
- Do not include client names, matter numbers, or identifying details
  in any output that may be logged externally.
- Do not store, reference, or infer information from previous sessions.
- Treat all information as confidential per Model Rules of Professional
  Conduct 1.6 (Confidentiality of Information).

SCOPE:
- Your role is legal research and document analysis only.
- You do not represent the client and do not provide legal advice directly.
- Flag all outputs with: "Review required by licensed attorney before use."

REFUSAL RULE:
- If asked to draft strategy for concealing evidence or misleading a court,
  refuse and explain that this violates professional responsibility rules.'''

print(PRIVILEGED_SYSTEM_PROMPT.format(firm_name='Smith & Associates LLP')[:200])

NDA_SUMMARY_PROMPT = '''Summarize this NDA for a business executive.
Extract these exact fields (be concise, max 2 sentences per field):

1. Parties: Who are the disclosing and receiving parties?
2. Purpose: Why is information being shared?
3. Confidential Information Definition: What is and is not covered?
4. Term: How long does confidentiality last?
5. Exclusions: What information is not protected?
6. Return/Destroy: What happens to confidential info after the relationship ends?
7. Remedies: What happens if the NDA is breached?
8. Key Risks: List up to 3 issues that deviate from standard market practice.

NDA Text:
{nda_text}

End with a one-sentence verdict: "This NDA is [FAVORABLE / BALANCED / UNFAVORABLE]
for the receiving party because _____."'''

def summarize_nda(nda_text):
    response = client.messages.create(
        model='claude-opus-4-5', max_tokens=1500,
        system=LEGAL_SYSTEM_PROMPT,
        messages=[{'role': 'user', 'content':
            NDA_SUMMARY_PROMPT.format(nda_text=nda_text)}]
    )
    return response.content[0].text

from pydantic import BaseModel
from typing import List, Optional
from enum import Enum

class RiskLevel(str, Enum):
    CRITICAL = 'CRITICAL'
    HIGH = 'HIGH'
    MEDIUM = 'MEDIUM'
    LOW = 'LOW'

class LegalRisk(BaseModel):
    title: str
    severity: RiskLevel
    clause_reference: str
    description: str
    mitigation: str

class ContractAnalysis(BaseModel):
    governing_law: str
    contract_type: str
    effective_date: Optional[str]
    term_years: Optional[float]
    risks: List[LegalRisk]
    overall_recommendation: str
    disclaimer: str = (
        'This analysis is informational only and does not constitute '
        'legal advice. Consult a licensed attorney before acting.'
    )

# Use with structured output (pseudo-code)
# analysis = ContractAnalysis.model_validate_json(llm_response)
# for risk in analysis.risks:
#     print(f'[{risk.severity}] {risk.title}: {risk.description}')

RED_FLAGS = [
    'unlimited indemnification with no cap',
    'unilateral right to modify terms without notice',
    'IP assignment of all work product ("work for hire" with no carve-outs)',
    'non-compete broader than 1 year or 100 miles',
    'automatic renewal with short cancellation window (< 30 days)',
    'no limitation of liability clause (unlimited damages)',
    'mandatory arbitration in unfavorable jurisdiction',
    'liquidated damages clause that may be penalty clause under NY law',
]

RED_FLAG_PROMPT = '''Review the contract below for the following red-flag provisions.
For each red flag found, quote the relevant text and rate severity 1-5.
If not found, mark as "Not Present".

Red Flags to Check:
{red_flag_list}

Contract:
{contract_text}'''

def detect_red_flags(contract_text):
    flags_text = '\n'.join(f'{i+1}. {f}' for i, f in enumerate(RED_FLAGS))
    response = client.messages.create(
        model='claude-opus-4-5', max_tokens=2000,
        system=LEGAL_SYSTEM_PROMPT,
        messages=[{'role': 'user', 'content':
            RED_FLAG_PROMPT.format(
                red_flag_list=flags_text,
                contract_text=contract_text
            )}]
    )
    return response.content[0].text

CITATION_PROMPT = '''Analyze the indemnification clause below under New York law.

For your analysis:
1. Cite the relevant NY statutes (e.g., NY General Obligations Law sections).
2. Reference applicable UCC provisions if relevant.
3. Cite at least one landmark NY case on indemnification interpretation.
4. If you are not certain a citation is accurate, prefix it with
   "[VERIFY: " and end with "]" — never fabricate case citations.
5. Distinguish between indemnification for third-party claims vs.
   direct damages between the parties.

Indemnification Clause:
{clause_text}'''

# Best practice: always post-process LLM citations with a legal database check
# (Westlaw, LexisNexis API) before relying on them in actual legal work
print('REMINDER: Always verify LLM-generated citations with a legal database.')

LEGAL_DISCLAIMER = (
    '\n\n---\n'
    'DISCLAIMER: This analysis is generated by an AI system and is '
    'provided for informational purposes only. It does not constitute '
    'legal advice and does not create an attorney-client relationship. '
    'Laws vary by jurisdiction and change over time. Always consult a '
    'licensed attorney in your jurisdiction before making legal decisions.'
)

def get_legal_analysis(prompt, system_prompt=LEGAL_SYSTEM_PROMPT):
    response = client.messages.create(
        model='claude-opus-4-5',
        max_tokens=2000,
        system=system_prompt,
        messages=[{'role': 'user', 'content': prompt}]
    )
    raw_output = response.content[0].text
    # Always inject disclaimer at application layer
    return raw_output + LEGAL_DISCLAIMER

analysis = get_legal_analysis('Summarize the key risks in this contract: ...')
print(analysis[-200:])  # Shows disclaimer at end