Un servidor del Protocolo de Contexto de Modelo (MCP) que envuelve la API REST de DataCite, brindando a Claude y a otros clientes MCP acceso de solo lectura al índice de más de 125 millones de DOI de investigación de DataCite. No se requiere clave de API. El servidor se ejecuta como un proceso stdio local y se comunica con Claude Desktop a través del protocolo MCP, permitiendo consultas en lenguaje natural contra el catálogo completo de DataCite: búsqueda por palabra clave, persona, financiador o repositorio; recuperación de registros de metadatos completos; y exploración de relaciones entre resultados de investigación.
Añada lo siguiente a su claude_desktop_config.json (ubicado en ~/Library/Application Support/Claude/claude_desktop_config.json en macOS):
{
"mcpServers": {
"datacite": {
"command": "node",
"args": ["/Users/[user_name]/Claude/projects/datacite/dist/index.js"]
}
}
}Related MCP server: OpenAIRE MCP Server
cd /Users/[user_name]/Claude/projects/datacite
npm install
npm run buildPara inspeccionar el servidor de forma interactiva:
npm run inspectorHerramienta | Descripción |
| Búsqueda de texto completo en el índice de más de 125 millones de DOI de DataCite con filtros por tipo de recurso, financiador, año, repositorio y más. Admite paginación basada en cursor. |
| Recupera metadatos completos para un solo DOI. Acepta cualquier formato de DOI común (sin formato, URL, prefijo |
| Formatea un DOI como una cadena de cita formateada. Admite APA, MLA, Chicago, Harvard, IEEE, Vancouver, BibTeX y CSL JSON. |
| Recupera recuentos de vistas, descargas y citas para un DOI. Incluye opcionalmente matrices de series temporales. |
| Explora el gráfico de relaciones para un DOI: citas, referencias, versiones y partes. |
| Encuentra todos los DOI asociados con un investigador mediante ORCID iD o nombre. |
| Explora los repositorios miembros (clientes) de DataCite con búsqueda y filtrado opcionales. |
| Obtiene el XML del esquema de metadatos de DataCite sin procesar para un DOI (decodificado en base64). |
Los prompts son flujos de trabajo preconstruidos invocables desde el menú de prompts de Claude Desktop (⌘K → "Use a prompt").
Prompt | Argumentos | Descripción |
|
| Encuentra los 10 registros de DataCite más relevantes para un tipo de recurso y área temática. Devuelve una tabla clasificada con observaciones de repositorio/año y una sugerencia de seguimiento. |
|
| Informe completo de calidad y actividad de metadatos para un repositorio. Pase un nombre común como "Zenodo" o "Dryad"; el prompt lo resuelve automáticamente a un client_id de DataCite. |
|
| Perfil de investigador a partir de registros de DataCite. Pase un ORCID iD ( |
URI del recurso | Descripción |
| El vocabulario controlado completo |
| Todos los proveedores miembros de DataCite (organizaciones). |
| Todos los clientes de repositorio de DataCite. |
| Registro de metadatos completo para un DOI determinado como JSON. |
| Trabajos que citan el DOI dado. |
| Trabajos citados por el DOI dado. |
| Metadatos para un proveedor de DataCite específico. |
| Metadatos para un cliente de repositorio de DataCite específico. |
Copie .env.example a .env y ajústelo según sea necesario. Todas las variables son opcionales; los valores predeterminados funcionan de inmediato.
Variable | Predeterminado | Descripción |
|
| URL incluida en el encabezado HTTP User-Agent |
| (vacío) | Correo electrónico de contacto para el grupo de cortesía de DataCite |
|
| Máximo de solicitudes a la API por segundo |
|
| TTL de caché de DOI (1 hora) |
|
| TTL de caché de búsqueda (5 minutos) |
|
| TTL de caché de datos estáticos (24 horas) |
Format a DOI as a citation string. Supports APA, MLA, Chicago, Harvard, IEEE, Vancouver, BibTeX, and CSL JSON styles.
| Name | Required | Description | Default |
|---|---|---|---|
| doi | Yes | ||
| style | No | apa | |
| locale | No | en-US |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided; description does not disclose behavior such as external API calls, error handling, or rate limits. The tool likely fetches metadata to format, but this is not stated.
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, the first states the purpose and the second lists supported styles. No fluff 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?
Given no annotations, no output schema, and 0% param coverage, the description is insufficient. It does not explain the output format, error scenarios, or whether the tool makes network calls.
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 must compensate. It partially describes 'doi' and 'style' (via the supported styles list) but completely omits 'locale'. Does not explain the format or validation for any 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?
Clearly states the action ('Format'), the resource ('a DOI as a citation string'), and lists supported citation styles (APA, MLA, Chicago, etc.). Differentiates from siblings like get_doi which retrieve metadata rather than format 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?
Implies usage when a citation string is needed for a DOI, but lacks explicit guidance on when to use this tool versus alternatives. No mention of prerequisites, limitations, or when not to use it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Retrieve complete metadata for a single DOI. Accepts any common DOI format (bare, URL, doi: prefix). Optionally includes the raw DataCite Schema XML.
| Name | Required | Description | Default |
|---|---|---|---|
| doi | Yes | ||
| include_xml | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Description implies a read operation but does not explicitly state idempotency, auth requirements, or side effects. With no annotations, the agent lacks clarity on safety.
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 the main purpose, and no redundant information. 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?
Covers the tool's core functionality and optional parameter. Lacks details on return structure or error handling, but for a simple retrieval tool with no output schema, it is adequately 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?
Adds meaningful context for the 'doi' parameter by noting accepted formats (bare, URL, doi: prefix), and for 'include_xml' by explaining it returns raw DataCite XML. Schema coverage is 0%, so description compensates well.
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 'Retrieve complete metadata for a single DOI', which is a specific verb+resource. Distinguishes from siblings like search_dois (search) and get_doi_metrics (metrics) by focusing on single DOI metadata 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?
No guidance on when to use vs alternatives. Only provides a tip on accepted DOI formats, but does not mention related tools or conditions for use.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Retrieve view, download, and citation counts for a DOI. Optionally include monthly time-series arrays.
| Name | Required | Description | Default |
|---|---|---|---|
| doi | Yes | ||
| include_time_series | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided; the description only outlines the action but does not disclose behavioral traits such as authentication requirements, rate limits, or whether counts are real-time. For a read operation, minimal guidance is given.
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?
Single sentence with clear front-loading of purpose. No redundant information; every word contributes.
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 output schema, the description omits return format and error conditions. It covers the core action but lacks completeness for an agent to fully understand the response structure.
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 adds meaning for include_time_series by mentioning 'monthly time-series arrays', but does not clarify the doi parameter beyond the name. With 0% schema coverage, it partially compensates.
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 it retrieves view, download, and citation counts for a DOI, with optional time-series. This is specific and distinguishes it from siblings like get_doi (metadata) and get_related_works.
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 explicit guidance on when to use versus alternatives like get_doi or search_dois. The description implies usage for metrics but lacks exclusions or context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Fetch the raw DataCite Metadata Schema XML for a DOI (base64-decoded). Useful for inspecting the complete, canonical metadata record.
| Name | Required | Description | Default |
|---|---|---|---|
| doi | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description must fully disclose behavior. It mentions that the output is 'base64-decoded' and 'XML,' but it does not address potential error states, authentication requirements, rate limits, or other side effects. This 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?
The description is two concise sentences that immediately convey the purpose. Every word serves a purpose, and there is no redundancy or unnecessary detail.
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 the tool's simplicity (single parameter, no output schema), the description adequately covers the return format and the decoding behavior. It could mention error handling or the structure of the XML, but overall it is sufficient for the tool's complexity.
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 provides the 'doi' parameter with no description (0% coverage). The description only repeats that it fetches for a DOI, adding no additional semantic guidance about format, constraints, or examples. More detail would help, such as the expected format or that it must be a valid DataCite DOI.
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 action ('Fetch') and the resource ('raw DataCite Metadata Schema XML for a DOI'), with a specific detail about base64-decoding. It distinguishes from sibling tools like get_doi or get_doi_metrics by focusing on the canonical XML record.
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 indicates the tool is 'useful for inspecting the complete, canonical metadata record,' providing clear context for its use. However, it does not explicitly state when not to use it or suggest alternatives, such as using get_doi for a different format.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Retrieve full metadata for a single DataCite repository (client) by its ID. Returns name, symbol, alternateName, clientType, isActive, re3data, opendoar, issn, prefixes, language, year, created, updated, and more. Pass includeStats:true to add doiCount (fetched via a secondary /dois call). Note: per-client view/download/citation counts are not exposed by the DataCite API.
| Name | Required | Description | Default |
|---|---|---|---|
| id | Yes | DataCite client ID (e.g. 'cern.zenodo', 'dryad.dryad'). Use list_repositories to discover IDs. | |
| includeStats | No | When true, adds doiCount fetched via /dois?client-id={id}&page[size]=0. Returns doiCount:null if the secondary call fails. Note: viewCount/downloadCount/citationCount are not available from the DataCite API. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Since no annotations are provided, the description fully explains behavior: it notes that includeStats triggers a secondary API call, that doiCount may be null if that call fails, and explicitly states limitations ('per-client view/download/citation counts are not exposed').
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 extremely concise, using only two sentences and a note. It is front-loaded with the core purpose and efficiently adds detail without 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 the tool's simplicity, the description covers all necessary aspects: what the tool does, how to use it, what data it returns, and limitations. The lack of an output schema is compensated by listing returned fields in the description.
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 has 100% coverage, so the baseline is 3. The description does not add significant meaning beyond what the schema already provides for both parameters, though it restates the purpose of includeStats.
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 action ('Retrieve full metadata'), the resource ('a single DataCite repository'), and the exact fields returned. It distinguishes itself from the sibling 'list_repositories' tool by focusing on a single repository by ID.
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 provides guidance on discovering IDs using 'list_repositories' and explains the optional 'includeStats' parameter. While it doesn't explicitly state when not to use this tool, the context is clear enough for an agent to decide.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Browse DataCite-registered repositories and data centers. Supports full-text search (Elasticsearch, matches name/alternateName/description) and filtering by clientType or providerId. Returns id, name, symbol, alternateName, clientType, isActive, re3data, prefixes, language, year, created/updated timestamps, and more. Pass includeStats:true to add doiCount (fetched via secondary /dois calls, one per result). Note: viewCount/downloadCount/citationCount are not available from the DataCite API and will not appear even when includeStats:true.
| Name | Required | Description | Default |
|---|---|---|---|
| query | No | ||
| clientType | No | repository | periodical | service | igsnCatalog | raidAgency | |
| providerId | No | ||
| includeStats | No | ||
| page_size | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description fully bears the transparency burden. It discloses that includeStats triggers secondary API calls, that certain count fields are unavailable, and describes the Elasticsearch-based full-text search behavior.
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 front-loaded with the main purpose and then details in a logical order. It is concise, covering essentials without unnecessary elaboration. A slight improvement could separate usage from behavioral notes, but overall effective.
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 output schema and moderate complexity (5 params), the description covers search, filtering, returned fields, stats limitations, and missing counts. It lacks explicit pagination behavior (e.g., how page_size works) but is otherwise thorough.
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 adds significant meaning beyond the schema: explains query matches name/alternateName/description, clarifies clientType values and filtering, describes providerId filtering, and details includeStats behavior and cost. With only 20% schema coverage, this is highly valuable.
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 it lists DataCite repositories and data centers with search and filtering. It specifies supported search and filtering options, distinguishing it from siblings like get_repository which likely handles single entities.
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 implicitly guides usage by detailing capabilities (search, filter) and limitations (missing counts, secondary calls for stats). It does not explicitly contrast with siblings but the context makes it clear this is for listing.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Find all DOIs associated with a researcher by ORCID iD or name.
| Name | Required | Description | Default |
|---|---|---|---|
| orcid | No | ||
| name | No | ||
| role | No | any | |
| resource_type | No | ||
| page_size | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided. The description does not disclose behavioral details such as pagination, default values, or that parameters like 'role' and 'resource_type' can filter results. It only mentions ORCID and name.
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 extremely concise (one sentence), but at the cost of omitting important details about multiple parameters and behavior. It is under-specified rather than efficiently concise.
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 5 parameters, no annotations, and no output schema, the description fails to provide sufficient context. It omits pagination, filtering capabilities, and the return format, leaving the tool's full functionality unclear.
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%. The description only explains 'orcid' and 'name' as search criteria, but does not clarify 'role', 'resource_type', or 'page_size'. This leaves the agent potentially unaware of available filters.
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 finds DOIs associated with a researcher by ORCID or name. It distinguishes from siblings like 'search_dois' (broader) and 'get_doi' (single DOI). However, it could be more precise about the scope.
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 implies a person-based search, but lacks explicit when-to-use or when-not-to-use instructions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search DataCite's index of 125M+ research DOIs. Supports full-text queries and filters by resource type, funder, year, repository, and more.
| Name | Required | Description | Default |
|---|---|---|---|
| query | No | ||
| resource_type | No | ||
| funder_ror_id | No | ||
| affiliation_ror_id | No | ||
| client_id | No | ||
| provider_id | No | ||
| prefix | No | ||
| published_year | No | ||
| sort | No | ||
| page_size | No | ||
| page_cursor | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided. The description mentions it indexes 125M+ DOIs, but lacks details on pagination, sorting defaults, rate limits, or auth requirements. Adequate for a search tool but incomplete.
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-loaded with purpose. No wasted words, but could be structured to list filters more clearly. Still, very efficient.
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, no output schema, and no description of return structure or pagination, the description is incomplete for an agent to use effectively. Lacks details on how to handle results beyond the search itself.
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 must compensate. It only names a few filters (resource type, funder, year, repository) but does not explain parameter specifics like format for affiliation_ror_id or curser usage. Insufficient for 11 parameters.
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 searches DataCite's index of DOIs, with specific capabilities like full-text queries and filters. It distinguishes itself from siblings like get_doi (single retrieval) and search_by_person (person 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?
The description implies usage for broad searches with filtering, but does not explicitly state when not to use it or list alternatives. However, the context of sibling tools makes the primary use case clear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
v0.4.0format_citationget_doiget_doi_metricsget_doi_schema_xmlget_related_worksget_repositorylist_repositoriessearch_by_personsearch_doisScored across 9 tools
Each tool has a clearly distinct purpose: formatting citations, retrieving metadata, metrics, schema XML, related works, repository info, listing, and searching by person or general query. No overlap in functionality.
All tool names follow a consistent verb_noun pattern (e.g., format_citation, get_doi, list_repositories, search_dois). The naming is uniform and predictable.
9 tools is well within the ideal range for a focused server. Each tool serves a specific purpose without redundancy, and the count feels appropriate for the scope of DataCite access.
The tool set covers all major read operations for DataCite DOIs: retrieval, search, metrics, citation formatting, schema, related works, and repository info. Minor gaps exist (e.g., no write/update operations, no per-repository stats), but these are consistent with a read-only API focus.
Search DataCite datasets and software, fetch DOI metadata, trace relations, format citations.
Search 150M+ academic works, journals, and funders via Crossref API.
Search and resolve Zenodo datasets, software, and publications by DOI; trace versions and funding.
Scholarly search: OpenAlex, Crossref, arXiv, OpenCitations and PubMed in one endpoint.