MCP · Connecting AI Models to Patent Data
What the Model Context Protocol does, why it matters for patent practice, and how patent-client-agents exposes eight IP data sources to Claude and ChatGPT as a concrete example.
Article published on 2 May 2026
Key insight: The Model Context Protocol (MCP) is an open standard that lets an AI assistant call external tools and data sources at runtime. Instead of asking the model to guess patent numbers, it queries a server that fetches the data directly from EPO, USPTO or JPO. Research and bibliographic tasks therefore rest on retrieved data rather than on the training cut-off.
By analogy: MCP is to a language model what the EP register web interface is to a patent practitioner. A clearly scoped access path to outside-world data, with defined inputs, defined outputs and a named source.
Why pure prompting falls short
A language model knows what was in its training data up to a cutoff date and nothing afterwards. Asking Claude or ChatGPT for the procedural status of an EP application, the grant date of a US patent, or the family members of a PCT application typically yields one of three answers: a hallucinated value, a polite reference to the cutoff, or a vague pointer to the official register; none of those answers is useful in practice.
The duty of evidence and fact-checking principles described in Duty of Evidence for AI Answers require every patent-related claim to be backed by a verifiable reference. Without tool access, all the model can do is invent plausible references, which is unusable in patent practice. MCP gives the model the real source and makes assembling the relevant context easier.
MCP does not remove hallucinations. Even an answer based on a tool result can still be misrepresented by the model: a wrong summary, a paraphrase that shifts meaning, two sources mixed together, a missing field. Human in the loop and human verification remain mandatory. The source to verify against is now present and one click away.
What MCP is
Anthropic released MCP as an open standard in November 2024. An AI assistant such as Claude Desktop or Claude Code (the host, the application you work in) can reach through a relay layer (the client) to a server that provides specific capabilities, e.g. a patent search on Espacenet. Since 2025, OpenAI (for ChatGPT) and Google (for Gemini) support it as well. A server written once is therefore reusable across multiple assistants.
An MCP server can expose three kinds of building blocks: tools (functions the model can invoke, such as search_patents), resources (read-only data sources the model can ingest as context), and prompts (pre-built instructions the user can pick). In a patent context, tools are the most important category, because they let the model fetch live data from an API instead of guessing.
The architecture mirrors the one described in AI Agents and Isolated Context: the assistant decides on its own when a tool is needed, calls it, receives the result, and continues. Unlike a traditional API call, the model does not see the source code; it sees a machine-readable description of the tool. Whether the model picks the right tool depends on that description alone.
Technical details: transport and protocol
MCP is built on JSON-RPC 2.0. It defines two transports: stdio for locally installed servers (the server runs as a process on the same machine as the host) and HTTP/SSE for remote servers. In 2025, Anthropic also described a pattern where the model executes tool calls not one by one but as a small code block that composes several calls at once. This saves tokens and allows more complex workflows in a single step (see "Code execution with MCP" in the sources).
A concrete example: patent-client-agents
Parker Hancock has been publishing the open-source project patent-client-agents (Apache 2.0) since 2025. It is a Python MCP server that surfaces eight IP data sources behind a unified interface.
| Data source | What it provides | API key needed? |
|---|---|---|
| Google Patents | Global search, full text, citations, families, PDFs | no |
| USPTO ODP | US applications, file wrapper, PTAB trials, petitions | yes (free) |
| USPTO PPUBS | Full-text search and document retrieval | no |
| USPTO Assignments | Ownership transfers, reel/frame | no |
| USPTO Office Actions | Office-action analytics, cited references | no |
| EPO OPS | EP patents, Inpadoc families, legal status, EP register | yes (free) |
| JPO | Japanese patents, examination history, PCT national phase | yes (free) |
| MPEP / CPC | USPTO examination guideline, classification | no |
The server can be used in three ways: as a plugin in Claude Code (a single configuration command), as a Python library via pip install patent-client-agents, or through the public demo at mcp.patentclient.com. The demo is rate-limited to 100 MB per day and 20 MB per minute per Google account, and is explicitly not intended for confidential client material.
What it enables in practice
Three examples, each phrased as the user might address the assistant:
- Procedural status and deadlines: "Pull the current procedural status of EP3812345, including pending deadline and the most recent submission." The assistant calls the EPO OPS server, fetches the register entry, summarises it, and provides the source as a link. Verifying the summary by opening the link stays with the practitioner.
- Family overview: "Show me the Inpadoc family for US10123456 with all members and their current legal status." Three tool calls (Google Patents for the patent number, EPO OPS for the family, several registers for legal status) produce a consolidated table.
- Office-action analytics: "Which arguments has USPTO examiner XY raised in the last twelve office actions in class G06N?" The USPTO Office Actions endpoint returns the raw data; the model condenses it into patterns and lists the application numbers.
Limits and caveats
- Confidentiality: the public demo must not be fed with client material. A local install of the MCP server alone is not enough; what matters is where the language model runs.*
- API calls remain external: even with a local install, tool calls still go to the external patent APIs (USPTO, EPO, JPO). The values transmitted are essentially patent numbers and classifications, which are not themselves confidential. Anyone sending additional content has to evaluate this against professional-conduct rules.
- Human in the loop stays mandatory: MCP does not cure hallucinations. A tool result is a reference; the model's condensation of it is not. Legal-status assessments, family interpretations, office-action strategy and every concrete statement have to be verified against the tool output and the original source, as described in the Duty of Evidence article.
- Picking the right tool: the model selects the correct tool only when its description is precise and no second tool sounds similar. With many MCP servers active in parallel, the model can confuse them. A few precisely described servers work better than many at once.
- Quotas: the free USPTO, EPO and JPO API keys come with daily quotas. A heavy research session can exhaust them, which is not a security issue but can interrupt the workflow.
Significance for patent practice
MCP connects a language model to structured IP data. Research, family, bibliographic and file-history tasks can be handed to the assistant, which retrieves the data and names the reference; until now they were consolidated by hand. Drafting and office-action work remains untouched, because that work happens on confidential content rather than public databases.
patent-client-agents is one of the first broadly scoped MCP server examples for IP data and builds on the long-established Python library `patent_client`. Further providers are to be expected, because the protocol is open and the effort to wrap a known API in a server is manageable. Many web interfaces of patent offices can be exposed as MCP servers in the same way.
Sources
* The processing of confidential content is subject to professional-conduct confidentiality requirements, among others. These can be met by a locally hosted model or, on a case-by-case basis, by a trusted or self-hosted cloud instance. This does not constitute legal advice.