Ein Model Context Protocol (MCP)-Server, der die DataCite REST API umschließt und Claude sowie anderen MCP-Clients schreibgeschützten Zugriff auf DataCites Index von über 125 Millionen Forschungs-DOIs gewährt. Es ist kein API-Schlüssel erforderlich. Der Server läuft als lokaler stdio-Prozess und kommuniziert mit Claude Desktop über das MCP-Protokoll, was natürlichsprachliche Abfragen gegen den gesamten DataCite-Katalog ermöglicht: Suchen nach Schlagwort, Person, Geldgeber oder Repository; Abrufen vollständiger Metadatensätze; und Erkunden von Beziehungen zwischen Forschungsergebnissen.
Fügen Sie Folgendes zu Ihrer claude_desktop_config.json hinzu (zu finden unter ~/Library/Application Support/Claude/claude_desktop_config.json auf 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 buildUm den Server interaktiv zu untersuchen:
npm run inspectorTool | Beschreibung |
| Volltextsuche im DataCite-Index von über 125M+ DOIs mit Filtern für Ressourcentyp, Geldgeber, Jahr, Repository und mehr. Unterstützt cursorbasierte Paginierung. |
| Abrufen vollständiger Metadaten für eine einzelne DOI. Akzeptiert jedes gängige DOI-Format (nackt, URL, |
| Formatieren einer DOI als formatierte Zitationszeichenfolge. Unterstützt APA, MLA, Chicago, Harvard, IEEE, Vancouver, BibTeX und CSL JSON. |
| Abrufen von Aufruf-, Download- und Zitationszahlen für eine DOI. Optional inklusive Zeitreihen-Arrays. |
| Erkunden des Beziehungsdiagramms für eine DOI — Zitate, Referenzen, Versionen und Teile. |
| Finden aller DOIs, die mit einem Forscher verknüpft sind, über ORCID iD oder Name. |
| Durchsuchen von DataCite-Mitglieds-Repositories (Clients) mit optionaler Suche und Filterung. |
| Abrufen des rohen DataCite-Metadatenschema-XML für eine DOI (base64-dekodiert). |
Prompts sind vorgefertigte Workflows, die über das Prompt-Menü von Claude Desktop aufgerufen werden können (⌘K → "Use a prompt").
Prompt | Argumente | Beschreibung |
|
| Finden der 10 relevantesten DataCite-Datensätze für einen Ressourcentyp und ein Fachgebiet. Gibt eine rangierte Tabelle mit Repository/Jahr-Beobachtungen und einem vorgeschlagenen Folgeschritt zurück. |
|
| Vollständiger Bericht zur Metadatenqualität und Aktivität für ein Repository. Geben Sie einen gebräuchlichen Namen wie |
|
| Forscherprofil aus DataCite-Datensätzen. Geben Sie eine ORCID iD ( |
Ressourcen-URI | Beschreibung |
| Das vollständige kontrollierte Vokabular für |
| Alle DataCite-Mitgliedsanbieter (Organisationen). |
| Alle DataCite-Repository-Clients. |
| Vollständiger Metadatensatz für eine gegebene DOI als JSON. |
| Werke, die die gegebene DOI zitieren. |
| Werke, die von der gegebenen DOI zitiert werden. |
| Metadaten für einen spezifischen DataCite-Anbieter. |
| Metadaten für einen spezifischen DataCite-Repository-Client. |
Kopieren Sie .env.example nach .env und passen Sie sie bei Bedarf an. Alle Variablen sind optional — die Standardwerte funktionieren sofort.
Variable | Standardwert | Beschreibung |
|
| URL, die im HTTP User-Agent-Header enthalten ist |
| (leer) | Kontakt-E-Mail für den höflichen Pool von DataCite |
|
| Maximale API-Anfragen pro Sekunde |
|
| DOI-Cache-TTL (1 Stunde) |
|
| Such-Cache-TTL (5 Minuten) |
|
| Statische Daten-Cache-TTL (24 Stunden) |
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.