EUDAMED MCP
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@EUDAMED MCPFind the public EUDAMED record for primary UDI-DI 1234567890, including manufacturer and risk class."
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Independent, unofficial integration.
EUDAMED MCP
Search European medical-device records from your AI assistant.
Independent, unofficial integration · Read-only access · No API key required for the public endpoints tested
A read-only Model Context Protocol server for the European Commission's EUDAMED Public API. Search UDI records, verify economic operators, decode classification and status values, and investigate a device without losing the distinction between a public record and verified conformity evidence.
Start with a company name, device name or UDI. Find candidate records, identify the registered manufacturer and build an evidence checklist with source links and explicit gaps.
5 tools · 3 guided workflows · 5 readable resources
Get started · Example requests · How evidence works · Official EUDAMED portal
What makes it useful
Identity before interpretation. Preserve leading zeroes in UDIs, apply exact matching locally, and keep multiple candidates visible.
Find the actual manufacturer. A supplied SRN can belong to another company in the same group. Investigation searches device identity independently and follows the manufacturer SRN in the returned record.
Evidence you can trace. Results carry the exact source query, original retrieval timestamp, API version, cache status and local limits.
Honest gaps. Missing flags remain unknown. Failed requests remain failures. IFUs, declarations and certificates remain unverified until obtained separately.
Small tool surface. Five tools expose the three verified API endpoints and a bounded investigation workflow. Prompts are also resources, so clients can read the procedures without invoking a slash command.
Conservative by default. Serialized requests, bounded retries, timeouts, response-size limits, short-lived caching and organizational-only actor data.
This is an independent integration, not an official European Commission product. Public registration does not independently establish product conformity. The server does not retrieve IFUs or certificates and does not issue a compliant/non-compliant verdict.
Related MCP server: clinicmarketiq-public-data
Install and connect
Requires Node.js 22 or later. Add this entry to your MCP client's server configuration:
{
"mcpServers": {
"eudamed": {
"command": "npx",
"args": ["-y", "@t4dhg/mcp-eudamed@0.1.1"]
}
}
}To build from source, run npm ci && npm run build in the checkout and configure node with the absolute path to dist/cli.js.
The server uses stdio. Standard output is reserved for MCP messages. No credentials or .env file are needed. Optional configuration is read from the process environment; .env files are not loaded automatically.
For programmatic use, import EudamedClient, investigate or createServer from the package. Importing the library does not start a transport:
import { EudamedClient, investigate } from '@t4dhg/mcp-eudamed';
const api = new EudamedClient();
const results = await api.devices({
primaryDi: 'YOUR_PRIMARY_UDI_DI',
exact: true,
});
const dossier = await investigate(api, {
manufacturerSrn: 'US-MF-000000001',
tradeName: 'YOUR_DEVICE_NAME',
});Try these requests
Find the public EUDAMED record for this Primary UDI-DI. Show the legal manufacturer, authorised representative, risk class and the exact source query.
I have a manufacturer SRN and a product name, but the manufacturer search is empty. Check whether the product is registered under a different legal entity.
Build an evidence checklist for this device. Separate what EUDAMED says from what still needs a controlled IFU, declaration or certificate.
Tools
Tool | Purpose | Main inputs |
| Search and normalize UDI records; optionally include raw device fields | At least one of |
| Verify one exact SRN with organizational fields only |
|
| Discover exact legal/abbreviated company-name candidates, with portal fallback |
|
| Retrieve code translations, optionally narrowed locally |
|
| Resolve candidate devices and operators, decode fields and expose evidence gaps | Device search fields; |
All tools advertise read-only, non-destructive, idempotent, open-world annotations. Tool errors return isError: true. Search tools provide JSON text and equivalent structuredContent. Investigation provides a concise report in text content and complete evidence in structuredContent (also including the report).
Search a device
{
"primaryDi": "YOUR_PRIMARY_UDI_DI",
"exact": true,
"limit": 10,
"language": "en",
"raw": true
}exact defaults to false for discovery. When true, every supplied filter is compared locally using trimmed, case-insensitive equality. Do not assume upstream partial-name matching; use exact known identifiers and inspect the returned evidence. Multiple filters are sent together; the observed upstream behavior is AND, but it is not a published contractual guarantee.
The device tool returns normalized identity, operators, decoded values, tri-state flags, intended-purpose status and unverified document checklists. Set raw: true to retain additional upstream device fields. The library's devices() method always returns validated raw device records.
Investigate a manufacturer mismatch
{
"manufacturerSrn": "YOUR_SUPPLIED_SRN",
"tradeName": "YOUR_DEVICE_NAME",
"maxDevices": 10,
"maxManufacturers": 3,
"maxRepresentatives": 3
}The workflow:
Query Primary DI first, then Basic UDI, then each supplied name/reference independently with exact local matching. A stale name cannot suppress an exact UDI result.
Look up the supplied actor and its returned device portfolio.
Use the strongest nonempty route as target candidates, record conflicts with other supplied fields, and preserve alternative route candidates. Read manufacturer SRNs from target candidates and inspect their actors and bounded portfolios.
Verify authorised representatives for the selected evidence records.
Decode reference values and list the controlled documents still unverified.
Return query provenance, failures, omitted counts and unknown upstream coverage.
targetEvidence contains only target candidates from the strongest nonempty identity route. portfolioEvidence contains other manufacturer records and must not be attributed to the target. evidence remains a compatibility alias for target evidence only. Manufacturer-only investigations have no target evidence.
searches retains each independent query. conflicts records supplied-versus-observed disagreements; alternativeCandidates retains other search-route matches. identityStatus distinguishes identifier matches, candidates, ambiguity, conflicts, not-found, unresolved and portfolio-only results. Multiple versions remain separate candidates; the server does not automatically choose the latest. Missing operator identities and unmatched actor lookups appear in unresolved.
status: "completed" means execution completed, not that identity, documents or conformity have been established. partial, timed-out and cancelled retain gathered evidence and its limits. The concise report lists target identity, decoded fields, evidence gaps, conflicts, failures, bounds and next documents needed. Detailed records remain available in structured output.
Prompts and resources
Each prompt takes a required query string containing known identifiers, names or the investigation question. Prompts supply procedures; they do not fetch data themselves.
Prompt | Workflow |
| Device identity, actual manufacturer, representatives and evidence gaps |
| Verify an operator and inspect its bounded returned portfolio |
| Prepare a document checklist while preserving unverified claims |
Readable resources:
eudamed://guides/searcheudamed://guides/evidenceeudamed://prompts/investigate_deviceeudamed://prompts/manufacturer_portfolioeudamed://prompts/conformity_evidence
Understand the evidence
Output | Meaning |
| Query and observation time; cached observations retain their original time |
| Records in this response, not a total registry count |
| Records left after local matching |
| Local output count and whether this response was locally capped |
| Registry coverage and individual-record freshness are not established |
| Raw numeric ID, translated label and resolved/unresolved status |
| Pages fetched, source page URLs and whether the query exhausted its continuation links |
|
|
|
|
| Explicitly unverified IFU, declaration and certificate evidence; no fabricated URLs |
Investigation | Failed steps, distinct from successful empty searches |
An empty search is evidence about that query. It is not proof that the device does not exist or is non-compliant. An ISO 13485 certificate addresses a quality-management system; it does not replace product-specific documentation. See the evidence workflow.
Configuration and bounds
Environment variable | Default | Range / purpose |
|
| HTTPS endpoint, without credentials, query or fragment |
|
| Version string such as |
|
| 1–120000; each request attempt including body reads |
|
| 1–50 pages per query; combined record cap 10,000 |
|
| 0–3 retries after the initial attempt |
|
| 0–86400000; device/actor response TTL |
|
| 0–86400000; reference response TTL |
|
| 1–50000000; streamed body cap |
Requests are serialized. The cache holds at most 32 validated responses and stores only projected actor data. References are joined using CODE + ID within the requested language. Redirects are rejected. GET retries apply to network failures, timeouts, HTTP 429 and 500/502/503/504. Retry-After is honored; a cooldown over 30 seconds ends the request instead of retrying early.
Device output defaults to 20 records (maximum 100), references to 100 (maximum 500). Investigation defaults to up to 10 records per identity query, 10 target records, 10 separate portfolio-context records, 10 alternative candidates, 3 discovered manufacturers and 3 representatives; maxima are 20 records per group and 5 operators per category. Representative lookups concern targets, or portfolio records when no target identity was supplied. The HTTP adapter rejects queries with over 10,000 combined records and follows only validated continuation links within the page cap. MCP output is capped at 250 KB; narrow the query or reduce limits if exceeded. These are local safeguards, not claims about upstream pagination. An investigation can perform multiple sequential requests and retries; deadlineMs limits the whole investigation (default 60000, maximum 300000), including queue waits, retries and body reads. MCP cancellation stops queued requests, active fetches and retry waits. Other requests remain usable. The library accepts { signal } as a separate request-options argument.
Development and verification
npm ci
npm run lint
npm run format:check
npm run typecheck
npm run test:coverage
npm run test:stdio
npm pack --dry-runUnit and MCP protocol tests are deterministic and use synthetic data. Built stdio checks verify transport initialization, discovery, resources and validation without live network access. Coverage gates include the adapter, investigation and MCP registrations.
Live checks are opt-in:
npm run test:live
EUDAMED_SMOKE_PRIMARY_DI=YOUR_KNOWN_UDI EUDAMED_SMOKE_ACTOR_ID=YOUR_KNOWN_SRN npm run test:liveThe first command verifies reference data. EUDAMED_SMOKE_LANGUAGE selects a reference language (default en); EUDAMED_SMOKE_EXPECT_LEGISLATION optionally asserts a known substring such as 2017/746 in the decoded legislation label. Supply both identifiers to exercise live device and actor lookups too. Live data can change; a failed check requires investigation rather than automatically rewriting fixtures. Payloads and actor contacts are not logged.
See CONTRIBUTING.md, API contract notes, and SECURITY.md.
API scope
Implemented: anonymous JSON GETs to /udi, /actors and /reference, verified against the live service on 14 October 2026. The DG SANTE API catalogue is the upstream reference.
Not implemented: certificate-portal scraping, IFU downloads, writes, bulk registry export or legal-rule evaluation. Pagination follows documented nextLink values. Rate limits, actual record freshness and uptime commitments remain unverified. This package covers the supplied public API integration scope, not every EUDAMED module.
MIT licensed.
Company discovery and full UDI inputs
Call eudamed_discover_actors with a company name. It queries legal and abbreviated names independently, deduplicates identical organizational projections and preserves distinct candidates. Confirm the country, role and legal identity before using a candidate SRN with eudamed_investigate. A company portfolio remains separate from a particular device's evidence.
The Data Lake requires an exact registered name in observed name queries. A shortened name can return no matches even when the public portal finds the company. Follow portalUrl in a browser for partial-name discovery, then verify the returned SRN with eudamed_actors. This server does not automatically browse the portal. Coverage and source details.
manufacturerSrn requires the form US-MF-000000001 (synthetic example), not a company name. actorId accepts economic-operator SRNs or four-digit notified body IDs. Validation checks syntax, not registration existence.
primaryDi also accepts a parenthesized GS1 UDI starting with (01) and a valid 14-digit GTIN, for example (01)00012345678905(10)TESTLOT. Only the DI is sent to the API; production identifiers are not query filters. identifier preserves the original input, extracted DI, recognized format and whether it changed. Invalid or ambiguous (01) fields are rejected. Raw DIs, including legacy identifiers, remain strings and are not padded or coerced. This is DI extraction, not validation of every UDI production field or a universal HIBCC/ICCBBA/barcode parser. See GS1 application identifiers.
Installation and workflow verification
npm run test:package packs the actual artifact, installs it into a clean temporary project, imports the library and exercises the installed executable over MCP stdio. It requires npm registry access for dependencies.
See maintenance for scheduled contract checks and handling API changes.
Independence and attribution
EUDAMED MCP is an independent, unofficial open-source project. It is not developed, commissioned, endorsed or supported by the European Commission, and is not affiliated with the European Commission.
The header reproduces the European Commission logo supplied by the EUDAMED portal, with an adjacent EUDAMED label. The logo remains the property of its respective owner and is not covered by this project’s MIT license.
EUDAMED is the European Commission’s European Database on Medical Devices. References to EUDAMED identify the public service this project integrates with; they do not imply official status or endorsement. For official information, visit the European Commission’s EUDAMED website.
Public database records do not independently establish a device’s conformity. This software provides research assistance, not a regulatory determination.
Available Tools
5 toolseudamed_actorsVerify an economic operatorARead-onlyIdempotent
Look up an exact actor SRN or four-digit notified body ID. Returns organizational identity, role, country and status; excludes personal names, addresses and contact details.
| Name | Required | Description | Default |
|---|---|---|---|
| actorId | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already cover read-only, idempotent and open-world behavior, so the description's value is in disclosing the shape of the result: identity, role, country, status, and importantly the exclusion of personal names, addresses and contact details. That exclusion is real context an agent cannot get from the annotations. Not found / empty-result behavior is left unstated.
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 filler. The lookup scope comes first and the return/exclusion clause second, which is the right order for an agent scanning for eligibility.
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 no output schema, the description usefully summarizes return fields and privacy exclusions, which is the main gap it needed to fill for a single-parameter read tool. Missing only edge-case behavior such as an unknown or malformed identifier.
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 0%, so the description carries the burden and does so reasonably: it explains that actorId is either an SRN or a four-digit notified body ID, which gives meaning to the regex pattern in the schema. It stops short of giving an example SRN or clarifying where to obtain one.
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?
States a specific verb ('look up') and resource ('actor'), and calls out the two accepted identifier types (SRN, four-digit notified body ID). The word 'exact' implicitly separates it from eudamed_discover_actors, but the sibling is never named, so differentiation is inferred rather than stated.
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?
'Exact' lookup implies this tool is for when you already hold a known identifier, and by contrast search-like intent belongs elsewhere. However, no alternative (e.g., eudamed_discover_actors) is named and there is no explicit when-not guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
eudamed_devicesSearch EUDAMED devicesARead-onlyIdempotent
Search public UDI records by at least one restrictive filter. Upstream name matching is not guaranteed to be partial; exact=true additionally matches every supplied filter locally. Returns normalized evidence and source provenance; raw=true adds original device fields. No exhaustive-coverage or conformity guarantee.
| Name | Required | Description | Default |
|---|---|---|---|
| raw | No | ||
| exact | No | Apply case-insensitive trimmed equality to every supplied filter. | |
| limit | No | Local output cap, not upstream page size. | |
| basicUdi | No | ||
| language | No | en | |
| primaryDi | No | ||
| reference | No | ||
| tradeName | No | ||
| deviceName | No | ||
| manufacturerSrn | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already cover safety (readOnly, idempotent, non-destructive, openWorld), and the description adds genuinely non-obvious traits: upstream name matching may not be partial, exact=true performs local equality matching, and results carry no exhaustive-coverage or conformity guarantee. That caveat set is exactly the kind of context annotations cannot express.
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?
Four dense sentences, front-loaded with the precondition and then the exact/raw/return semantics in priority order. No filler, though the wording is compressed enough that terms like "normalized evidence and source provenance" require a second read.
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 no output schema, the description steps in to describe the return shape (normalized evidence, provenance, optional raw device fields) and adds coverage/conformity disclaimers. Combined with annotations, an agent has enough to invoke it correctly; only the per-filter semantics remain thin.
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 only 20% across 10 parameters, so the description must compensate. It does explain the two behavior-changing toggles (exact does local equality, raw adds original device fields) that the schema leaves undocumented, but the seven identifier filters (basicUdi, primaryDi, reference, tradeName, deviceName, manufacturerSrn, language) remain unexplained and the phrase "restrictive filter" is never tied to specific fields.
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?
States a specific verb and resource ("Search public UDI records") plus the hard precondition of at least one restrictive filter. It clearly reads as a device search distinct from the actor/reference/investigate siblings, though it never names those siblings to sharpen the boundary.
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?
"By at least one restrictive filter" gives a real precondition for use, and the exact/raw notes hint at when to escalate to stricter or richer results. But there is no explicit guidance on when to choose this over eudamed_actors or eudamed_investigate, and no statement of which parameters actually count as restrictive filters.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
eudamed_discover_actorsDiscover company actorsARead-onlyIdempotent
Resolve a company name using exact legal and abbreviated name searches. Returns deduplicated organizational candidates, source observations and a public-portal link for partial-name discovery. Confirm legal entity, country and role before using its SRN; never invent or silently pick an ambiguous SRN.
| Name | Required | Description | Default |
|---|---|---|---|
| name | Yes | Registered legal or abbreviated company name. Data Lake matching is exact, not substring. | |
| role | No | ||
| limit | No | ||
| country | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already establish read-only, idempotent, open-world, non-destructive behavior. The description adds meaningful context beyond that: matching is exact rather than substring, results are deduplicated, source observations and a public-portal link are returned, and ambiguous SRNs must be resolved carefully. It does not mention rate limits or auth, but the annotation bar is lower here.
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 the core action and followed by return contents and a critical safety caution. Every sentence carries useful information, and there is no filler or repetition.
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 no output schema, the description usefully explains that results include deduplicated candidates, source observations, and a portal link. It also clarifies exact matching and the need to verify entity, country, and role before using an SRN. It remains incomplete around the limit parameter and role/country filtering, which are left to a mostly undescribed schema.
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 description coverage is only 25%, so the description needs to compensate. It reinforces the name parameter's exact-match semantics and mentions country/role confirmation, but it does not explain the role filter, the country format or filter behavior, or the limit parameter. It adds some semantic value but leaves clear parameter gaps.
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 states a specific verb and resource: resolving a company name into organizational candidates. It also explains the output types (deduplicated candidates, source observations, portal link), making the tool's purpose clear. It does not explicitly distinguish this discovery tool from the sibling eudamed_actors retrieval tool, so it falls short of a 5.
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?
It gives clear usage context: use exact legal or abbreviated name searches and confirm legal entity, country, and role before using an SRN. The warning against inventing or silently picking an ambiguous SRN is useful workflow guidance. However, it does not name alternatives such as eudamed_actors or eudamed_investigate, nor state when not to use this tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
eudamed_investigateInvestigate device evidenceARead-onlyIdempotent
Bounded device investigation: verify supplied manufacturer, search identifiers first and names separately, discover actual manufacturers, inspect portfolios and representatives, decode fields and list unverified documents. Separates target evidence from portfolio context, reports identity conflicts, and returns a concise report plus detailed JSON. Preserves failures, provenance and bounds. No certificate/IFU retrieval or conformity decision.
| Name | Required | Description | Default |
|---|---|---|---|
| basicUdi | No | ||
| language | No | en | |
| primaryDi | No | ||
| reference | No | ||
| tradeName | No | ||
| deadlineMs | No | Total investigation deadline including queued requests and retries. | |
| deviceName | No | ||
| maxDevices | No | ||
| manufacturerSrn | No | ||
| maxManufacturers | No | ||
| maxRepresentatives | No |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare read-only, idempotent, open-world and non-destructive, so the safety bar is low; the description still adds real behavior: a bounded execution deadline, separation of target evidence from portfolio context, identity-conflict reporting, preservation of failures/provenance/bounds, and a dual report/JSON response. It doesn't state rate limits or auth needs, but the added context is genuinely beyond the annotations.
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?
It is compact and front-loaded with the scoping phrase 'Bounded device investigation', but the body is a telegraphic pile of clauses ('decode fields', 'preserves failures, provenance and bounds') that reads as internal shorthand rather than guidance. Every clause is relevant, yet the noun-pile style hurts immediate comprehension.
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 11 parameters, zero required fields, 9% schema coverage and no output schema, the description needs to explain invocation preconditions. It does mention the return shape (concise report plus detailed JSON), which covers the missing output schema, but it never states that at least one identifier or manufacturer must be supplied, nor how the search paths combine — a material gap for a zero-required-parameter 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 description coverage is only 9% (only deadlineMs is documented), so the description must carry the load. It implicitly maps identifier params (basicUdi/primaryDi/reference) versus name params (tradeName/deviceName) via 'search identifiers first and names separately', and gestures at maxDevices/maxManufacturers/maxRepresentatives via portfolios and representatives, but it never explains the budget parameters, ranges, defaults, or how manufacturerSrn interacts with identifiers. Partial compensation only.
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 names a specific composite operation (verify manufacturer, search identifiers then names, discover manufacturers, inspect portfolios/representatives, decode fields, list unverified documents) on the device resource. It excludes conformity decisions and certificate/IFU retrieval, but never positions itself against eudamed_devices, eudamed_actors or eudamed_discover_actors, so an agent must infer why it should pick this composite tool over the narrower siblings.
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?
It gives intra-tool ordering guidance ('search identifiers first and names separately') and two explicit out-of-scope exclusions ('No certificate/IFU retrieval or conformity decision'). However, it never says when to call this instead of eudamed_devices or eudamed_discover_actors, so the alternative-selection decision is left implied.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
eudamed_referencesDecode EUDAMED reference valuesARead-onlyIdempotent
Fetch reference values by language, optionally filtering CODE and ID together. Local limit only; use CODE + ID as the join key, never ID alone.
| Name | Required | Description | Default |
|---|---|---|---|
| id | No | ||
| code | No | ||
| limit | No | ||
| language | No | en |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The annotations already declare this a safe, idempotent, read-only, open-world operation, so that bar is lower. The description adds behavior that the annotations do not cover: the limit is applied locally rather than server-side, and ID is only meaningful when joined with CODE. Both are non-obvious operational facts.
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?
It is two sentences with no filler, and the core action comes first, followed by the join-key warning. The trade-off is that the compression goes slightly too far, because 'Local limit only' is terse to the point of ambiguity.
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?
There is no output schema, so the description ought to say what comes back: for example, a list of code/ID/label reference pairs. Instead it explains only how to filter, not what the reference values look like or how they relate to the codes found in the sibling tools. Adequate but incomplete for a 4-parameter decode 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 description coverage is 0%, so the description has to carry the burden. It names all four parameters (language, code, id, limit), which is better than nothing, but it does not say that language is a two-letter lowercase code, that code is a string up to 200 characters, or what 'local limit' actually bounds. It covers the parameters without explaining them.
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 states a specific verb and resource: it fetches reference values, scoped by language, with optional CODE/ID filtering. That is enough to identify it as the decode/reference lookup. It does not, however, contrast itself with siblings such as eudamed_devices or eudamed_actors, so the agent must infer which tool resolves codes.
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?
It gives real usage guidance on how to combine parameters: filter CODE and ID together, never ID alone. That is a genuine constraint on invocation. However it never says when a caller should reach for this tool instead of a sibling, such as 'use this to resolve codes returned by eudamed_devices,' so the usage context is only implied.
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.
5 tool updates
v0.1.1- First observed
eudamed_actors - First observed
eudamed_devices - First observed
eudamed_discover_actors - First observed
eudamed_investigate - First observed
eudamed_references
TDQS
Scored across 5 tools
The five tools mostly target distinct operations: device search, exact actor lookup, actor name discovery, reference lookup, and bounded investigation. The main overlap is between eudamed_devices and eudamed_investigate, since investigation also searches devices, but the composite/multi-step scope is described clearly enough to distinguish them. Actor lookup versus actor discovery is well separated by exact-ID versus name-resolution intent.
All names use the eudamed_ prefix and snake_case, which is predictable. However, the set mixes noun-style resource names (eudamed_devices, eudamed_actors, eudamed_references) with action-style names (eudamed_discover_actors, eudamed_investigate), so the verb_noun convention is not fully consistent.
Five tools is well within the appropriate range for a focused public-data lookup server. Each tool covers a distinct slice of the domain, and the composite investigation tool avoids needing many narrow follow-up tools.
The surface covers device UDI search, actor lookup and discovery, reference values, and bounded investigation, which is solid for public EUDAMED exploration. The main explicit gaps are certificate/IFU/document retrieval, but the investigate tool acknowledges these limits so agents can recognize the boundary.
Maintenance
Related MCP Connectors
Manage products, EU Digital Product Passports, operator parties, and GS1 EPCIS supply-chain events.
Read-only EU e-invoice checks: VAT format, VIES, Peppol lookup. Returns evidence, no filing.
Keyless, read-only US public records for agents: SEC, FDA, enforcement, sanctions, market data.
Find governed AI capabilities and verify signed receipts. Read-only, no account.
Related MCP Servers
- AlicenseCqualityCmaintenanceEnables AI assistants to query ClinicalTrials.gov and PubMed for research evidence, and to compare regulatory document changes against internal files, with strict read-only access and no ability to modify or export data.5Apache 2.0
- FlicenseNot gradedqualityBmaintenanceEnables read-only access to public U.S. healthcare market-intelligence datasets, including catalogs, schemas, metadata, checksums, and artifact URLs. It supports CMOs, analysts, researchers, and AI agents in discovering and consuming governed market observations without patient-level data.-
- AlicenseNot gradedqualityBmaintenanceEnables local read-only retrieval and search across 27 global medical device regulatory knowledge hubs (NMPA/FDA/MDR/PMDA etc.) using four MCP tools, with zero credentials and no external network calls.1Apache 2.0
- AlicenseNot gradedqualityBmaintenanceEnables AI clients to query FDA medical-device data through public keyless APIs, including 510(k) clearances, predicates, MAUDE adverse events, recalls, warning letters, PMA approvals, registrations, and UDI records, with tools for postmarket health checks and raw FDA endpoint access.MIT