AI Patent Search
The AI Patent Search MCP server provides patent intelligence tools for searching, analyzing, and monitoring patents using USPTO data. Key capabilities include:
Patent Data Retrieval
Fetch full patent dossiers (bibliographic data, claims, citations, family, classifications, examiner info)
Retrieve just claims (cheaper than a full dossier)
Access prosecution history (Office Actions, responses, amendments, IDS)
Look up examiner stats (art unit, allowance rate, average pendency)
AI-Powered Analysis
Analyze Office Actions to identify rejection grounds (102, 103, 112, etc.), cited prior art, and suggested response arguments
Generate per-claim element charts mapping claim elements to examiner-cited prior art
Get AI-suggested CPC codes from natural-language descriptions
Search & Discovery
Generate optimized Boolean search queries from natural-language descriptions
Execute multi-strategy patent searches (telescoping, onion-ring, faceted) against Google Patents
Find semantically similar patents
Retrieve backward/forward citations and patent families
Classification
Look up CPC code hierarchies
Get AI-suggested CPC codes with confidence rankings
Legal Intelligence
Check PTAB validity challenges
Look up district-court litigation and reverse-lookup by company
Check legal status, chain of title, and remaining patent term
Account Management
Check credit balance and subscription status
Provides tools for patent intelligence, prosecution history, Office Action analysis, citation lookups, family information, and CPC classification lookups, all powered by Google Patents.
patent-search-mcp-server
MCP (Model Context Protocol) server for the AI Patent Search Generator — patent dossiers, prosecution history, Office Action AI analysis, citation/family/CPC lookups, plus a legal-intelligence layer (PTAB validity challenges, district-court litigation, company-litigation lookup, legal status, chain of title, term) and a one-shot AI risk profile. All from USPTO public data. Works in Claude Code, Claude Desktop, Cursor, ChatGPT-with-MCP, and any other MCP-compatible client.
26 tools available.
Patent data:
dossier,claims,claim_chart,prosecution,prosecution_timeline,oa_analyze,examiner,attorney,entity_status,term,assignments,legal_status,pregrant_pub,query,search,similar,citations,family,cpc,cpc_suggest,balance.Legal intelligence (new):
challenges(PTAB validity challenges — who attacked the patent and did it survive),litigation(US district-court infringement suits — who sued whom),company_litigation(reverse lookup: all patent suits involving a company).
Prerequisites
Install the AI Patent Search Generator Chrome extension and sign in.
Generate an API key from the extension's Admin tab.
Node.js 18+ (only required for local installs;
npx-style configs don't need a local install).
Related MCP server: patents-mcp
Configure in Claude Code
Add to your MCP config (~/.claude/mcp.json or project-scoped .mcp.json):
{
"mcpServers": {
"patent-search": {
"command": "npx",
"args": ["-y", "patent-search-mcp-server"],
"env": {
"PATENT_SEARCH_API_KEY": "psg_live_..."
}
}
}
}Configure in Claude Desktop
Edit ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) or %APPDATA%\Claude\claude_desktop_config.json (Windows):
{
"mcpServers": {
"patent-search": {
"command": "npx",
"args": ["-y", "patent-search-mcp-server"],
"env": { "PATENT_SEARCH_API_KEY": "psg_live_..." }
}
}
}Configure in Cursor
Settings → MCP → Add Server. Same JSON shape as Claude Code.
Tools
balance
Return current credit balance + subscription status. Free. No arguments.
dossier
Full patent intelligence: bibliographic, claims, citations, family, classifications, similar documents, examiner stats — all bundled. 3 credits on fresh fetch; free on 24h cache hit.
{ "patentNumber": "US10867416B2" }prosecution
USPTO file-wrapper documents (Office Actions, responses, amendments, etc.) for a US patent. Free.
{ "patentNumber": "US10867416B2" } OR { "applicationNumber": "15912345" }oa_analyze
AI analysis of a USPTO Office Action — rejection grounds, cited prior art, suggested response arguments. First 5 analyses per application are free; subsequent analyses cost 1 credit each.
Two forms:
Auto-pick most recent OA:
{ "patentNumber": "US10867416B2" }Explicit doc:
{ "applicationNumber": "15912345", "documentId": "..." }
examiner
Examiner name, art unit, total applications, allowance rate, average pendency. Free.
{ "patentNumber": "US10867416B2" }query
Single optimized Boolean query string for manual paste into Google Patents. Does NOT execute. 1 credit.
{ "description": "foldable display with ultrasonic fingerprint sensor" }search
Executes a multi-query patent search against Google Patents server-side and returns ranked, deduplicated hits. 1 credit.
{
"description": "foldable display with ultrasonic fingerprint sensor",
"strategy": "telescoping",
"limit": 20
}Strategies: telescoping (3 queries, broad/moderate/narrow), onion-ring (layered), faceted (concept pairs).
similar
Google Patents' similar-documents ranking for a given patent. Free.
{ "patentNumber": "US10867416B2", "limit": 20 }citations
Backward + forward citations for a patent. Each citation flags whether it was examiner-cited. Free.
{ "patentNumber": "US10867416B2", "direction": "both" }direction: backward | forward | both (default).
family
Patent family — continuations, divisionals, foreign counterparts. Free.
{ "patentNumber": "US10867416B2" }cpc
CPC classification code lookup. Free. v1.0 covers all sections + ~80 common subclasses; subgroup descriptions land in v1.2.
{ "code": "H01M10/0525" }claims (new in v0.2.0)
Just the claims of a patent — much cheaper than dossier when you only need claim text. Free when the dossier is cached; 1 credit cold.
{ "patentNumber": "US10867416B2" }claim_chart (new in v0.2.0)
Per-claim element chart: decomposes each independent claim into discrete elements and maps each to examiner-cited prior art from cached Office Action analyses. Free when dossier is cached; 3 credits cold. Call oa_analyze first if you want fresh OA data included.
{ "patentNumber": "US10867416B2", "oaDocumentIds": ["optional-filter"] }cpc_suggest (new in v0.2.0)
Description → suggested CPC codes via AI. Returns 3–5 candidates ranked by confidence with reasoning. 1 credit; cached by description hash for 30 days. Curated dataset (~80 subclasses) — niche chemistry/biotech may miss.
{ "description": "lithium-ion battery thermal management with phase change materials" }Environment variables
Var | Required | Description |
| yes | API key minted from the extension's Admin tab. Format: |
| no | Override the API base URL. Default: |
Local development
git clone https://github.com/smythmyke/patent-search-mcp-server.git
cd patent-search-mcp-server
npm install
npm run build
# Point your MCP client config at the local build:
{
"command": "node",
"args": ["/absolute/path/to/patent-search-mcp-server/dist/index.js"],
"env": { "PATENT_SEARCH_API_KEY": "psg_test_..." }
}Security
Never commit
PATENT_SEARCH_API_KEYto source control.Revoke a leaked key from the extension's Admin tab.
Keys are SHA-256 hashed on the server; the raw key is shown only once at creation.
Errors
Invalid or missing PATENT_SEARCH_API_KEY— mint or rotate the key.Out of credits— purchase a credit pack from the extension's Tools tab.Rate limit exceeded— wait briefly and retry.
License
MIT
Available Tools
11 toolsbalanceA
Return the current credit balance and subscription status for the authenticated AI Patent Search Generator account. Use this before calling paid tools (dossier, oa_analyze, query, search) to verify credits are available.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, but the description fully conveys the read-only nature and the output (balance and subscription status). Lacks mention of rate limits or authentication specifics, but for a simple query this is sufficient.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, front-loaded with purpose. Every sentence adds value. No wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given zero parameters and no output schema, the description provides all necessary context: what it returns, when to use it, and why. Complete for an agent to invoke correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
No parameters exist, so the description correctly omits param details. Schema coverage is 100% trivially. No additional meaning needed.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Clearly states the verb 'Return' and the resource 'current credit balance and subscription status'. Distinguishes itself from sibling tools by specifying it is a read-only check before paid tools like dossier and query.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly instructs to use this tool before calling paid tools to verify credit availability. Provides clear context and alternatives by naming the paid tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
citationsA
Return backward and/or forward citations for a patent. Backward = patents this one cites (its prior art). Forward = patents that cite this one (downstream impact). Each citation includes whether it was examiner-cited (load-bearing on patentability) vs applicant-cited. Free. Lighter payload than dossier when you only need citation lists.
| Name | Required | Description | Default |
|---|---|---|---|
| patentNumber | Yes | Patent publication number (e.g. US10867416B2). | |
| direction | No | Which citation set to return. Defaults to 'both'. | both |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations present; description mentions it's free and includes citation types, but lacks detail on error handling, rate limits, or auth requirements.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Five well-structured sentences, front-loaded with purpose, each sentence adds meaningful information with no redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given simple tool with 2 params and no output schema, description covers purpose, parameters, and sibling comparison adequately; could mention output format briefly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema covers 100% of parameters; description adds value by explaining direction options (backward=prior art, forward=downstream impact) and citation types (examiner vs applicant).
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Clearly states it returns backward/forward citations for a patent, defines terms, and distinguishes from sibling 'dossier' by noting it's lighter.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides context by comparing to dossier and noting it's free, but does not give exhaustive when-not-to-use guidance for all siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
cpcA
Look up a Cooperative Patent Classification (CPC) code and return its section, class, subclass, and group context. Accepts any level of code — section letter (e.g. 'H'), class ('H01'), subclass ('H01M'), main group ('H01M10/00'), or subgroup ('H01M10/0525'). Free. v1.0 dataset covers all sections + ~80 common subclasses; subgroup-level descriptions land in v1.1.
| Name | Required | Description | Default |
|---|---|---|---|
| code | Yes | CPC code at any level (section, class, subclass, main group, or subgroup). |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the burden. It discloses coverage limitations (v1.0 vs v1.1) and the read-only nature. This adds value beyond the schema.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise, front-loaded with the purpose, and each sentence adds unique value. No redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a single-parameter tool with no output schema, the description covers purpose, input formats, output context, and limitations. It is sufficient for an agent to select and use correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description provides concrete examples of valid code formats (e.g., 'H', 'H01', 'H01M'), adding significant meaning beyond the schema's generic description. Schema coverage is 100%, but the examples enhance understanding.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool looks up a CPC code and returns its hierarchical context. It specifies the resource and verb, and distinguishes from sibling tools by focusing on classification lookup.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives clear input examples and notes the dataset version, implying when to use the tool. However, it does not explicitly contrast with siblings or state when not to use.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
dossierA
Fetch a comprehensive intelligence dossier for a patent by publication number. Returns bibliographic data (title, assignees, inventors, dates, legal status), independent claims, backward + forward citations, patent family, CPC classifications, examiner info, and similar documents. Costs 3 credits on a fresh fetch; subsequent calls within 24 hours read from cache and are free. The headline tool — most patent-analysis workflows start here.
| Name | Required | Description | Default |
|---|---|---|---|
| patentNumber | Yes | Publication number in canonical form (e.g. US10867416B2, EP3500001B1). Accepts loose input like '10,867,416' or 'us10867416' — the server normalizes. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Discloses caching and credit costs, but no annotations exist; missing information on rate limits, errors, or authentication requirements.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Every sentence adds value; starts with purpose, lists returns, explains costs, and positions tool. No wasted text.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Comprehensively lists returned data despite no output schema; lacks mention of error handling or detailed format, but sufficient for a fetch tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Adds value beyond schema by explaining input normalization ('Accept loose input...'), which standard schema description does not convey.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states 'Fetch a comprehensive intelligence dossier for a patent' and lists all returned data types, distinguishing it from sibling tools like 'citations' or 'family'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides clear cost and caching behavior, and identifies as 'headline tool' where most workflows start, but does not explicitly mention when to avoid using it or alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
examinerA
Get the assigned examiner's name, art unit, total applications handled, allowance rate, and average pendency for a US patent. Free. Useful for prosecution strategy and risk assessment.
| Name | Required | Description | Default |
|---|---|---|---|
| patentNumber | Yes | Patent publication number (e.g. US10867416B2). |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden. It lists the exact return fields and notes it's 'Free', which is helpful. It does not disclose any potential limitations like rate limits or data freshness, but overall it is transparent enough.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two concise sentences with no fluff. The first states the core function, the second adds key context (free and use case). Every sentence earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple tool with one parameter and no output schema, the description adequately explains the output fields and provides a use case. It could mention error handling or data source, but overall it is sufficiently complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema already provides a clear description for the single parameter 'patentNumber' with an example. The tool description does not add further parameter details, so it meets baseline but does not exceed.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool retrieves specific examiner details (name, art unit, applications, allowance rate, pendency) for a US patent, with a clear verb 'Get' and resource. It distinguishes from sibling tools like 'citations' or 'prosecution' which cover different aspects.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly states it's 'Useful for prosecution strategy and risk assessment', providing a clear use case. However, it does not explicitly mention when not to use or suggest alternative tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
familyA
Return the patent family for a given patent — continuations, divisionals, and national counterparts (foreign equivalents). Useful for confirming worldwide IP coverage and identifying related applications still pending. Free.
| Name | Required | Description | Default |
|---|---|---|---|
| patentNumber | Yes | Patent publication number (e.g. US10867416B2). |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Without annotations, the description carries the full burden. It discloses the tool is read-only ('return') and specifies what the family includes, but does not mention authentication or rate limits. The 'free' note adds helpful context.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences: first states core function, second adds use case and freeness. No fluff, every word earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple one-param tool with no output schema, the description is complete: explains what family includes and why useful. No gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The sole parameter 'patentNumber' is fully described in the schema (100% coverage). The description adds no extra meaning beyond the schema example, so baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'Return the patent family for a given patent' with specific examples of included types (continuations, divisionals, national counterparts), distinguishing it from siblings like 'citations' or 'cpc'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description mentions it is 'useful for confirming worldwide IP coverage and identifying related applications still pending', which provides context but lacks explicit when-not-to-use or alternative tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
oa_analyzeA
AI-analyze a USPTO Office Action document to extract rejection grounds (102, 103, 112, etc.), cited prior art, and suggested response arguments. Two invocation forms: (1) pass only patentNumber and the server auto-picks the most recent Office Action for the patent; (2) pass both applicationNumber and documentId (from prosecution output) for explicit selection. First 5 analyses per application are free; subsequent analyses cost 1 credit each.
| Name | Required | Description | Default |
|---|---|---|---|
| patentNumber | No | Patent publication number — auto-picks the most recent OA for this patent. | |
| applicationNumber | No | Application number for explicit selection (used with documentId). | |
| documentId | No | Office Action document ID from prosecution-history output (used with applicationNumber). |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the burden. It discloses the analytical output, free tier, and credit cost. It does not mention potential AI variability or error scenarios, but the behavioral traits are adequately covered.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise (3 sentences) and well-structured: first sentence summarizes purpose, second details invocation forms, third covers pricing. No extraneous information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description covers purpose, invocation, and pricing adequately. It lacks explicit return value description, but output schema is not provided. For a tool with 3 parameters and no output schema, it is fairly complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% (baseline 3). The description adds value by explaining the two invocation patterns and the role of each parameter, such as auto-picking for patentNumber and explicit selection for applicationNumber/documentId.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function: AI analysis of USPTO Office Actions, extracting specific rejection grounds, prior art, and response arguments. It distinguishes itself from sibling tools by focusing on analysis rather than data retrieval.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly defines two invocation forms and refers to the 'prosecution' output for the explicit form, guiding usage. It includes pricing context but does not explicitly state when not to use the tool or compare directly to siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
prosecutionB
Retrieve the USPTO file-wrapper documents (office actions, responses, amendments, IDS, notices) for a US patent or application. Free. Returns each document's ID, mail date, category, and short description — IDs can be passed to oa_analyze for AI analysis.
| Name | Required | Description | Default |
|---|---|---|---|
| patentNumber | No | Patent publication number (e.g. US10867416B2). One of patentNumber or applicationNumber required. | |
| applicationNumber | No | USPTO application number (e.g. 15912345). One of patentNumber or applicationNumber required. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description carries burden. It states the tool is free and retrieves documents, but does not disclose data freshness, rate limits, or authentication requirements. Adequate for a read operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two concise sentences front-loading purpose and return values. No fluff, though a bit more structure could improve scannability.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Explains return fields and hints at chaining, but lacks mention of pagination, error handling, or comparison to similar tools. Adequate for a simple retrieval tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema has 100% description coverage. The description adds context ('for a US patent or application') and output usage hint, but does not provide new parameter details beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool retrieves USPTO file-wrapper documents for a US patent or application, listing document types. It is specific but does not explicitly differentiate from sibling tools like 'dossier' or 'citations'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives. It hints at chaining with 'oa_analyze' but lacks context on prerequisites or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
queryA
Generate a single optimized Boolean search query for Google Patents from a natural-language description of an invention or technology. Returns the Boolean string only — does NOT execute the search. Use search if you want ranked hits instead. Costs 1 credit.
| Name | Required | Description | Default |
|---|---|---|---|
| description | Yes | Natural-language description of the invention or technology area (e.g. 'foldable smartphone display with ultrasonic fingerprint sensor'). Minimum 10 characters. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, but description discloses that it does not execute search, returns only the Boolean string, costs 1 credit, and requires minimum 10 characters. Adequately transparent for a non-destructive tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Three sentences, front-loaded with purpose, no redundancy. Each sentence adds necessary information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple tool with one parameter and no output schema, the description covers purpose, usage hint, cost, and sibling differentiation completely.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with one parameter. Description adds natural-language context, example, and minimum character constraint, adding value beyond schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states the tool generates a Boolean search query for Google Patents, explicitly says it does not execute the search, and distinguishes from sibling 'search'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides clear guidance to use this for query generation and 'search' for ranked hits, plus mentions credit cost. Could be more explicit about when not to use, but sufficient.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
searchA
Execute a patent search against Google Patents server-side and return ranked hits. Given a natural-language description and a search strategy, the server: (1) extracts technical concepts, (2) generates Boolean queries per the chosen strategy, (3) runs each query against Google Patents, (4) dedupes results by publication number. Strategies: 'telescoping' (3 queries: broad/moderate/narrow — recommended default), 'onion-ring' (layered queries adding one concept at a time), 'faceted' (multiple two-concept pair queries). Costs 1 credit.
| Name | Required | Description | Default |
|---|---|---|---|
| description | Yes | Natural-language description of the invention or technology area (minimum 10 characters). | |
| strategy | No | Search strategy. Defaults to 'telescoping'. | telescoping |
| limit | No | Maximum number of deduplicated hits to return (default 20, max 100). |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description fully discloses the tool's behavior: it extracts concepts, generates Boolean queries per strategy, runs them, dedupes by publication number, and costs 1 credit. It adds useful context beyond just 'search', such as the internal workflow and cost.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured, front-loading the purpose and then detailing the process and strategies. It is relatively concise, though it could be slightly tighter. Every sentence adds value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given no annotations and no output schema, the description covers essential aspects: processing steps, strategies, cost, and parameter constraints. It is complete enough for the tool's complexity, though it could mention potential errors or when to use siblings.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Input schema coverage is 100%, so baseline is 3. The description adds meaning by explaining each parameter: 'description' as natural-language input, 'strategy' with three options and their meanings, and 'limit' as max hits. It enriches the schema descriptions, earning a 4.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: executing a patent search against Google Patents server-side, processing a natural-language description and strategy, and returning ranked hits. It distinguishes itself from sibling tools like 'query' by specifying the server-side processing and deduplication.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explains when to use the tool (for patent searches with natural language input) and details the processing steps and strategies. However, it lacks explicit guidance on when not to use it or direct comparison to alternatives like the 'query' sibling tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
similarA
Return Google Patents' 'similar documents' ranking for a given patent — a list of patents that Google considers technically related based on its own semantic models. Free. Distinct from search (which generates new queries from a description); this tool finds patents related to an existing one.
| Name | Required | Description | Default |
|---|---|---|---|
| patentNumber | Yes | Patent publication number (e.g. US10867416B2). | |
| limit | No | Maximum number of similar patents to return (default 20). |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Without annotations, the description carries full burden. It discloses the source (Google's semantic models) and cost (Free), but lacks details on error handling, ordering, or rate limits. For a simple retrieval tool, the transparency is adequate but not thorough.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, no fluff. The main action is front-loaded, and the sibling differentiation is placed naturally. Every sentence adds value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With 2 parameters fully described in schema, no output schema needed, and no annotations, the description covers the essential purpose, usage guidance, and a key incidental fact (Free). It could mention pagination or result structure, but overall it is complete for a simple tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so baseline is 3. The description adds no additional meaning beyond the schema; it mentions 'for a given patent' which maps to patentNumber, but this is already implied by the parameter name. No enrichment of the limit parameter.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description starts with a specific verb 'Return' and resource 'Google Patents' similar documents ranking for a given patent'. It clearly distinguishes from the sibling tool 'search' by contrasting inputs (existing patent vs. description query), making the purpose unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly states 'Distinct from search' and explains the alternative's behavior ('generates new queries from a description'), providing clear guidance on when to use this tool. The mention of 'Free' adds practical context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
11 tool updates
v0.1.0- First observed
balance - First observed
citations - First observed
cpc - First observed
dossier - First observed
examiner - First observed
family - First observed
oa_analyze - First observed
prosecution - First observed
query - First observed
search - First observed
similar
TDQS
Each tool serves a distinct and non-overlapping purpose, from checking credits (balance) to retrieving citations, classification, full dossier, examiner info, family, prosecution history, office action analysis, query generation, search execution, and similar patent finder. No two tools are ambiguous in their function.
Most tool names are single-word nouns (e.g., balance, citations, cpc) that cleanly describe their purpose. The only deviation is 'oa_analyze' which uses an underscore, but it's still clear and readable. Overall pattern is highly consistent.
With 11 tools, the server is well-scoped for the patent search and analysis domain. Each tool adds meaningful functionality without redundancy. The count is neither overwhelming nor insufficient.
The tool set covers the full spectrum of patent research: credit management, classification lookup, comprehensive dossier retrieval, citations, family, examiner details, prosecution history, office action analysis, query generation, search execution, and similar patent discovery. No obvious gaps are present.
Maintenance
Resources
Unclaimed servers have limited discoverability.
Looking for Admin?
If you are the server author, to access and configure the admin panel.
Related MCP Connectors
Real-time Amazon, WIPO & PACER data for AI agents — 19 tools via the MCP protocol.
MCP server for progressive tool usage at any scale (see https://klavis.ai)
Patent search, USPTO data, patent landscape & pgvector prior-art search for agents.
Related MCP Servers
- FlicenseNot gradedqualityDmaintenanceMCP server for USPTO patent prior-art search, enabling keyword search, ranking, and date filtering via Claude, Cursor, or Windsurf.-
- AlicenseAqualityBmaintenanceMCP server for patent search and prior art discovery powered by Google Patents public dataset on BigQuery. Supports searching patents, fetching full patent details with CPC codes and citations, and retrieving legal claims text.35MIT

novada-mcpofficial
AlicenseAqualityCmaintenanceOne MCP server. All web data. Search, scrape, crawl, proxy, and AI research — in a single npx command.342,4113MIT- AlicenseNot gradedqualityAmaintenanceAn MCP server that gives AI agents access to global patent data, including 1.4 billion records and Chinese full-text, with zero-config mode for basic tools.1MIT
Latest Blog Posts
- Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)By Om-Shree-0709 on .mcpAgent IdentityOAuth 2.1
- Your AI Chatbot Just Exposed Your CEO's Salary to an InternBy Om-Shree-0709 on .Agent IdentityMCP SecurityOAuth Delegation
- Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)By Om-Shree-0709 on .Agentic AiPrompt InjectionWebAssembly
MCP directory API
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/smythmyke/patent-search-mcp-server'
If you have feedback or need assistance with the MCP directory API, please join our Discord server