MCP App Store
by KeenEthics
IP Author icon

IP Author MCP Server for Claude and ChatGPT

By IP Author, Inc.

Overview

Search and analyze IP Author's 183M-publication global patent corpus and US prosecution data. • Run guided prior-art, freedom-to-operate, patent-landscape, evidence-of-use, and SEP-essentiality workflows; • Inspect application file wrappers, claims, citations, specifications, and response arguments; • Compare examiners; and • Prepare downloadable research artifacts. Results are research support, not legal opinions, and should be reviewed by qualified counsel.

How to connect

  1. Claude: Open the IP Author listing in the Claude connectors directory and choose Connect. Claude listing IP Author exposes 19 tools here.
  2. ChatGPT: Open the IP Author listing in the ChatGPT app directory and choose Connect. ChatGPT listing IP Author exposes 20 tools here.

Tools

application_citations

ChatGPT
Parsed structured citations for a US application — the prior-art references that were either submitted by the applicant (IDS / SB-08 / 1449 forms) or cited by the examiner (892 form). Each row identifies one cited reference with: cited_ucid (patent UCID like 'US-20200351973-A1', or null for NPL); npl_text (free-form for non-patent literature, null for patents); cited_by ('applicant' / 'examiner' / 'third_party'); source_document_code (IDS / 1449 / SB08 / 892 / REF.OTHER); submission_date; considered (examiner-initialed flag, relevant for IDS forms only); pcs_verified (whether the UCID resolved in the corpus); pcs_metadata (title / pd / famid / ab_snippet from the corpus when verified); and npl_url + npl_snippet when enrichment has run. Supports invalidity, FTO, and prior-art-mapping workflows. Typical parameter patterns: - 'what prior art has the applicant disclosed?' → cited_by_filter=['applicant'] - 'what art did the examiner find?' → cited_by_filter=['examiner'], document_codes=['892'] - 'clean corpus-verified prior-art set, no NPL noise' → only_pcs_verified=true Returns an empty list (count=0) when no IDS-class citations are on record for this app — the applicant may have filed none yet, or they have not been processed yet. Either way the response is valid and safe to act on.

application_claim_evolution

ChatGPT
Claim-by-claim amendment tracking for a US application. Diffs every claim snapshot (as-filed → each amendment round) in the file wrapper and returns a chronological timeline: which claims were added, canceled, or amended at each round, with before/after previews and a per-amendment length delta (a longer claim usually means added limitations = narrowing = prosecution-history estoppel risk). summary gives the headline (rounds, net claim change, claims ever added/removed). Supports estoppel and claim-scope-surrender analysis and shows how the claims reached their granted form. If no snapshots are parseable the result carries advice — a hydration gap, NOT 'no amendments were made'.

application_document_body

ChatGPT
Fetch the body text (raw_text) of one document from a US application's file wrapper. The body_ref comes from a prior application_filewrapper call — every entry in data.documents has a body_ref field. This tool exists so you can fetch ONLY the bodies the user actually needs after triaging the metadata, instead of pulling every body inline by default. Designed for requests about a specific document — 'what does the final rejection say?', 'show me the applicant's remarks from 2026-04-07', etc. Each call returns ~10-50 KB (one body), so the response fits inline cleanly. If the user wants the bodies of several documents, each body_ref identifies one document. The body_ref is an opaque value from application_filewrapper and is not client-decodable.

application_filewrapper

ChatGPT
Pull the complete prosecution + publication record for a US application. Merges three sources into a metadata-only view by default: (a) office actions and the applicant's formal responses; (b) supplemental filing documents (CLM = claims-as-filed, REM = applicant remarks, A... = amendments, SPEC, IDS, NOA, etc.); each has document_code, mail_date, direction, body_ref, and optional download_url; (c) patent-publication metadata when the app is published — title, abstract, publication number, UCID, assignee, status. Claims (clm) and specification (desc) bodies are NOT included by default — see application_spec for those. Patent identity: top-level patent_number is the GRANTED US patent number from the USPTO applications table (null while the app is pending), with grant_date, filing_date, and application_status_text alongside. The publication number is distinct from the granted patent number and identifies the pre-grant A1 UCID for a pending application (e.g. app 16024707: patent_number=11355438, publication US-20200006232-A1). Each document in data.documents carries a body_ref (an opaque string) and a raw_text_size or file_size_bytes hint. To fetch the body text of a specific document, pass that body_ref to application_document_body. The body_ref is an opaque continuation value and is not client-decodable. This lazy-fetch design keeps the default response small (~5 KB) so you can triage 7-doc filewrappers without burning context, then pull only the bodies the user actually needs. Optional high-volume fields: - include_body=true: inline raw_text for every document in one call. Convenient but bloats the response (~70-500 KB). - include_pcs_full_text=true: inline the full claim + description text too. The per-document body_ref path is the lower-volume option when every body is not required. Parsed prior-art citation rows (IDS / 892 / 1449 forms — structured records of which references the applicant disclosed and which ones the examiner cited) are available from application_citations and are not bundled here. When publication metadata is present it includes the title and abstract. Document bodies are available separately by body_ref, and full claims or specification text is available through application_spec.

application_precedents

ChatGPT
Given a US application with an office action, find the closest precedent office actions: granted applications handled by the SAME examiner that received the SAME statutory rejection (for example a 35 U.S.C. 103 obviousness rejection) and were overcome to reach grant. Results are ranked by how much subject matter they share with the target, measured by overlapping CPC subclass, so the closest technical matches come first. Each precedent carries the granted patent number (the proof it was overcome), the shared CPC subclasses, and a short preview of the rejection it faced. Use it to show an attorney how this examiner's comparable rejections were successfully answered before drafting a response. The statute, examiner, and art unit default to the target application's own record; override statute for a different rejection, or examiner_name to study how a different examiner handled it. When no same-examiner precedent shares a CPC subclass, it falls back to same examiner plus statute plus art unit. match_mode in the result says which path was used, and warnings explains any empty result. To read how a specific precedent was overcome, pass its application number to application_response_arguments or application_filewrapper.

application_response_arguments

ChatGPT
Extract the argument sections from each prior response on a US application, showing what was argued and what worked. Merges the parsed responses table with applicant response documents (REM / amendments) from the file wrapper. Each response carries _source, and inline arguments_text when the stored body really is argument text; a text_quality flag means the response EXISTS but our stored copy is partial or unavailable. In that case the response and date remain present, and download_url points to the source document. The _meta.advice field describes data-quality limitations.

application_spec

ChatGPT
Fetch the full specification (desc, ~50-500 KB) and claims (clm, ~10-50 KB) of a published US application from the IP Author patent corpus. Used for drafting, amendment, claim-construction, §112 written-description analysis, and prior-art mapping. Title and abstract are NOT returned here — they're already in application_filewrapper's metadata. This tool is intended for requests that require the full disclosure body. Unpublished / pre-publication apps (no published corpus text) fall back to the as-filed SPEC and CLM documents from the USPTO file wrapper — _source says so when that happened. Errors only when neither the corpus nor filing documents have the text.

bulk_download

ChatGPT
Bulk-download full-document patent PDFs. Accepts a list of patent UCIDs (e.g. from a search result) and returns a single ZIP of their full-document PDFs plus a coverage report. Max 500 UCIDs per batch. The operation self-polls: a quickly completed batch returns the full result inline; otherwise it returns a next_step identifying bulk_download with the result's job_id as the continuation — each call keeps working and returns the ZIP directly when it is ready. Large batches take MINUTES (a few hundred PDFs is normally 2-4 minutes). Continuation calls use the job_id; an in-progress state is not a failure and the download is delivered only when the result carries download_url. While a job is running, continuation uses its job_id; resubmitting the UCID list creates another batch. The result carries download_url (a ZIP link), retrieved (how many were found), and two shortfall buckets: missing/missing_ucids (no PDF available for those — usually older or non-US patents) and errors/error_ucids (couldn't be retrieved this time — re-submitting just those UCIDs usually returns them).

document_status

ChatGPT
Get the processing status of an uploaded document. Poll after uploading a PDF file until status changes from processing to ready (or failed). For inline text uploads (document_upload), status is always ready immediately — no polling needed. Response includes: doc_id, name, type, status, pages, chars, expires_at, and error (if failed).

document_upload

ChatGPT
Register a large document (spec sheet, standard, product datasheet, invention disclosure) so an analysis can reference it by id instead of inlining its full text. Accepts large documents already available as text — a multi-hundred-page standard, a long datasheet, or a full IDF. Returns a doc_id immediately with status: ready. Pass that doc_id to evidence_of_use or freedom_to_operate via their doc_ids input: the server resolves it to the document's text and reads it in full (chunked, never truncated), so a huge document never has to travel inline through a capped text field. For a binary PDF that has not been extracted yet, upload the file through IP Author's document upload and poll document_status until it is ready. Documents are consumer-scoped (only the uploading API key can access them) and expire 30 days from last reference. expires_at is returned so calling apps can warn users before expiry.

evidence_of_use

ChatGPT
Practitioner-grade evidence-of-use claim chart. patent_ucid is the only required input; the tool harvests its own product evidence. It maps a patent against a product for an infringement read, a claim chart, an evidence-of-use analysis, or an invalidity-vs-infringement comparison, running claim construction, prosecution-history estoppel, doctrine-of-equivalents analysis, visual comparison against the patent's drawings, a conservative review pass, and the all-elements rule over evidence it finds and ranks itself. patent_ucid alone identifies candidate (company, product) pairs from the claim language and charts the chosen one; add company / company_url, product_urls, evidence, or product_description to target a product; doc_ids (preferred for large files) or inline product_file_contents add uploaded documents; patents=[UCID, …] (max 10) runs a batch. Returns per-product claim_charts[] — each with construction, estoppel, element mappings, coverage, critical review, documentation gaps, decidability and assessment — alongside claim_construction, prosecution_history, visual_corroboration, temporal (the product's availability against the patent's priority and issue dates), comparative_coverage, recommended_next_steps, _provenance, and workflow_guidance. The language is neutral (overlap, correspondence); the construction, estoppel and doctrine-of-equivalents conclusions require attorney review, and it is not a legal opinion or an infringement determination. Heavy operation: roughly a minute per interactive step, several minutes for a full unattended run. Collaborative by default (see autonomous): it pauses for user confirmation or adjustment, and a review step advances only with the user's confirmation; the finished chart and export deliverables arrive in a completed result.

examiner_compare

ChatGPT
Head-to-head comparison of 2 US examiners: grant rate, statute rejection mix, art unit, average prosecution length, allowance after interview. Both name_a and name_b are required.

fields

ChatGPT
Lists the patent attributes available for search, filtering, and export, grouped by subject.

freedom_to_operate

ChatGPT
Guided freedom-to-operate analysis. Finds active and pending patent rights that may cover a product, lets the user review the scope and candidates, compares shortlisted claims to the product, and produces an auditable clearance report with ranked risks, unresolved questions, and recommended physical checks. No preliminary retrieval call is required. The workflow is interactive by default: it returns the product's features, the search boundary, the surfaced patents and claims it proposes to read, the clearance read, and the output format, so the user can confirm or revise each. A review point advances only with the user's confirmation. New runs accept product_description, or claim_elements when the product features are already defined. The report includes the reviewed search scope, relevant granted and pending rights, claim-by-claim findings, legal-status and ownership context, mitigation considerations, and clear warnings for any unresolved scope or data gap. At the final review point the report can be delivered as a Word, Excel or PDF file to download. A partial result does not yet include the clearance conclusion.

landscape

ChatGPT
The landscape tool. Comprehensive multi-section report: filer scorecard with composite quality index, filing trajectory + acceleration, geo + CPC distribution, crown jewels (multi-factor), technology evolution heatmap, whitespace matrix, SEP overlay, lead-lag, evolving pipeline (granted/pending/expiring), continuation stacking, M&A signals, momentum forecast. Add market_context via augmentations to also open with cited market/industry context. Persona-tailored output (vc | ip_director | litigator | rd_scientist | inventor). q determines which patents are analysed; topic is the plain-English label used for market context. Precise queries combine quoted phrases with OR and classification filters, for example tac_en:("5G NR" OR "5G New Radio") AND cpcpri:H04W*. Bare terms can match an excessively broad corpus. When q is absent, the short topic label becomes the patent search. A search matching too little or far too much is not reported as a landscape: the result carries status insufficient_corpus or decomposition_required plus a hint describing how the query can be adjusted. Drives itself: it submits and polls internally. For corpora over ~10k families this can take 90-240s (up to ~8 minutes with deep_taxonomy); if it does not finish within one window it returns a job_id and a next_step identifying landscape_status as the continuation tool. Re-entering landscape with that job opens another report view rather than polling the existing view. A completed result contains structured report sections, a narrative hint for each section, and a top-level presentation.report_outline. The outline identifies the recommended section order and table data, which carry the report's substance; a short bullet summary in their place omits most of it. Hosts that render inline app UIs show the landscape as an interactive report — charts, tables, section navigation — automatically; there is nothing to pass on for that. A completed run also carries report_url: that same interactive report, stored and openable only by the person who ran the search — a long signed link, meant as a labelled link rather than pasted as raw text. The field is absent when no interactive report was stored.

landscape_status

ChatGPT
Continue a landscape run and collect the finished report using the job_id returned by landscape. It keeps working on the same run and returns the finished bundle directly when it is ready; if the run needs more time it returns the current progress plus a next_step identifying landscape_status with the same job_id as the next step. A result whose status starts with completed contains the report. Most runs take 30-240s; runs with deep_taxonomy can take up to ~8 minutes, and a stage that repeats across calls is normal, not a stall. While running, progress shows the step count and the current stage. Interim progress does not contain a landscape report. The completed bundle has the same structured sections, narrative hints, presentation outline, and optional private report_url as a completed landscape response.

portfolio_analysis

ChatGPT
A COMPANY'S PATENT PORTFOLIO, step by step. Use this — not search — when the user asks how many patents a company has, wants a company's portfolio, or wants a company's patents in Excel. (search is for technology, keyword and patent lookups.) It runs in stages and stops for the user at each decision. STAGE 1 — identify the company: call with company as the user said it (short or inexact is fine, e.g. 'Delta'). It returns either status='confirm_company' (only one company has that name: name, patents, industry, country) or status='choose_company' (every company with that name, largest first, each with patents, industry and country, so the user can tell them apart). STOP: show the company or the WHOLE list and let the user confirm, pick one, or type another name — never pick yourself, never call it an error. Then call with portfolio_id and company_confirmed (the company as offered), or with company again for a newly typed name. STAGE 2 — the count: returns status='portfolio_ready' with the total publications and the simple families they form. Show the user the summary (the second text block of the result) exactly as written and add nothing to it, then STOP and ask whether to export and how to reduce the rows: per simple family (default), per extended family, per application or per publication. Always say 'simple family' or 'extended family', never 'family' alone. STAGE 3 — export: call with portfolio_id, export=true and rows ('simple_family', 'extended_family', 'application' or 'publication'). Returns download_url to an Excel file in the portfolio layout: number, publication number (linked), drawing, title, legal status & events, standardized current assignee (the company as the user named it), corporate owner, corporate owner (simple family), original applicant, dates, application number, English abstract and title, simple family members and countries (extended family for extended-family rows), inventors, expiry date, independent claims and claims in English — plus a Summary sheet (counts, and the companies that own the patents with why each is there). For each simple family / extended family / application the row shows a member owned by the company, US first, granted before published. Any stage can take a while: if the result names portfolio_analysis with a job_id, call again with ONLY job_id until the stage result arrives. Progress is NOT the result; never answer from it.

prosecution_strategy

ChatGPT
Deep prosecution strategy brief for an Office Action response decision. US prosecutions only. Composite of: file_wrapper + response_arguments + filewrapper_search (similar rejections), enriched with: - rejection-statute mix (the statutes cited in the latest Office Action) - argument patterns: named patterns like 'swearing behind under 1.131', 'TSM rebuttal', 'Graham secondary considerations', 'enablement carve-out' — each with a summary, frequency in the corpus, and 'when to use' note. - recommended_strategies with risk_level (low/med/high) and expected path to allowance - deadline math: statutory due date, USPTO 1-5 month extension fees (large/small/micro entity), AFCP 2.0 eligibility window - strategic options playbook: response (with/without amendment) / RCE / continuation / AFCP 2.0 / pre-appeal brief / full appeal — with viability, expected pendency, USPTO fees, and statute-driven preference annotations.

sep_analysis

ChatGPT
SEP essentiality assessment. Construes the claims, identifies the standard and release, reads the specification when it can be retrieved, maps every limitation to a provision, and re-checks each mapping before reaching a weakest-link verdict. Supports SEP essentiality analysis, declared-SEP checks, FRAND licensing research, and patent-to-standard mapping. The tool is collaborative by default: it returns the claims to assess, the standard and release it will chart against, whether the specification was actually retrieved, the limitation-to-provision mapping, and the output format, so the user can confirm or revise each. A review step advances only with user-supplied confirmation. Declared-SEP status (e.g. ETSI) is surfaced when known; standards are often paywalled, so the specification text can be supplied when a fetch is unavailable. A patent is standard-essential when a mandatory portion of the standard cannot be implemented without practicing every limitation of the claim, so the assessment follows the all-limitations / weakest-link rule. Returns the patent, the identified standard and release (with declared status), a per-claim mapping (each limitation with its verbatim normative text, section citation, and match strength), an overall assessment (verdict, confidence, essentiality type, key risks, recommended next steps), and a ready-to-read claim chart. The verdict is delivered in the completed result.

application_citations

Claude

application_claim_evolution

Claude

application_document_body

Claude

application_filewrapper

Claude

application_precedents

Claude

application_response_arguments

Claude

application_spec

Claude

bulk_download

Claude

document_status

Claude

document_upload

Claude

evidence_of_use

Claude

examiner_compare

Claude

freedom_to_operate

Claude

landscape

Claude

landscape_status

Claude

sep_analysis

Claude

Similar Apps

Listed on MCP App Store

Listed on MCP App Store

Add this badge to your site or README. It links to this page.

HTML

<a href="https://mcp-app-store.keenethics-labs.com/app/ip-author"><img src="https://mcp-app-store.keenethics-labs.com/badges/listed-on-mcp-app-store.svg" alt="Listed on MCP App Store" width="220" height="44"></a>

Markdown

[![Listed on MCP App Store](https://mcp-app-store.keenethics-labs.com/badges/listed-on-mcp-app-store.svg)](https://mcp-app-store.keenethics-labs.com/app/ip-author)