Patent Analyzer

Problem

Patent documents are dense, highly structured legal texts that pack an enormous amount of technical and legal information into a format designed for lawyers, not engineers. When you're doing prior art research or analyzing a patent landscape, you're looking at dozens or hundreds of documents, each running 20-50 pages, and trying to extract the key claims, identify technical overlaps, and spot relationships between inventions.

Doing this manually is brutally slow. Each patent requires careful reading of the claims section (the legally binding part), the specification (the technical description), and the cited references. Miss a relevant claim and you might overlook prior art that invalidates a filing. The tools that exist for this are either expensive enterprise platforms or basic keyword search, neither of which gives you the structured analysis that patent work actually demands.

I wanted a fast, scriptable tool that could take a batch of patent documents, extract the structured information, and produce actionable analysis without requiring a subscription to a patent analytics platform.

Approach

I built a Python CLI tool that processes patent documents using natural language processing techniques. The tool accepts patent texts (from USPTO bulk data exports or individual PDF extractions), parses them into structured sections, and runs analysis pipelines for claim extraction, technical concept identification, and prior art mapping.

The CLI design prioritizes composability. Each analysis step can run independently or as part of a pipeline, which makes it easy to integrate into larger research workflows. Want just the claims extracted? One command. Want a full landscape analysis with citation networks? Chain the commands together. The output formats include JSON (for programmatic consumption), CSV (for spreadsheet analysis), and a formatted text report for human reading.

The NLP pipeline uses a combination of rule-based pattern matching for the highly structured parts of patents (claims always follow specific formatting conventions) and statistical methods for the less structured sections where you need to identify technical concepts and their relationships.

Key Technical Details

Patent claims follow a specific legal grammar that makes them amenable to rule-based parsing. Independent claims start with preamble language ("A method for...", "An apparatus comprising..."), and dependent claims reference parent claims explicitly ("The method of claim 1, wherein..."). This structure means you can build a claim dependency tree programmatically:

def parse_claim_tree(claims: list[str]) -> dict[int, Claim]:
    tree = {}
    for i, text in enumerate(claims, 1):
        dep_match = re.match(
            r"(?:The|A|An)\s+\w+\s+of\s+claim\s+(\d+)", text
        )
        parent = int(dep_match.group(1)) if dep_match else None
        tree[i] = Claim(
            number=i,
            text=text,
            parent=parent,
            is_independent=parent is None,
        )
    return tree

For technical concept extraction, the tool uses TF-IDF scoring against a corpus of patent texts in the same technology class. This surfaces terms that are distinctive to a particular patent relative to its peers, which is more useful than raw keyword frequency for identifying what makes an invention novel.

The CLI uses Click for argument parsing, which provides automatic help generation, parameter validation, and composable command groups:

@click.group()
def cli():
    """Patent analysis toolkit."""
    pass

@cli.command()
@click.argument("input_path", type=click.Path(exists=True))
@click.option("--format", type=click.Choice(["json", "csv", "text"]))
@click.option("--claims-only", is_flag=True)
def analyze(input_path: str, format: str, claims_only: bool):
    """Analyze patent documents and extract structured data."""
    documents = load_patents(input_path)
    results = run_pipeline(documents, claims_only=claims_only)
    output(results, format=format)

The prior art mapping uses citation analysis combined with text similarity. When patent A cites patent B, and both share high-similarity technical concepts, that's a strong signal of a relevant prior art relationship. The tool generates a ranked list of related patents with similarity scores and shared concept explanations.

Links

• GitHub Repository