> ## Documentation Index
> Fetch the complete documentation index at: https://phidatainc.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Contracts

> Parties, dates, and a clause-level breakdown for legal review queues.

Extract parties, effective dates, terms, and clauses into a typed structure for downstream review. Use stable clause categories so review tools can filter the result.

```python theme={null}
from typing import List, Literal, Optional

from agno.agent import Agent
from agno.media import File
from agno.models.openai import OpenAIResponses
from pydantic import BaseModel, Field


ClauseCategory = Literal[
    "term_and_termination",
    "payment",
    "confidentiality",
    "indemnification",
    "limitation_of_liability",
    "warranty",
    "ip_assignment",
    "governing_law",
    "dispute_resolution",
    "non_compete",
    "other",
]


class Clause(BaseModel):
    category: ClauseCategory
    heading: Optional[str] = Field(None, description="Section heading as printed")
    text: str = Field(..., description="Clause text, verbatim")
    page: Optional[int] = Field(None, description="1-indexed page where the clause begins")


class Party(BaseModel):
    name: str
    role: Optional[str] = Field(None, description="e.g. Customer, Vendor, Licensor")
    address: Optional[str] = None


class Contract(BaseModel):
    title: Optional[str] = None
    contract_type: Optional[str] = Field(None, description="e.g. MSA, SOW, NDA, EULA")
    parties: List[Party] = Field(default_factory=list)
    effective_date: Optional[str] = None
    term: Optional[str] = Field(None, description="Stated term, e.g. '3 years from Effective Date'")
    governing_law: Optional[str] = None
    clauses: List[Clause] = Field(default_factory=list)


agent = Agent(
    model=OpenAIResponses(id="gpt-5.5"),
    instructions=(
        "Extract the contract header and every clause from the attached PDF. "
        "Clause text must be verbatim from the document. Assign each clause "
        "to the closest category; use 'other' if nothing fits. Do not "
        "summarize, paraphrase, or skip clauses."
    ),
    output_schema=Contract,
)

contract = agent.run(
    "Extract this contract.",
    files=[File(url="https://example.com/msa-acme.pdf")],
).content
# Contract(title='Master Services Agreement', contract_type='MSA',
#          parties=[Party(name='Acme Corp', role='Customer'),
#                   Party(name='Beta Labs', role='Vendor')],
#          effective_date='2026-01-15', term='3 years from Effective Date',
#          governing_law='State of Delaware',
#          clauses=[Clause(category='term_and_termination', ...), ...])
```

The `Literal` on `category` is what makes the output usable. Downstream review queues filter by category, so the categories must be a closed set. Free-text categories are unfilterable.

## Review queues by clause type

Once clauses carry a category, route them by team. Indemnification and limitation-of-liability go to legal; payment and term go to finance.

```python theme={null}
def route_for_review(contract: Contract) -> dict[str, list[Clause]]:
    legal = {"indemnification", "limitation_of_liability", "warranty", "ip_assignment"}
    finance = {"payment", "term_and_termination"}

    buckets: dict[str, list[Clause]] = {"legal": [], "finance": [], "other": []}
    for clause in contract.clauses:
        if clause.category in legal:
            buckets["legal"].append(clause)
        elif clause.category in finance:
            buckets["finance"].append(clause)
        else:
            buckets["other"].append(clause)
    return buckets
```

`route_for_review` operates on the typed result. Each clause retains its verbatim `text` and `page` for review.

## Diff against a template

For contract review, the question is often "what changed from our standard?" Extract both the incoming contract and your template into the same `Contract` schema, then diff by category.

```python theme={null}
incoming = agent.run("Extract.", files=[File(url=incoming_url)]).content
template = agent.run("Extract.", files=[File(filepath="templates/msa-v3.pdf")]).content


def clauses_by_category(contract: Contract) -> dict[str, list[str]]:
    grouped: dict[str, list[str]] = {}
    for clause in contract.clauses:
        grouped.setdefault(clause.category, []).append(clause.text)
    return {category: sorted(texts) for category, texts in grouped.items()}


incoming_by_cat = clauses_by_category(incoming)
template_by_cat = clauses_by_category(template)

deltas = [
    (cat, incoming_by_cat.get(cat, []), template_by_cat.get(cat, []))
    for cat in set(incoming_by_cat) | set(template_by_cat)
    if incoming_by_cat.get(cat, []) != template_by_cat.get(cat, [])
]
```

Clauses group into lists because one category often holds several clauses (`other` usually does). Sorting keeps the comparison order-independent.

For a richer comparison, hand both contracts to a reviewer agent with `output_schema` set to a `ClauseDelta` model and let the model summarize the differences.

## Long contracts and chunking

Agno sends the PDF to the model as a single file input: a URL reference when you pass `File(url=...)`, or base64-encoded bytes when you pass `filepath` or `content`. Nothing splits the document on the way, so the provider's file-size and context limits bound what one call can take. For contracts over that limit, split by section in your own code and run the agent per chunk. The schema is the same; you concatenate the `clauses` lists at the end.

## Next steps

| Task                                   | Guide                                                                           |
| -------------------------------------- | ------------------------------------------------------------------------------- |
| Schedule a nightly contract intake run | [Batch and durability](/use-cases/document-processing/batch-and-durability)     |
| Send risky clauses to a human reviewer | [Human routing and eval](/use-cases/document-processing/human-routing-and-eval) |
| Apply the same shape to intake forms   | [Forms and intake](/use-cases/document-processing/forms-and-intake)             |

## Developer Resources

* [Document extraction cookbook](https://github.com/agno-agi/agno/tree/main/cookbook/data_labeling/_16_document_extraction)
* [Structured output](/input-output/structured-output/agent)