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., "@simple-dicom-mcp find studies for patient ID 12345"
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.
Repo credit: https://github.com/ChristianHinge/dicom-mcp
Minimal config (configuration.yaml):
nodes:
orthanc:
host: "localhost"
port: 4242
ae_title: "ORTHANC"
description: "Default Local Orthanc DICOM server"
aliases: ["local", "dev-orthanc"]
radiant:
host: "localhost"
port: 11112
ae_title: "RADIANT"
description: "Radiant Viewer Dicom Node"
aliases: ["viewer"]
current_node: "orthanc"
calling_aets:
default:
ae_title: "MCPSCU"
description: "Default calling AE"
calling_aet: "default"
query_root: "study"
allow_remote_hosts: false
network:
acse_timeout: 10
dimse_timeout: 30
network_timeout: 30
assoc_timeout: 10
max_pdu: 16384
retry:
max_attempts: 2
backoff_seconds: 1.0
backoff_multiplier: 2.0
backoff_max_seconds: 5.0
Start server (dev):
uv run --with-editable '.' -m dicom_mcp configuration.yamlIf uv caches old code: add --no-cache or --reinstall-package simple-dicom-mcp.
Related MCP server: DICOM MCP Server
{
"mcpServers": {
"DicomMCP": {
"command": "C:\\Windows\\System32\\wsl.exe",
"args": [
"--distribution",
"Ubuntu",
"--",
"bash",
"-lc",
"cd '/mnt/c/Users/paulo/Python Projects/simple-dicom-mcp' && uv run --with-editable '.' python -m dicom_mcp '/mnt/c/Users/paulo/Python Projects/simple-dicom-mcp/configuration.yaml'"
]
}
},
"globalShortcut": "",
"preferences": {
"menuBarEnabled": false
}
}WSL tips
Enable mirrored networking so localhost works for both Windows and WSL.
Use --with-editable '.' so your code changes are seen live.
Connection: list_dicom_nodes, switch_dicom_node, verify_connection
Registry: get_manifest
Query: query_patients, query_studies, query_series, query_instances, get_attribute_presets
Query tools return structured status metadata:
{
"success": true,
"results": [],
"dicom_statuses": [],
"warnings": [],
"error": null
}Find studies in a date range:
query_studies(study_date="20230101-20231231")Filter studies by patient attributes:
query_studies(patient_id="12345678", patient_sex="O", patient_birth_date="19700101")If uv doesn’t reflect code changes, add --no-cache or --reinstall-package simple-dicom-mcp.
On WSL/Windows, enable mirrored networking so localhost works across Windows and WSL.
MIT license (see LICENSE)
The simple-dicom-mcp server enables AI assistants to query and read data on DICOM servers (PACS, VNA, etc.).
🤝 Contributing guide • 🐞 Report bug • 🛟 Support • 🔐 Security
simple-dicom-mcp provides tools to:
🔍 Query Metadata: Search for patients, studies, series, and instances using various criteria.
⚙️ Utilities: Manage connections and understand query options.
Install using uv:
uv tool install simple-dicom-mcpOr by cloning the repository:
# Clone and set up development environment
git clone https://github.com/ThalesMMS/simple-dicom-mcp
cd simple-dicom-mcp
# Create and activate virtual environment
uv venv
source .venv/bin/activate
# Install with dev dependencies
uv pip install -e ".[dev]"simple-dicom-mcp requires a YAML configuration file (config.yaml or similar) defining DICOM nodes and calling AE titles. Adapt the configuration or keep as is for compatibility with the sample ORTHANC Server.
nodes:
main:
host: "localhost"
port: 4242
ae_title: "ORTHANC"
description: "Local Orthanc DICOM server"
aliases: ["local", "dev-orthanc"]
current_node: "main"
calling_aets:
default:
ae_title: "MCPSCU"
description: "Default calling AE"
calling_aet: "default"
query_root: "study"
allow_remote_hosts: false
network:
acse_timeout: 10
dimse_timeout: 30
network_timeout: 30
assoc_timeout: 10
max_pdu: 16384
retry:
max_attempts: 2
backoff_seconds: 1.0
backoff_multiplier: 2.0
backoff_max_seconds: 5.0
Notes:
calling_aet can be a name, alias, or AE title defined in calling_aets.
query_root accepts study or patient.
allow_remote_hosts defaults to false and blocks non-loopback DICOM hosts unless you explicitly opt in.
Simple DICOM-MCP is not meant for clinical use, and should not be connected with live hospital databases or databases with patient-sensitive data. Doing so could lead to both loss of patient data, and leakage of patient data onto the internet. If you intentionally need a remote PACS or VNA, setallow_remote_hosts: true only after reviewing the risk and using a private, trusted environment.
If you don't have a DICOM server available, you can run a local ORTHANC server using Docker:
Clone the repository and install test dependencies:
uv pip install -e ".[dev]"Start Orthanc and run tests:
cd tests
docker compose up -d
cd ..
uv run pytest -m integrationUI at http://localhost:8042
Add to your client configuration (e.g. claude_desktop_config.json):
{
"mcpServers": {
"dicom": {
"command": "uv",
"args": ["tool","simple-dicom-mcp", "/path/to/your_config.yaml"]
}
}
}For development:
{
"mcpServers": {
"simple-dicom-mcp": {
"command": "uv",
"args": [
"--directory",
"path/to/cloned/simple-dicom-mcp",
"run",
"simple-dicom-mcp",
"/path/to/your_config.yaml"
]
}
}
}simple-dicom-mcp provides five categories of tools for interaction with DICOM servers and DICOM data.
query_patients: Search for patients based on criteria like ID or birth date.
query_studies: Find studies using patient ID, date, modality, description, accession number, or Study UID.
query_series: Locate series within a specific study using modality, series number/description, or Series UID.
query_instances: Find individual instances (images/objects) within a series using instance number or SOP Instance UID
list_dicom_nodes: Show the currently active DICOM node, calling AE title, and list all configured nodes.
switch_dicom_node: Change the active DICOM node for subsequent operations.
verify_connection: Test the DICOM network connection to the currently active node using C-ECHO.
get_attribute_presets: List the available attribute presets (none, custom) for metadata query results.
get_manifest: Return the MCP tool contract manifest (required/optional tool versions).
The tools can be chained together to answer complex questions:
Read CONTRIBUTING.md before opening a pull request.
Use the issue forms for bugs and focused feature ideas.
Follow SECURITY.md for vulnerability reporting.
Use SUPPORT.md for setup/help guidance.
Do not post PHI, real DICOM studies, or live PACS credentials in issues or PRs.
Unit tests run without Orthanc; integration tests require a running Orthanc DICOM server. You can use Docker:
# Navigate to the directory containing docker-compose.yml (e.g., tests/)
cd tests
docker compose up -dRun unit tests using uv:
# From the project root directory
uv run pytest -m "not integration"Run integration tests using uv:
# From the project root directory
uv run pytest -m integrationStop the Orthanc container:
cd tests
docker compose downUse the MCP Inspector for debugging the server communication:
npx @modelcontextprotocol/inspector uv run simple-dicom-mcp /path/to/your_config.yaml --transport stdioSet LOG_LEVEL to control verbosity (e.g., DEBUG, INFO, WARNING):
LOG_LEVEL=DEBUG uv run simple-dicom-mcp /path/to/your_config.yaml --transport stdiouv run ruff check .
uv run ruff format .
uv run pyrightuv run pre-commit install
uv run pre-commit run --all-filesBuilt using pynetdicom
Get all available attribute presets for DICOM queries.
This tool returns the defined attribute presets that can be used with the query_* functions. It shows which DICOM attributes are included in each preset (none, custom) for each query level.
Returns: Dictionary organized by query level (patient, study, series, instance), with each level containing the attribute presets and their associated DICOM attributes.
Example: { "patient": [ "PatientID", "PatientBirthDate", "PatientSex", "PatientAge", ], "study": [ "StudyInstanceUID", "PatientID", "AccessionNumber", "StudyDescription", "PatientBirthDate", "PatientSex", "PatientAge", "StudyDate", "RequestedProcedureDescription", "RequestedProcedureCodeSequence", ], "series": [ "SeriesInstanceUID", "StudyInstanceUID", "Modality", "SeriesDescription", "BodyPartExamined", "ProtocolName", "RequestAttributesSequence", ], "instance": [ "SOPInstanceUID", "SeriesInstanceUID", ], ... }
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description bears full burden. It explains return structure (dictionary by query level) and provides an example. It is clear it is a read-only operation, though no permissions or side effects are noted.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise, front-loaded, and includes a useful example. Every sentence adds value with no redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given zero parameters and presence of output schema, the description fully covers the tool's behavior. The example output completes the understanding.
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 tool has 0 parameters, so baseline is 4. No additional parameter info needed.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'Get all available attribute presets for DICOM queries.' It specifies the exact resource and action, and distinguishes from sibling tools which focus on actual queries or node management.
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 preparing queries but does not explicitly state when to use vs alternatives or provide exclusions. It mentions 'can be used with the query_* functions' but no direct contrast.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Return the MCP manifest for schema/version contract validation.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of disclosing behavioral traits. It states only that the tool 'returns' data, but fails to confirm it is a read-only operation, mention any side effects, authentication requirements, or performance characteristics. This is a minimal disclosure for a tool with zero annotation support.
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 a single sentence that front-loads the key action and purpose. Every word adds value, with no redundancy or unnecessary elaboration.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple tool with no parameters and an existing output schema, the description is mostly sufficient. However, it does not explain what an 'MCP manifest' is or what the output contains, which could confuse new users. The presence of an output schema mitigates this gap.
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 tool has zero parameters, and schema description coverage is 100% (vacuously satisfied). The description does not need to add parameter details. A baseline score of 4 is appropriate given no parameters exist.
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 ('Return'), the resource ('MCP manifest'), and the purpose ('for schema/version contract validation'). It effectively distinguishes itself from siblings, which are all DICOM-related tools, by focusing on contract validation rather than data retrieval or node operations.
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 validation purposes but provides no explicit guidance on when to use this tool versus alternatives, nor does it mention any prerequisites or exclusions. Since no siblings perform the same function, the context is moderately clear but could benefit from direct statements.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List all configured DICOM nodes and their connection information.
This tool returns information about all configured DICOM nodes in the system and shows which node is currently selected for operations. It also provides registry metadata used by downstream node resolvers.
Returns: Dictionary containing: - current_node: The currently selected DICOM node name - current_calling_aet: The currently selected calling AE name or AE title - current_calling_ae_title: The resolved calling AE title in use - nodes: List of node registry entries with canonical name, AE title, and optional aliases/description - nodes_legacy: Backward-compatible list of {name: description} - calling_aets: List of configured calling AE entries (if any)
Example: { "current_node": "pacs1", "current_calling_aet": "default", "current_calling_ae_title": "MCPSCU", "nodes": [ { "name": "pacs1", "ae_title": "PACS1", "aliases": ["main", "primary"], "description": "Primary PACS", }, { "name": "orthanc", "ae_title": "ORTHANC", }, ], "nodes_legacy": [ {"pacs1": "Primary PACS"}, {"orthanc": ""}, ], "calling_aets": [ { "name": "default", "ae_title": "MCPSCU", "description": "Default calling AE", } ], }
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the burden. It clearly indicates a read-only operation by stating it 'returns information' and does not mention any modifications or side effects, though it does not explicitly declare 'read-only'.
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 purpose, but it includes a detailed return structure and example that may be redundant given the existence of an output schema. It could be more concise without the extensive inline example.
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 low complexity (no parameters, simple listing) and the presence of an output schema, the description fully covers the behavior and return structure, leaving no gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has zero parameters, so the baseline score is 4. The description does not need to add parameter semantics, and it correctly omits any parameter details.
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 uses the specific verb 'List' and identifies the resource 'all configured DICOM nodes and their connection information,' clearly distinguishing it from sibling tools like switch_dicom_node (which changes the active node) and verify_connection (which tests connectivity).
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 states the tool returns information about configured nodes and the currently selected node, implying it is for inspection. However, it does not explicitly provide 'when to use' vs. alternatives or state 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.
Query individual DICOM instances (images) within a series.
This tool performs a DICOM C-FIND operation at the IMAGE level to find individual DICOM instances within a specified series. The series_instance_uid is required, and additional parameters can be used to filter the results.
Args: series_instance_uid: Unique identifier for the series (required) instance_number: Filter by specific instance number within the series sop_instance_uid: Unique identifier for a specific instance attribute_preset: Controls which attributes to include in results: - "none": No attributes, use with additional_attributes (default) - "custom": Our custom attributes additional_attributes: List of specific DICOM attributes to include beyond the preset exclude_attributes: List of DICOM attributes to exclude from the results
Returns: Dictionary containing query results and status metadata. The results list includes entries like: { "SOPInstanceUID": "1.2.840.113619.2.1.1.322.1600364094.412.3001", "SOPClassUID": "1.2.840.10008.5.1.4.1.1.2", "InstanceNumber": "45", "ContentDate": "20230215", "ContentTime": "152245" }
Notes: Returns success False if the query fails.
| Name | Required | Description | Default |
|---|---|---|---|
| series_instance_uid | Yes | ||
| instance_number | No | ||
| sop_instance_uid | No | ||
| attribute_preset | No | none | |
| additional_attributes | No | ||
| exclude_attributes | No |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries full burden. It discloses the tool performs a DICOM C-FIND network operation and returns success false on failure. It does not explicitly state read-only behavior, but the operation type implies no side effects. The return format is explained.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with a purpose statement, detailed paragraphs, and clearly labeled Args, Returns, and Notes sections. It is front-loaded with the main action. Minor redundancy exists (purpose repeated in first sentence of second paragraph) but does not detract significantly.
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 has 6 parameters (1 required) and an output schema, the description covers all parameters with explanations and provides a concrete return example. It also includes a note about failure handling. No annotations exist, so the description effectively fills the gap.
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 add meaning. It provides detailed explanations for all six parameters, including the purpose of series_instance_uid, instance_number, sop_instance_uid, attribute_preset (with enumerated options 'none' and 'custom'), additional_attributes, and exclude_attributes. This adds significant value beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool queries individual DICOM instances (images) within a series using a C-FIND operation at the IMAGE level. This specific verb and resource level distinguishes it from sibling tools like query_patients and query_series, which operate at different DICOM levels.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explains when to use the tool (to find instances within a series) and provides required and optional filters. However, it does not explicitly state when not to use it or mention alternatives among siblings, leaving room for ambiguity.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Query patients matching the specified criteria from the DICOM node.
This tool performs a DICOM C-FIND operation at the PATIENT level to find patients matching the provided search criteria. All search parameters are optional and can be combined for more specific queries.
Args: patient_id: Patient ID to search for, e.g., "12345678" birth_date: Patient birth date in YYYYMMDD format, e.g., "19700101" attribute_preset: Controls which attributes to include in results: - "none": No attributes, use with additional_attributes (default) - "custom": Our custom attributes additional_attributes: List of specific DICOM attributes to include beyond the preset exclude_attributes: List of DICOM attributes to exclude from the results
Returns: Dictionary containing: - success: Boolean indicating if the query completed without failure - results: List of matched patient records - dicom_statuses: List of DICOM status entries - warnings: List of warning entries - error: Optional error dictionary
Example: { "success": true, "results": [ { "PatientID": "12345", "PatientBirthDate": "19700101", "PatientSex": "M" } ], "dicom_statuses": [{"code": "0x0000", "category": "success"}], "warnings": [], "error": null }
Notes: Returns success False if the query fails.
| Name | Required | Description | Default |
|---|---|---|---|
| patient_id | No | ||
| birth_date | No | ||
| attribute_preset | No | none | |
| additional_attributes | No | ||
| exclude_attributes | No |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description fully covers behavior: it performs a DICOM C-FIND, returns success/failure, and details the return structure. However, it does not explicitly state read-only or mention auth/rate limits.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with clear sections (Args, Returns, Example, Notes) and front-loaded purpose. It is efficient but slightly verbose with the example.
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 complexity and sibling tools at different DICOM levels, the description is complete: it explains level, parameters, return format, and error handling. The output schema is absent but the description compensates with a detailed example.
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%, but the description provides detailed semantics for all 5 parameters, including examples and format hints (e.g., date format, attribute_preset options), adding substantial value beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it queries patients from a DICOM node using C-FIND at the PATIENT level, distinguishing it from sibling tools for studies, series, and instances.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explains that parameters are optional and combinable, but lacks explicit guidance on when to use this tool versus siblings like query_studies or query_series.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Query series within a study from the DICOM node.
This tool performs a DICOM C-FIND operation at the SERIES level to find series within a specified study. The study_instance_uid is required, and additional parameters can be used to filter the results.
Args: study_instance_uid: Unique identifier for the study (required) modality: Filter by imaging modality, e.g., "CT", "MR", "US", "CR" series_number: Filter by series number series_description: Series description text with wildcards. IMPORTANT: Use wildcards on BOTH sides for substring matching, e.g., "AXIAL" to find "AXIAL 2.5MM RECON". Using "AXIAL*" only matches descriptions starting with "AXIAL". series_instance_uid: Unique identifier for a specific series limit: Maximum number of results to return (None = no limit) attribute_preset: Controls which attributes to include in results: - "none": No attributes, use with additional_attributes (default) - "custom": Our custom attributes additional_attributes: List of specific DICOM attributes to include beyond the preset exclude_attributes: List of DICOM attributes to exclude from the results
Returns: Dictionary containing query results and status metadata. The results list includes entries like: { "SeriesInstanceUID": "1.2.840.113619.2.1.1.322.1600364094.412.2005", "SeriesNumber": "2", "SeriesDescription": "AXIAL 2.5MM", "Modality": "CT", "NumberOfSeriesRelatedInstances": "120" }
Notes: Returns success False if the query fails.
| Name | Required | Description | Default |
|---|---|---|---|
| study_instance_uid | Yes | ||
| modality | No | ||
| series_number | No | ||
| series_description | No | ||
| series_instance_uid | No | ||
| limit | No | ||
| attribute_preset | No | none | |
| additional_attributes | No | ||
| exclude_attributes | No |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided. The description explains it performs a C-FIND, returns status metadata, and notes failure behavior, but does not disclose potential side effects, authentication needs, or performance implications.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with clear sections (Args, Returns, Notes) and front-loaded purpose, but the parameter details are somewhat lengthy and could be slightly more 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?
Given the complexity (9 parameters, DICOM-specific), the description thoroughly covers required parameter, filtering, wildcard behavior, attribute presets, return format, and failure behavior, making it highly complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, but the description compensates with detailed explanations for each parameter, including wildcard usage examples and attribute preset options, adding significant meaning beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it queries series within a study using a DICOM C-FIND operation, distinguishing it from sibling tools like query_studies or query_instances.
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 states that study_instance_uid is required and additional parameters filter results, but lacks explicit guidance on when to use this tool versus alternatives or any 'when not to use' conditions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Query studies matching the specified criteria from the DICOM node.
This tool performs a DICOM C-FIND operation at the STUDY level to find studies matching the provided search criteria. All search parameters are optional and can be combined for more specific queries.
Args: patient_id: Patient ID to search for (supports wildcards), e.g., "12345678" or "123" patient_sex: Patient sex (F, M, O) patient_birth_date: Patient birth date or range in DICOM format: - Single date: "19700101" - Date range: "19700101-19801231" study_date: Study date or date range in DICOM format: - Single date: "20230101" - Date range: "20230101-20230131" modality_in_study: Filter by modalities present in study, e.g., "CT" or "MR" study_description: Study description text with wildcards. IMPORTANT: Use wildcards on BOTH sides for substring matching, e.g., "CHEST" to find "CT CHEST W CONTRAST". Using "CHEST*" only matches descriptions starting with "CHEST". accession_number: Medical record accession number (supports wildcards) study_instance_uid: Unique identifier for a specific study limit: Maximum number of results to return (None = no limit) attribute_preset: Controls which attributes to include in results: - "none": No attributes, use with additional_attributes (default) - "custom": Our custom attributes additional_attributes: List of specific DICOM attributes to include beyond the preset exclude_attributes: List of DICOM attributes to exclude from the results filters: Dictionary of DICOM tag names to filter values. Use this to filter by any DICOM attribute not in the standard parameters. Supports wildcards. Example: {"RequestedProcedureDescription": "CHESTANGIO*"}
Returns: Dictionary containing query results and status metadata. The results list includes entries like: { "StudyInstanceUID": "1.2.840.113619.2.1.1.322.1600364094.412.1009", "StudyDate": "20230215", "StudyDescription": "CHEST CT", "PatientID": "12345", "ModalitiesInStudy": "CT" }
Notes: Returns success False if the query fails.
| Name | Required | Description | Default |
|---|---|---|---|
| patient_id | No | ||
| patient_sex | No | ||
| patient_birth_date | No | ||
| study_date | No | ||
| modality_in_study | No | ||
| study_description | No | ||
| accession_number | No | ||
| study_instance_uid | No | ||
| limit | No | ||
| attribute_preset | No | none | |
| additional_attributes | No | ||
| exclude_attributes | No | ||
| filters | No |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden. It explains the underlying operation (C-FIND), supports wildcards and date ranges, and notes that failure returns success=False. It does not cover auth or performance, but as a query tool, transparency is adequate.
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 lengthy but well-organized with clear sections and front-loaded purpose. While comprehensive, some parameter explanations could be slightly more concise, but overall it is highly informative.
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 complexity (13 parameters, no annotations), the description covers parameter semantics, usage format, and return examples. It lacks explicit pagination details and comprehensive error handling, but is sufficiently complete for a query 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?
The schema has 0% description coverage, so the description must compensate. It provides detailed explanations, formats, examples, and wildcard guidance for all 13 parameters, adding significant meaning beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it performs a DICOM C-FIND at the STUDY level, distinguishing it from sibling tools like query_instances and query_series. It precisely indicates the resource (studies) and action (query), making the purpose unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explains that all parameters are optional and combinable, and provides usage examples. However, it does not explicitly contrast with sibling tools or state when not to use this tool, which would further aid selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Switch the active DICOM node connection to a different configured node.
This tool changes which DICOM node (PACS, workstation, etc.) subsequent operations will connect to. The node must be defined in the configuration file.
Args: node_name: The name of the node to switch to, must match a name in the configuration
Returns: Dictionary containing: - success: Boolean indicating if the switch was successful - message: Description of the operation result or error
Example: { "success": true, "message": "Switched to DICOM node: orthanc" }
Notes: Returns success False if the node name is not found.
| Name | Required | Description | Default |
|---|---|---|---|
| node_name | Yes |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Without annotations, the description carries the full burden. It discloses that the node must exist in configuration, returns success false if not found, and specifies the return structure (success and message). This is sufficient for a simple configuration-switching tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and well-structured with separate sections for Args, Returns, Example, and Notes. It front-loads the key action and uses minimal, effective language.
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 (one parameter, no nested objects), the description fully covers operation, parameters, return values, and error behavior. It is complete for its context.
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 input schema, which only provides the title and type for node_name. The Args section explains that node_name must match a configuration entry, which is essential usage detail not present in the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states that the tool switches the active DICOM node connection, using the verb 'Switch' and specifying the resource 'active DICOM node connection'. This purpose distinguishes it from sibling tools like list_dicom_nodes and verify_connection.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explains when to use the tool (to change the active node for subsequent operations) and notes that the node must be defined in the configuration. It does not explicitly mention when not to use it, but the context is clear enough.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Verify connectivity to the DICOM node using C-ECHO.
This tool performs a DICOM C-ECHO operation (similar to a network ping) to check if the currently selected DICOM node is reachable and responds correctly. This is useful to troubleshoot connection issues before attempting other operations.
Returns: Dictionary containing: - success: Boolean indicating if the connection succeeded - message: Description of the connection status - details: Connection details (node, host, port, AE titles)
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Describes the C-ECHO operation as a network ping and lists return fields. Without annotations, this provides enough behavioral context, though it doesn't explicitly state non-destructive nature.
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 plus a bullet list for returns, front-loaded with purpose. Every sentence is informative without fluff.
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?
Tool is simple with no inputs; description fully explains its behavior and output structure, sufficient for an agent to use it correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
No parameters exist, and schema coverage is 100%. Description adds context about what the tool does, meeting the baseline for 0-param tools.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description clearly states it performs a DICOM C-ECHO operation to verify connectivity, and distinguishes from sibling tools which handle nodes, queries, and manifest 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?
Explicitly says it's useful to troubleshoot connection issues before other operations, providing context. No when-not or alternatives needed given its unique role.
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.1.1get_attribute_presetsget_manifestlist_dicom_nodesquery_instancesquery_patientsquery_seriesquery_studiesswitch_dicom_nodeverify_connectionScored across 9 tools
Each tool targets a distinct aspect: attribute presets, manifest, node listing, four query levels, node switching, and connection verification. No overlapping purposes.
All tool names follow a consistent verb_noun pattern (get_, list_, query_, switch_, verify_) in snake_case, making them predictable and easy to differentiate.
9 tools is well-scoped for a DICOM MCP server: four query tools for different imaging levels, plus configuration and connection management.
The surface covers querying at all four DICOM levels and node management, but lacks instance retrieval (C-MOVE/C-GET) or data export, which may be expected but are outside a 'simple' scope.
Connect AI clients to biomedical data and tools.
Hosted MCP server exposing US hospital procedure cost data to AI assistants
Query InterviewFlowAI candidate and interview data from MCP-compatible AI assistants.
Securely access and manage FHIR healthcare data stored in Medplum.
