# Patents (npm · @pipeworx/mcp-patents) Patents MCP — wraps the USPTO Open Data Portal (ODP) Patent File Wrapper API - Trust score: 81/100 (high trust) - Change this week: +3 - Registry status: active - Liveness: live - Owner verified: no - Last scored: 2026-11-05 ## Components - remote · `gateway.pipeworx.io`: 63/100, [markdown](https://verifymcp.io/servers/pipeworx-io-patents/patents-mcp.md), [page](https://verifymcp.io/servers/pipeworx-io-patents/patents-mcp) - npm · `@pipeworx/mcp-patents`: 81/100 (this document), [markdown](https://verifymcp.io/servers/pipeworx-io-patents/pipeworx-mcp-patents.md), [page](https://verifymcp.io/servers/pipeworx-io-patents/pipeworx-mcp-patents) ## Channel facts - Registry: `npm` - Package: `@pipeworx/mcp-patents` - Version: `0.2.1` - Transport: `stdio` ## Trust breakdown How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog) Scored 2026-11-05. - **Supply Chain Security**: 100/100 - No malware found by supply-chain analysis. - No known CVEs affecting this package version or its production dependencies. - No install/post-install scripts declared. - No production dependencies, so there is no dependency health to assess. - **Provenance & Transparency**: 97/100 - Source repository is publicly reachable at the declared URL. - Cryptographically verified build provenance (signed, bound to pipeworx-io/mcp-patents). - Clear OSI-approved license (MIT). - Actively maintained (last published 1 days ago). - Disclosure check failed: no security disclosure policy was found in the source repository. - **Schema Quality & AI Usability**: 59/100 - AI-judged instruction clarity (excellent). - Context-footprint check failed: tool/resource definitions use about 3502 tokens (~500/item across 7 items; 7 tools + 0 resources), over budget; trim descriptions and params. - Usage-examples check failed: none of the tools include examples. - **Stability & Change Management**: 23/100 - Stability observed for 7 of 30 days with no destabilising changes; credit accrues until the full window elapses. - **Tool Coverage**: 100/100 - 100% of tools have a non-trivial description (not blank, and not just the tool's name). - 100% of tool parameters carry a description. - Structured output schemas are declared (57% of tools); any adoption earns full credit. - **Tool Safety**: 100/100 - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured. - We read all 7 captured tool definition(s), and no name or description among them implies an irreversible operation. - An AI judge read all 8 captured unit(s) of tool text and found none that tries to manipulate the model reading it. - **Capabilities**: 100/100 - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28. ## Install ### How do I install the Patents MCP server? Patents runs locally as an npm package, launched with npx -y @pipeworx/mcp-patents. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation. ### Claude ```bash claude mcp add pipeworx-io-patents -- npx -y @pipeworx/mcp-patents ``` ### Cursor ```json { "mcpServers": { "pipeworx-io-patents": { "command": "npx", "args": [ "-y", "@pipeworx/mcp-patents" ] } } } ``` ### VS Code ```json { "servers": { "pipeworx-io-patents": { "command": "npx", "args": [ "-y", "@pipeworx/mcp-patents" ] } } } ``` ### Codex ```bash codex mcp add pipeworx-io-patents -- npx -y @pipeworx/mcp-patents ``` ### opencode ```json { "$schema": "https://opencode.ai/config.json", "mcp": { "pipeworx-io-patents": { "type": "local", "command": [ "npx", "-y", "@pipeworx/mcp-patents" ], "enabled": true } } } ``` ### OpenClaw ```bash openclaw mcp add pipeworx-io-patents --command npx --arg -y --arg @pipeworx/mcp-patents ``` ### Hermes ```yaml mcp_servers: pipeworx-io-patents: command: "npx" args: ["-y", "@pipeworx/mcp-patents"] ``` ### Netclaw ```json { "McpServers": { "pipeworx-io-patents": { "Transport": "stdio", "Command": "npx", "Arguments": [ "-y", "@pipeworx/mcp-patents" ] } } } ``` ### Vellum ```bash assistant mcp add pipeworx-io-patents -t stdio -c npx -a -y @pipeworx/mcp-patents ``` ### Other ```json { "mcpServers": { "pipeworx-io-patents": { "command": "npx", "args": [ "-y", "@pipeworx/mcp-patents" ] } } } ``` ## Changelog Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims. ### 2026-11-04 (score 81, +1) - [functional] Package version: 0.2.0 → 0.2.1 ### 2026-11-02 (score 80, +1) No change was recorded against any check on this day. Stability & Change Management went from 10 to 13. That category is still filling its 30-day observation window: 3 days of observed history at the previous scan, 4 at this one. The score rises as the window fills, whether or not the server changes. ### 2026-10-31 (score 79, +1) No change was recorded against any check on this day. Stability & Change Management went from 3 to 7. That category is still filling its 30-day observation window: 1 days of observed history at the previous scan, 2 at this one. The score rises as the window fills, whether or not the server changes. ### 2026-10-29 (score 78) First indexed and scored. ## MCP tools (7) ### `search_patents` (~1642 tokens) Search USPTO patent applications and grants — **without a `granted_after`/`granted_before` bound this returns the APPLICATION corpus sorted newest-FILED-first, not issued patents.** USPTO publishes an application ~18 months after filing and typically takes 2+ years to grant it, so the newest rows in an unfiltered search are always recent, unexamined filings with `grant_date: null` — that is expected, not stale data. **Pick the date field on the QUESTION'S VERB, not on the word "recent":** a question asking who has FILED / applied for / sought patents in a window wants `filed_after`/`filed_before` — the default application corpus already includes pending AND granted patents, so no `granted_after` is needed or wanted, and adding one will silently drop recently-filed-but-not-yet-examined applications (grant lags filing by 2+ years, so "filed in the last 3 years" AND "granted in the last 3 years" are mostly DISJOINT sets). Only use `granted_after`/`granted_before` when the question explicitly says GRANTED / ISSUED / APPROVED / "has a patent" (not just "recent patents"). Use `query` for free-text keywords ("lithium battery", "crispr", "machine learning"); all terms are required (AND), and you can quote a phrase to keep it together. A curated, short list of known synonym/abbreviation pairs for concepts that patents describe inconsistently (e.g. cfRNA / cell-free RNA / circulating RNA; MRD / minimal residual disease / residual cancer) is recognized in `query` — quoted or bare — and expanded to an OR group before the search runs, so "cfRNA" and "cell-free RNA" are treated as the same concept rather than requiring the caller to guess a specific patent's exact wording (marked `synonyms_expanded: true` in the response; this is a fixed, documented list, not general synonym invention). A question that names several DISTINCT ways of describing the same idea (e.g. a condition plus a detection method, each expressed as its own quoted phrase) should still be passed as one query — i… Input parameters: - `_apiKey` (string): USPTO ODP API key. Get free at https://data.uspto.gov/myodp. Falls back to platform key if configured. - `applicant` (string): Optional. Company applicant name as it appears on the USPTO filing. This is also how to list the patents a company OWNS or holds ("patents assigned to X", "X's patents", "patents owned by X"): set `a… - `filed_after` (string): Optional. Filter to patents FILED on/after this date (ISO YYYY-MM-DD). Use this for "who has filed / applied for patents on X (recently / in the last N years)" — it covers both pending applications a… - `filed_before` (string): Optional. Filter to patents FILED on/before this date (ISO YYYY-MM-DD). - `granted_after` (string): Optional. Filter to patents GRANTED (issued) on/after this date (ISO YYYY-MM-DD) — use ONLY when the question explicitly says GRANTED / ISSUED / APPROVED, not for a plain "recent patents" or "who has… - `granted_before` (string): Optional. Filter to patents GRANTED (issued) on/before this date (ISO YYYY-MM-DD). Accepted synonym: `issued_before`. - `inventor` (string): Optional. Inventor name as recorded on the filing; a last name matches most reliably. Examples: "Hinton", "Bengio". Accepted synonyms: `inventor_name`, `author`. - `limit` (number): Number of results to return (default 10). USPTO caps every search at 25 records, so values above 25 have no effect — use the filters to narrow instead. - `number` (string): Optional. A specific US application number, digits only or formatted — "16123456" or "16/123,456". Accepted synonyms: `application_number`, `patent_number`. - `query` (string): Free-text keywords. Every term must appear (they are AND-ed), so add words to narrow and remove words to widen. Wrap words in double quotes to require them adjacent: `"machine learning" model` needs… - `title` (string): Optional. Words that must appear in the invention title, which narrows far harder than `query` does since `query` searches the whole record. Example: "solid state battery". ### `get_patent` (~525 tokens) Fetch a single USPTO patent application/grant by application number (`number`, e.g. "16/123,456" or "16123456") or by an already-granted patent number (`patent_number`, e.g. "11646472") — pass whichever one you actually have. Returns full metadata: title, inventors, classifications, status, and — when the application has been granted — `patent_number`, `grant_date`, `publication_number`, `publication_date`. **8-digit application numbers and 8-digit patent numbers can be the SAME digit string for a different record** (application series codes 10-12 were used ~2003-2008, and granted patent numbers entered that same 10,000,000-12,999,999 range in 2018 and are still in it) — e.g. "11646472" is BOTH application 11/646,472 (a 2006 filing) AND patent 11,646,472 (a 2023 grant), two unrelated inventions. If you only pass `number` and it is an 8-digit value in that collision range, this tool checks BOTH interpretations; if both exist, it returns `ambiguous: true` with each record summarized rather than silently guessing — re-call with `number` for the application or `patent_number` for the patent. Passing `patent_number` explicitly always skips the ambiguity check. A `status` of "Patented Case" with `patent_number: null` means USPTO ODP omitted that field for this record (check `patent_number_warning`), not that the patent was never granted; a pending application correctly has `patent_number: null`, `grant_date: null`. Input parameters: - `_apiKey` (string): USPTO ODP API key. Get free at https://data.uspto.gov/myodp. - `number` (string): An application number, digits only or with slashes (e.g. "16123456", "16/123,456"). If this happens to also be a valid 8-digit granted patent number (see the collision note above), the response may c… - `patent_number` (string): An already-granted US patent number, digits only (e.g. "11646472", "10000000"). Use this instead of `number` whenever you specifically mean the patent, not the application — it is never ambiguous. ### `search_inventors` (~218 tokens) Search USPTO patent applications by inventor last name. Returns matching applications with title, inventor list, and filing date — sorted newest-filed-first, so this is the APPLICATION corpus (same as search_patents with no `granted_after`), and the newest rows will be unexamined filings with no grant date by construction (USPTO publishes ~18 months after filing). That is expected, not stale data. For a specific inventor's ISSUED patents, use search_patents with `inventor` + `granted_after` instead. Input parameters: - `_apiKey` (string): USPTO ODP API key. Get free at https://data.uspto.gov/myodp. - `limit` (number): Number of results to return (default 10). USPTO caps every search at 25 records, so values above 25 have no effect — use the filters to narrow instead. - `query` (string, required): Inventor last name to search for (case-insensitive). Examples: "Hinton", "Bengio". ### `get_patent_assignments` (~138 tokens) Retrieve USPTO-recorded assignment/conveyance history for one patent application from the migrated Open Data Portal endpoint. Returns assignors, assignees, execution/recording dates, conveyance text, and reel/frame. A recorded assignment is notice of a submitted instrument—not a legal opinion on present title, validity, scope, liens, or chain-of-title completeness. Input parameters: - `_apiKey` (string): USPTO ODP API key. Get free at https://data.uspto.gov/myodp. - `application_number` (string, required): US patent application number, digits only or formatted, e.g. "15/000,001". Output parameters: - `application_number` (string) - `assignments` (array) - `count` (number) - `interpretation` (string) - `source` (string) ### `get_patent_transactions` (~210 tokens) Fetch the full USPTO prosecution/transaction history for one patent application — every dated event the Office recorded against the case (filings, mailings, fee payments, office actions, notices, the grant itself), newest first. This is a superset of the handful of events `get_patent` surfaces: use this tool when the question is about the PROSECUTION HISTORY itself (how many office actions, when was it mailed, when did examination start) rather than just the current status. Input parameters: - `_apiKey` (string): USPTO ODP API key. Get free at https://data.uspto.gov/myodp. - `limit` (number): Maximum number of events to return, newest first (default 50). The full history is usually under 100 events; a `note` in the response says when more exist than were returned. - `number` (string, required): US application number, digits only or formatted. Examples: "18926509", "16/123,456". Output parameters: - `application_number` (string) - `events` (array) - `returned` (number) - `source` (string) - `total` (number) ### `get_patent_continuity` (~192 tokens) Fetch the parent/child continuity (priority) chain for one patent application — every earlier application this one claims priority from (continuation, divisional, CIP, provisional, etc.) and every later application that in turn claims priority from it, each with the claim type, dates, and the parent/child's own patent number where granted. Use this to answer "what did this patent come from" or "what later patents/applications descend from this one". An application with no continuity relationships returns an empty chain on both sides — that is a real, common answer (most applications are standalone filings), not a failure. Input parameters: - `_apiKey` (string): USPTO ODP API key. Get free at https://data.uspto.gov/myodp. - `number` (string, required): US application number, digits only or formatted. Examples: "17248024", "16/123,456". Output parameters: - `application_number` (string) - `child_count` (number) - `children` (array) - `parent_count` (number) - `parents` (array) - `source` (string) ### `search_patent_assignments` (~525 tokens) Search USPTO-recorded patent assignment/conveyance history by assignee, assignor, a granted patent number, or an application number — one of the four is required. Unlike `get_patent_assignments` (which needs an application number you already have), this answers "what has company X been assigned" or "who assigned patent Y". An `assignee`/`assignor` search returns one row per recorded assignment (reel/frame, conveyance, dates, the other party) and additionally resolves the covered property (application/patent number, title) for each one it returns via a follow-up lookup — capped by `limit` because each one is a separate upstream call. A `patent_number`/`application_number` search returns the full assignment chain for that one property directly. An assignee/assignor with no recorded assignments returns a plain zero with the upstream total, not an error — USPTO assignment coverage is uneven for older or never-assigned properties. Individual (non-corporate) assignee addresses are omitted; company addresses are kept. Powered by the USPTO Assignment Search system (public, no account or key required). Input parameters: - `_apiKey` (string): Not used by this tool — USPTO Assignment Search is keyless. Present only for schema parity with the other tools in this pack. - `application_number` (string): A US application number, digits only or formatted. Example: "15000001", "15/000,001". - `assignee` (string): Company or person that RECEIVED rights in a recorded transfer (the recipient). Partial/substring match. Example: "Amyris". This lists recorded transfers into the party (one row per transfer, at most… - `assignor` (string): Company or person who assigned rights AWAY in a recorded transfer (the inventor or prior owner). Partial/substring match. Example: "Musk" - `limit` (number): Maximum assignment records to return (default 10, max 25). For an assignee/assignor search this also bounds the number of follow-up property lookups, so a higher limit costs more upstream calls. - `patent_number` (string): A granted US patent number, digits only. Example: "10000000". Output parameters: - `assignments` (array) - `query` (object) - `returned` (number) - `source` (string) - `total` (number) ## Diagnostics Captured diagnostic sections: Provenance, Dependencies. The full working is on the page: https://verifymcp.io/servers/pipeworx-io-patents/pipeworx-mcp-patents#diagnostics ## Score history - 2026-11-05: 81 - 2026-11-04: 81 - 2026-11-03: 80 - 2026-11-02: 80 - 2026-11-01: 79 - 2026-10-31: 79 - 2026-10-30: 78 - 2026-10-29: 78 ## Common questions ### What is the Patents MCP server? Patents is an MCP server listed in the public MCP registry as io.github.pipeworx-io/patents. Patents MCP, wraps the USPTO Open Data Portal (ODP) Patent File Wrapper API. This page covers its npm package (@pipeworx/mcp-patents). ### Is the Patents MCP server safe to use? Patents scores 81 out of 100 on VerifyMCP. We found no known CVEs affecting it as of 5 November 2026. It declares no install or post-install scripts. Its build provenance is signed and verified. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm. ### What tools does the Patents MCP server expose? Patents exposes 7 tools: search_patents, get_patent, search_inventors, get_patent_assignments, get_patent_transactions, and 2 more. Their descriptions and schemas cost roughly 3,450 tokens of context every time the server is loaded. ### Is the Patents MCP server still maintained? Patents is still listed as active in the MCP registry. We last reached this channel on 5 November 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced. ### What licence is the Patents MCP server under? Patents declares the MIT licence, which is OSI-approved. That covers the source only, and says nothing about the cost of any service it calls. ### What did VerifyMCP test on the Patents MCP server? VerifyMCP ran 16 checks on Patents, covering Malware scan, Known CVEs, Install scripts, Dependency health and 12 more. Endpoint Security and Transport & Reachability do not apply to an npm package, so they were not tested. The score does not measure everything, and the scoring documentation lists what it leaves out. ## Links - npm package: https://www.npmjs.com/package/@pipeworx/mcp-patents - Socket report: https://socket.dev/npm/package/@pipeworx/mcp-patents - Repository: https://github.com/pipeworx-io/mcp-patents - Website: https://pipeworx.io/packs/patents - Changelog RSS feed: https://verifymcp.io/servers/pipeworx-io-patents/pipeworx-mcp-patents.xml - Changelog JSON feed: https://verifymcp.io/servers/pipeworx-io-patents/pipeworx-mcp-patents/changelog.json - Trust report (JSON): https://verifymcp.io/servers/pipeworx-io-patents/pipeworx-mcp-patents.json - HTML version of this page: https://verifymcp.io/servers/pipeworx-io-patents/pipeworx-mcp-patents