AI Lease
Abstraction
Engine

import fitz  # PyMuPDF

def extract_text_from_pdf(pdf_path: str) -> str:
    """Extract all text from a PDF lease document."""
    doc = fitz.open(pdf_path)
    text = ""

    for page_num, page in enumerate(doc):
        page_text = page.get_text()
        text += f"\n[PAGE {page_num + 1}]\n{page_text}"

    doc.close()
    return text

lease_text = extract_text_from_pdf("lease.pdf")
print(f"Extracted {len(lease_text)} characters from lease")

from langchain.text_splitter import RecursiveCharacterTextSplitter

def chunk_lease(text: str, chunk_size: int = 1500, overlap: int = 200) -> list[str]:
    """Split lease text into overlapping chunks for LLM processing."""
    splitter = RecursiveCharacterTextSplitter(
        chunk_size=chunk_size,
        chunk_overlap=overlap,
        separators=["\n\n", "\n", ". ", " "]
    )
    chunks = splitter.split_text(text)
    print(f"Split into {len(chunks)} chunks")
    return chunks

chunks = chunk_lease(lease_text)

from openai import OpenAI

client = OpenAI()

def extract_lease_fields(chunk: str) -> str:
    prompt = f'''
    Extract the following lease information from this text.

    Fields to extract:
    - Tenant Name
    - Lease Start Date
    - Lease End Date
    - Base Rent
    - Square Footage
    - Security Deposit
    - Renewal Options
    - Rent Escalation

    Return ONLY the fields found.
    If a field is not found, return: Not specified

    Text:
    {chunk}
    '''
    response = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[{"role": "user", "content": prompt}]
    )
    return response.choices[0].message.content

extracted = extract_lease_fields(chunks[0])
print(extracted)

import json
from datetime import datetime

def parse_to_json(extracted_text: str) -> dict:
    """Convert LLM extraction output to a structured dict."""

    # In production, use GPT-4 to output JSON directly
    # by adding: 'Respond in valid JSON only.'

    lease_data = {
        "tenant_name":      "TechCorp Inc.",
        "lease_start":      "2022-01-01",
        "lease_end":        "2032-12-31",
        "term_years":       10,
        "base_rent_psf":    28.00,
        "square_feet":      12000,
        "annual_rent":      336000,
        "security_deposit": 336000,
        "escalation_pct":   3.0,
        "renewal_options":  "Two 5-year options at market rate",
        "extracted_at":     datetime.utcnow().isoformat() + "Z"
    }

    return lease_data

lease_json = parse_to_json(extracted)
print(json.dumps(lease_json, indent=2))

import pandas as pd
import sqlite3

def store_to_csv(lease_data: dict, output_path: str = "lease_abstractions.csv"):
    """Append extracted lease to a growing CSV rent roll."""
    df = pd.DataFrame([lease_data])

    try:
        existing = pd.read_csv(output_path)
        df = pd.concat([existing, df], ignore_index=True)
    except FileNotFoundError:
        pass

    df.to_csv(output_path, index=False)
    print(f"[✓] Saved to {output_path} — {len(df)} leases total")

def store_to_sqlite(lease_data: dict, db_path: str = "leases.db"):
    """Store extracted lease in SQLite (swap for PostgreSQL in production)."""
    df = pd.DataFrame([lease_data])
    with sqlite3.connect(db_path) as conn:
        df.to_sql("leases", conn, if_exists="append", index=False)
    print("[✓] Stored to SQLite database")

store_to_csv(lease_json)
store_to_sqlite(lease_json)