Patty

Version 0.6.0

A local MCP server for software inventions. It reads a repository with you and does three jobs:

• Patent this repo. Finds the mechanisms in the code, compares each with the closest prior art it can find, records whether each is worth protecting, and prepares a US provisional patent application.

• Build around a patent. Charts every independent claim of someone else's patent against the code, element by element, and shows where a change would take an element out.

• Trademark. Knockout check and the fields for a US trademark application.

You approve what it prepares, then sign, pay and submit in your own USPTO account. The server never signs, submits or pays. It never says an invention is novel or patentable, or that code is clear of a patent.

Patty prepares documents for you to file yourself. It is not a law firm and this is not legal advice.

How it works

The MCP host (Claude Code, Cursor, Codex) does the reading and the writing. The server supplies the method, the file formats, the drawings, the checks and the filing copies.

1. patty_start returns the drafting method and a map of the repo.

2. The host reads the code and writes EVIDENCE.md: each mechanism with file:line citations.

3. patty_prior_art searches patents, papers and repositories, then fetches the closest references in full, with their similar documents and citations to chase. The host writes PRIOR_ART_CHART.md: each mechanism broken into elements, each reference marked yes, partly or no per element, with a quote for every yes and partly.

4. The host writes SPECIFICATION.md around what the closest references lack, and calls patty_figures for the drawings.

5. patty_check opens every cited line of code, looks for every chart quote in the stored reference text, compares every reference numeral, and fails the packet on placeholders and limiting language.

6. patty_build writes the PDFs, the cover sheet worksheet, the docket and the filing steps. It will not run until the check passes.

Building around a patent

1. patty_start with kind clearance returns that method and the repo map.

2. patty_prior_art with fetch stores the patent: status, expiration, owner, and each claim marked independent or dependent.

3. The host writes CLAIM_CHART.md: each independent claim split into elements in the claim's own words, each element marked found in the code (with file:line) or not found (with the reason), and options for taking an element out.

4. patty_check compares the claim wording with the stored patent, opens every code citation, requires every independent claim to be charted, and requires the result to match the rows.

5. patty_build writes CLEARANCE_REPORT.md.

A product is covered by a claim only if it has every element of it. The chart shows which elements the code has. It is a literal reading, not a freedom-to-operate opinion.

Related MCP server: Claude Patent Creator MCP Server

Install

Needs bun 1.1 or later. Node is not required.

In Claude Code, one line:

claude mcp add patty -- bunx github:ckaico/patty

Add --scope user to have it in every project. In any other MCP host the server is the stdio command bunx github:ckaico/patty:

{ "mcpServers": { "patty": { "command": "bunx", "args": ["github:ckaico/patty"] } } }

Then open a software repo and say "patent this repo".

bunx keeps the copy it first downloaded. To install or move to a specific release, pin its tag: bunx github:ckaico/patty#v0.6.0.

From a clone

To work on Patty itself, or to pin a copy, clone the repository and run it from its folder:

git clone https://github.com/ckaico/patty && cd patty

bun install

claude mcp add patty -- bun "$PWD/src/index.ts"

Add --scope user to have it in every project. Any other MCP host takes the same stdio command:

{ "mcpServers": { "patty": { "command": "bun", "args": ["/absolute/path/to/patty/src/index.ts"] } } }

Connections

Patty has no accounts of its own. Every outside service is the user's: they sign up, they pay where it charges, and the key stays on their machine. patty_sources shows the whole picture, and with test: true tries each connection and reports what is left on a keyed plan.

Keys go in ~/.patty/, one file per service (serpapi_key, github_token, uspto_key, epo_key and epo_secret, pqai_key), or in PATTY_SERPAPI_KEY, PATTY_GITHUB_TOKEN, PATTY_USPTO_KEY, PATTY_EPO_KEY and PATTY_EPO_SECRET, PATTY_PQAI_KEY. PATTY_HOME moves the folder. They are read when a request is made and never written to a packet or an error message.

Hosted patent and trademark connectors with their own sign-in (GleanMark, Clarivate CompuMark, Haloo, Clerq, Patlytics, Solve Intelligence, IP Author) are not something Patty can log in to. The user adds them to their MCP host. When one is present in the session, the drafting method tells the host model to search with it too and to bring what it finds into Patty's charts, where quotes are checked. None was tested with an account.

A dependable patent source (recommended)

Without a key, patents come from Google Patents' own pages, which refuse requests after a burst; on one real run that cut the patent comparison off entirely. With a SerpApi key, the same search and the same full text come through their API. Their pricing page lists a free plan of 250 searches a month; a run on a mid-sized repo used about 40 patent requests.

Put the key in a file only you can read. Copy it from your SerpApi dashboard, then:

mkdir -p ~/.patty && pbpaste > ~/.patty/serpapi_key && chmod 600 ~/.patty/serpapi_key

PATTY_SERPAPI_KEY in the environment works too. The key is read when a request is made; it is never written to a packet or an error message. With a key set, patent queries and publication numbers go to serpapi.com, which queries Google Patents.

Official and semantic patent sources (optional)

Each of these is searched alongside Google Patents when its key is present. Results are merged, a publication found by several sources is listed once, and each hit says which sources found it. One source failing is reported on its own line and does not stop the others.

• USPTO Open Data Portal. Sign in at data.uspto.gov with a USPTO.gov account and copy the key from Manage API Key into ~/.patty/uspto_key. When a US patent is fetched, the stored reference gets a line USPTO status (official, checked <date>): ..., read by application number. Its search runs over application data (titles and bibliographic fields), not claims.

• EPO Open Patent Services. Register at developers.epo.org, add an app, and save its Consumer Key in ~/.patty/epo_key and its Consumer Secret in ~/.patty/epo_secret. The search runs over titles and abstracts. EP and WO publications are then fetched from OPS in full. US patents never are: OPS has no US full text.

• PQAI. API access comes with a paid plan, and commercial integration needs a higher one (projectpq.ai/api-pricing). Save the token from your account page in ~/.patty/pqai_key.

patty_sources with test: true checks each one with the cheapest call it offers.

Then, in any software repo, say "patent this repo" or "help me build around US1234567B2". The two prompts do the same: patent-this-repo and build-around (in Claude Code: /mcp__patty__patent-this-repo, /mcp__patty__build-around).

Tools

packet_path defaults to patty-packet/ in the folder the server was started in.

The packet

patty-packet/
  EVIDENCE.md          each mechanism, with file:line citations into the repo   (host writes)
  SPECIFICATION.md     the disclosure                                           (host writes)
  figures/*.svg        drawings; figures/source.json keeps the JSON they came from
  PRIOR_ART.md         what the searches found, with links
  PRIOR_ART_CHART.md   each mechanism against the closest references, element by element   (host writes)
  references/*.txt     full text of each reference read; references/search.json is the search log
  specification.pdf    filing copy
  drawings.pdf         filing copy
  COVER_SHEET.md       every field the filer types into the USPTO form
  FILING_STEPS.md      numbered steps for the human, ending in sign, submit, pay
  DOCKET.md            first public disclosure, grace limit, twelve-month date
  STATUS.json          what is done, what is waiting on the human
  TM_KNOCKOUT.md, TM_FIELDS.md   trademark packet
  CLAIM_CHART.md, CLEARANCE_REPORT.md   building around a patent

The numbered steps end sign, submit, pay, in that order, because that is the order of Patent Center's screens: the fee is paid after the submission receipt.

No example packet is included in this repository. A packet describes an invention, and an unfiled one does not belong in a public repository.

File formats

EVIDENCE.md entries look like this. The text after | has to be on the cited line or inside the cited range; only whitespace differences are forgiven.

## E1. Two-stage eviction
Spec: 2
Expired entries are removed first, and a live entry is removed only if the store is still full.
- src/cache.ts:22 | Expired entries go first; only then the least used one.
- src/cache.ts:23-29 | if (store.size < MAX) return;

PRIOR_ART_CHART.md looks like this. A reference can be charted only after patty_prior_art has fetched it, and every quote has to be in the stored text.

## M1. Two-stage eviction
Evidence: E1
- A. Expired entries are removed before any live entry.
- B. A live entry is removed only if the store is still full.

### US0000001A
- A: yes | entries whose time to live has elapsed are deleted before any other entry
- B: no

Result: closest US0000001A; differs in B

The result line has three forms: knocked out by <reference> (one reference has every element), closest <reference>; differs in B, C, and nothing close found. There is no form that says a mechanism is new. Each mechanism also carries Protect: yes | reason, maybe or no: the host's call on whether it is worth the cost of protecting, weighing whether a real difference survives, whether a competitor would have to copy it, and whether copying could be seen from outside. A knocked-out mechanism has to be no.

CLAIM_CHART.md looks like this. Elements are copied from the claim; a paraphrase fails.

## US0000009B2 claim 1
- A. maintaining a data store that stores data for a plurality of tenants
- B. storing an entry in an in-memory cache with an expiry time

- A: no | one store for one user; nothing in src/ carries a tenant identifier
- B: yes | src/cache.ts:19 | store.set(key, { value, expires: now + ttl, hits: 0 });

Result: not found in the code: A

The result is every element found in the code or not found in the code: A, D. There is no form that says the code is clear.

SPECIFICATION.md uses the headings Title, Field, Background, Summary, Brief Description of the Drawings, Detailed Description (with sections numbered ### 1. Name), Example Claims, Abstract. Reference numerals are whole numbers from 100 up. The full contract, with the figure JSON, is the text in src/method.ts, which patty_start returns.

What patty_check checks

Fails the packet when:

• a numbered section of the Detailed Description (other than Variations) has no evidence entry with a citation that verifies;

• a cited file or line does not exist, the path leaves the repo, or the cited text is not on the cited line;

• a quote in the prior art chart is not in the stored reference, a charted reference was never fetched, or an element has no row;

• the chart's result contradicts its rows: a reference marked yes for every element has to be reported as a knockout;

• the search returned results and there is no chart;

• a mechanism has no Protect: line, or a knocked-out one is not marked no;

• in a claim chart: an element is not the claim's own words, an independent claim is not charted, a code citation does not verify, a "no" has no reason, or the result does not match the rows;

• a reference numeral is in the Detailed Description and in no figure, or in a figure and never in the text;

• the text refers to a figure that does not exist, or a figure has no line in the Brief Description of the Drawings;

• a placeholder remains ([CITY], TODO, TBD, ____, {{...}});

• limiting language appears: "the invention is", "the present invention", "must", "essential", "critical", "always";

• a required section is missing or empty.

Warns, loudly, when a mechanism is knocked out; cutting or narrowing it is the human's decision. Warns when no search ran. Also warns on an abstract over 150 words, a title over 500 characters, text above the first heading, an inventor section in the specification, and missing claims or variations.

What it does not do: it does not judge whether the specification says only what the evidence supports, whether the description is accurate, whether a quote really discloses the element it is set against, or whether anything is new, non-obvious or eligible. A "no" in either chart is the host model's reading and is not checked; in a claim chart the whole result rests on it. Protect is a judgment, recorded so the human can disagree with it. Telling a quantity from a reference numeral is a heuristic: a number of 100 or more counts as a quantity when "for example", "about" or a similar word comes before it, or a unit such as "characters" or "ms" comes after it. "critical" also fails in "critical section"; reword.

Network use

The server sends no source code anywhere and has no telemetry. It makes these requests, and no others:

PATTY_OFFLINE=1 turns every request off; the affected files then say "search unavailable". PATTY_PATENT_SEARCH_URL points the patent search at another endpoint with the same response shape. PATTY_TM_REGISTER_URL does the same for the register lookup.

A query describes the mechanism being searched for. For an unfiled invention, that is a description of it sent to a search service. Phrase queries as general mechanisms, or set PATTY_OFFLINE=1 and search by hand.

What the host model does with your code is the host's business, not this server's.

Checked against primary sources

Read on 2026-11-08. Each row says what was read and what it showed. The generated documents state no fee amounts; the amounts here are a dated observation, not something the code uses.

Other patent and trademark MCP servers, surveyed 2026-11-10

None was run with an account. What is said here comes from their own listings, plus one unauthenticated request to each endpoint.

None of these reads a codebase, and none ties its conclusions to quotes that are checked.

Not checked

• Patent Center and Trademark Center themselves. Both need a signed-in, identity-verified account. The steps follow the published guide, not the live screens.

• Whether Patent Center accepts these PDFs. They have embedded fonts and a 1.6 header and were rendered and read back locally, but none was uploaded, and no PDF/A validator was run.

• The USPTO Open Data Portal, EPO OPS and PQAI with a real key. Each was built from its published documentation and tested against responses shaped like it; see Limits.

• The USPTO TSDR API. From USPTO pages it looks up a mark's status by serial number with a key; it is not a name search. Not tested.

• Micro and small entity rules. The documents link to them and leave the certification to the filer.

• The class numbers and identification wording suggested in TM_FIELDS.md. They are starting points to look up in the Trademark ID Manual.

• "Revised Inventorship Guidance for AI-Assisted Inventions", 90 FR 54636, 28 November 2025. It exists and replaces the February 2024 guidance; only its abstract was read. It bears on who is named as an inventor, which this tool leaves to the human.

• Anything outside the United States.

Tested

• patty_sources with test: true, live, no keys set: the direct patent pages, arXiv, GitHub and GleanMark each answered; SerpApi, the USPTO Open Data Portal, EPO OPS and PQAI reported no key.

• With made-up keys for the USPTO, EPO and PQAI (2026-11-11), live: a search reported each of the three as refused on its own line (HTTP 403, 401 and 401), an EP fetch, refused by OPS, went on to Google Patents and reported both failures, patty_sources reported each test as failed, and no key appeared in any output. That exercises the error paths only; no real key has been used.

• bun test: 54 tests on a small sample cache repository, no network. They cover the repo map, each figure type, every failure the check is meant to catch, the prior art chart rules (a quote not in the reference, a reference never fetched, a knockout reported as anything else), the build refusing a failing packet, the PDF header and fonts, the order of the last filing steps, date arithmetic, and the offline paths of the two searches. The claim chart tests cover a paraphrased element, an uncharted independent claim, a bad code citation, a result that contradicts its rows, and a report that never says "clear".

• bun run typecheck: strict TypeScript.

• Figure port: six existing figures (two hand-placed diagrams, four flowcharts) were re-expressed as figure JSON and rendered; each matched the original element for element. One deliberate difference: double-headed arrows now point outward at both ends.

• The check was run against an existing hand-written provisional draft. It found one placeholder and six reference numerals that were in the figures and never in the text.

• PDFs were rendered to images and looked at. That is how a font subsetting fault was caught: letters went missing on the page while the text layer still read correctly. Fonts are embedded whole for that reason.

• End to end: a fresh Claude Code session in a copy of a real repository of about 17,000 lines, given only "patent this repo", produced a packet in 34 turns that passes patty_check (8 evidence entries, 53 citations, 6 figures) and ends at FILING_STEPS.md. The patent search was switched off for that run.

• patty_start on a git repository with two remotes: the public one was reported public, the other not, and a token embedded in a remote URL did not appear in the output.

• patty_prior_art: a live query returned titled, linked results; with the endpoint pointed at a closed port the file said "Search unavailable" and the tool did not fail.

• End to end with search on (2026-11-10): a fresh session on a 39-line sample cache repository searched in rounds, fetched ten references, and wrote a chart of three mechanisms against four references with 21 checked quotes. Each mechanism came back with a close reference and a narrow difference, and the session reported the differences as thin. Three follow-up fetches failed with HTTP 503 and GitHub search was rate-limited on four of eight queries; both now retry or say so.

• Build-around, end to end (2026-11-10): a fresh session asked to build around a real, active cache-eviction patent on the sample repository fetched it, charted all four independent claims (27 code citations), found no claim with every element in the code, singled out the one claim that was close and why, and listed three options with what each costs. 13 turns, about 2 minutes.

• patty_prior_art fetch: a patent (87,000 characters, with 25 similar documents and its citations), an arXiv paper (abstract) and a GitHub repository (README) were each stored and listed.

• patty_tm_check on "Argyle": reported two registered ARGYLE marks and one pending in software classes from the register, the existing company at argyle.com, and eight registered domains.

Limits

• Software inventions only. The codebase is the disclosure.

• US provisional patent applications and US trademark applications. No non-provisional claim drafting, no design applications (a design cannot be filed as a provisional), no foreign filings.

• No submission, signing or payment, by design. No hosted version, accounts or billing.

• The prior art search is keyword search through an unofficial patent endpoint, arXiv and GitHub. Retrieval is the weak point: a reference the search never surfaces is never charted. It does not reach products, documentation, or code that is not on GitHub. Papers are stored as abstracts and repositories as READMEs.

• The claim chart is a literal reading of the claims named, against this repo. It does not cover equivalents, other patents or pending applications of the same owner, or patents outside the US. Status and expiration come from Google Patents and are unverified. With a USPTO key, the stored patent also carries the USPTO's own application status; it does not show maintenance fees paid or an expiration date. Design patents are not handled: their claim is the drawings.

• Without a key, the patent source throttles. On a real run of 21 queries in six minutes, Google Patents began answering 503 after the first eight and refused every full-text fetch, so no patent was charted; it was still refusing an hour later. Requests are spaced per source and a refusal is reported as such, but the keyless route is not dependable for a real run. The SerpApi route is the fix. It was written from SerpApi's published response format and its parsers are tested against that format; it has not been run with a live key.

• The USPTO Open Data Portal route (status lookup and search) was written from the portal's published OpenAPI files and is tested against responses shaped like them; it has not been run with a live key. Its search is a keyword match over application data, not claims or full text.

• The EPO OPS route (search, and EP and WO full text) was written from the OPS reference guide and its XML schemas and is tested against responses shaped like them; it has not been run with a live key and secret. The claims parser handles the two layouts the schema allows, one element per claim and one block of numbered text; a third layout would show up as a reference with no claims, which is refused and falls back to Google Patents. OPS has no US full text, and a reference read from it carries no citations, similar documents or legal status.

• The PQAI route was written from PQAI's API guide and, for the fields of each result, its open-source server code; it has not been run with a live token. The hosted service could return fields the open-source server does not.

• The chart can show that something is not new. It cannot show that something is new, and it says nothing about obviousness or subject-matter eligibility.

• The trademark knockout sees the register only through a third party's copy, and only for the name as typed.

• Drawings are block diagrams, data tables and flowcharts. Fonts in the PDFs are Tinos and Arimo (SIL Open Font License 1.1, from the @expo-google-fonts packages).

• Markdown in the specification is limited to headings, paragraphs, - lists, bold, italic and inline code.

Development

bun test

bun run typecheck

bun scripts/call.ts --list

scripts/call.ts calls one tool over stdio the way a host does: bun scripts/call.ts patty_check '{"packet_path":"/path/to/patty-packet"}'.

src/index.ts     server, tool and prompt registration
src/method.ts    the drafting method and file-format contract
src/start.ts     patty_start        src/repomap.ts   repo map
src/figures.ts   patty_figures      src/check.ts     patty_check
src/build.ts     patty_build        src/pdf.ts       PDF writers
src/priorart.ts  patty_prior_art    src/tm.ts        patty_tm_check
src/sources.ts   patty_sources      src/keys.ts      where keys are read from
src/references.ts  reference fetching and storage    src/chart.ts  prior art chart rules
src/claimchart.ts  claim chart rules (a patent against this repo)
src/packet.ts    packet folder and STATUS.json

License

Apache License 2.0. See LICENSE and NOTICE.