SDMX MCP Gateway
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., "@SDMX MCP Gateway Find dataflows related to inflation"
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.
SDMX MCP Gateway
A Model Context Protocol (MCP) server that provides progressive discovery tools for SDMX statistical artefacts and data. This implementation enables AI agents to explore and access SDMX-compliant statistical data repositories through interactive tools, resources, and prompts.
Version 0.2.0 - Now with structured outputs, Streamable HTTP transport, and elicitation support.
š Key Features
Progressive Discovery: Reduces metadata transfer from 100KB+ to ~2.5KB
Structured Outputs: All tools return validated Pydantic models
Multiple Transports: STDIO (development) and Streamable HTTP (production)
Interactive Elicitation: User confirmation dialogs for endpoint switching
Multi-Provider Support: SPC, FBOS, SBS, ECB, UNICEF, IMF, OECD, ESTAT, ILO, ABS, BIS
Related MCP server: StatTools
Quick Start
A public instance of this server is hosted on Railway. Point any MCP client at the URL below and you can skip cloning, installing dependencies, and managing a Python environment.
https://sdmx-mcp-gateway-production.up.railway.app/mcpTransport is Streamable HTTP. The endpoint is shared and stateless from the client's perspective; each MCP session gets its own server-side state (endpoint selection, client pool, mismatch-hint cache).
Quick check that it responds:
curl -X POST https://sdmx-mcp-gateway-production.up.railway.app/mcp \
-H "Content-Type: application/json" \
-H "Accept: application/json, text/event-stream" \
-d '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2024-11-05","capabilities":{},"clientInfo":{"name":"probe","version":"0"}}}'See MCP Client Configuration for ready-to-paste configs for Claude Code, Claude Desktop, Codex, Cursor, Zed, and OpenCode.
Health Status
A standalone monitor checks the hosted gateway and every provider endpoint
(through the gateway and directly) every two hours. See monitor/README.md
for running or deploying it. Once deployed, its status page shows current
health, per-endpoint history, and whether a failure sits in the gateway or
the upstream provider.
Self-Hosting
If you prefer to run the server yourself (offline use, private deployments, development on the tools themselves), see Installation and Running the Server.
cd sdmx-mcp-gateway
uv sync
uv run python main_server.py # STDIO, for local clients
uv run python main_server.py --transport http --port 8000 # HTTP, for remote clients
uv run mcp dev ./main_server.py # MCP Inspector (browser UI)The Problem We Solve
Traditional SDMX queries with references=all return 100KB+ of XML metadata, overwhelming LLM context windows. Our progressive discovery approach provides a layered exploration:
Step | Operation | Data Size |
1 | Find dataflows by keyword | ~300 bytes |
2 | Get dimension structure | ~1KB |
3 | Explore specific dimension codes | ~500 bytes |
4 | Check data availability | ~700 bytes |
5 | Build final query URL | ~200 bytes |
Total | ~2.5KB |
Architecture
sdmx-mcp-gateway/
āāā main_server.py # FastMCP server with CLI
āāā app_context.py # Lifespan management & shared resources
āāā config.py # Endpoint configuration
āāā sdmx_progressive_client.py # SDMX 2.1 REST client
āāā utils.py # Validation & utilities
āāā models/
ā āāā __init__.py
ā āāā schemas.py # Pydantic output schemas
āāā tools/
ā āāā sdmx_tools.py # Discovery tools implementation
ā āāā endpoint_tools.py # Endpoint management
āāā resources/
ā āāā sdmx_resources.py # MCP resources
āāā prompts/
ā āāā sdmx_prompts.py # Guided prompts
āāā tests/ # Test suiteAvailable Tools
Discovery Tools
Tool | Description | Output Schema |
| Find dataflows by keyword |
|
| Get dimensions and structure |
|
| Explore codes for a dimension |
|
| Check what data exists |
|
| Generate Mermaid diagram of relationships |
|
| Compare two structures for differences |
|
| Validate query parameters |
|
| Construct SDMX key |
|
| Generate data retrieval URL |
|
| Browse specific codelist |
|
SDMX 2.1 has no server-side pagination, so list_dataflows fetches a provider's entire dataflow listing under the hood even when limit is small; for ESTAT that listing alone is 37 MB. The parsed result is cached process-wide (shared across every session, not per client) for DATAFLOW_CACHE_TTL_S seconds (default 900, 15 minutes), keyed on the base URL, agency, and the other parameters that change the answer. The result's next_step field always states whether that call was served from cache and, if so, how old the entry is, so a caller never has to guess. Pass fresh=True to bypass the cache and force a live re-fetch; the fresh result still refreshes the cache for everyone else. Use fresh=True for liveness checks, where a cached answer would say nothing about whether the provider is reachable right now.
Reference Metadata
Tool | Description | Output Schema |
| Summarise source, methodology, licence and caveats for a dataflow |
|
| Get every value of one metadata attribute, with the slice each applies to |
|
Reference metadata is the descriptive material about a dataflow rather than its structure: who compiled it, from what source, under what licence, with what caveats. Coverage varies by provider, so the result's channels field reports which channel was available: .Stat Suite deployments (SPC, FBOS, SBS, OECD) publish it through a v2 MSD query, some other providers carry equivalent detail only in ordinary DSD attributes on the data message, and some publish neither. A channel status of inconclusive means the query did not produce a usable answer; that is different from a confirmed absence, which is what empty reports.
Pass key to narrow the query to one series. This matters for large dataflows: SPC's DF_SDG metadata query is 5.37 MB unfiltered against 5.6 KB with a partial key, and the tool refuses an unfiltered query over 2 MB (too_broad) by aborting the read partway through rather than downloading it in full; the same cap applies to both the MSD query and the DSD-attribute fallback used by providers without a /v2/ endpoint.
get_reference_metadata: the summary
get_reference_metadata returns one entry per attribute the provider declares, in metadata_attributes, plus a coverage count and a per-channel channels status. Each attribute carries:
status:populatedwhen the provider published at least one value,declared_emptywhen every occurrence in the response read was blank -- for the whole dataflow when no key was supplied, or for the slice queried when one was, since a keyed request only reads that slice. A declared-but-empty attribute is a real, observed answer, not a missing one, and it is listed rather than omitted, so a blank licence field reads differently from a provider that has no licence concept at all.valueanddrill_down:valuecarries the headline text when exactly one distinct value exists and either it describes the whole dataflow (dataflow/datasetscope, provider-marked unqualified), or it was identical on every data row this query actually returned (all_observed_rowsscope). The second case is common: SPC'sDF_SDGpublishes the same value on every per-country row and has no dataflow-wide row at all, so before this rule every one of its populated attributes came backvalue: null.drill_downisfalseonly fordataflow/datasetscope; forall_observed_rowsit staystrue, since that scope says nothing about rows the query did not return (a different key, or rows beyond a truncated response's row cap) and the per-row detail behind it still matters. When the attribute's values differ across the rows read,valueisnullanddrill_downistrue, meaning no single value can stand in as the answer.distinct_valuesandscope: how many distinct values were found, and what the headline (when present) attaches to: the whole dataflow (dataflow/dataset), every row this query returned (all_observed_rows, weaker thandataflow: no provider ever marked it unqualified), or one slice (partial_key).
coverage (declared / populated / empty) is reported only when the MSD channel itself answered found on an untruncated read: that is the only channel that can see a declared-but-empty attribute (parse_msd_csv's declared_empty status). Neither an MSD empty answer nor the DSD-attribute fallback can establish it, even when both agree: the DSD fallback only ever sees what a message actually populates, so it can never confirm that a provider declares nothing further, and a truncated MSD read cannot rule out a value past the row cap. coverage is None in every one of those cases -- when the only channel that answered was the DSD-attribute fallback, which shows populated attributes only; when the MSD channel answered empty (with or without the DSD fallback also resolving); or when the MSD channel found something but the read was cut off before finishing.
get_metadata_attribute: the drill-down
Call get_metadata_attribute(dataflow_id, attribute_id, key=None, agency_id=None) after get_reference_metadata reports drill_down: true for an attribute, to read every distinct value with the dimension key (key_context) it applies to. attribute_id is the short id from the summary, not the full dotted path. The result (MetadataAttributeValuesResult) has no separate error field; every case below is a normally-shaped result distinguished by total and by the text of notes. Four answers matter and are kept distinct:
Populated: one entry per distinct (value,
key_context) pair; the same value may appear multiple times with differentkey_contextvalues.totalcounts these pairs, while the summary'sdistinct_valuescounts distinct values only (the two need not match), andtruncatedistruewhen more than 200 pairs exist, withvalueslimited to the first 200.Declared but empty:
total: 0,values: [], and a note stating the attribute is declared and left blank -- for the whole dataflow when no key was supplied, for the slice queried when one was. The first note does not start with"Error:".Unknown attribute id:
total: 0,values: [], and a first note starting with"Error: "reading"Error: Unknown attribute '<id>' for <dataflow>: declared attributes are <ids>", naming the dataflow's declared attribute ids so a typo reads as "here is what exists" rather than as an empty result. This wording is only used when the MSD channel itself answeredfound: that is the one channel outcome that can vouch for a provider's full declared set, so the listed ids are genuinely everything declared. A caller distinguishes this from the declared-but-empty case above by checking whether the first note starts with"Error:", not by looking for a field that does not exist on this result.No channel confirmed a declared set:
total: 0,values: [], and notes explaining which channel could not answer and why that is not evidence the attribute is missing. This covers an MSD channel that answeredtoo_broad,inconclusiveorunsupported, and also the MSD channel's ownemptyanswer -- even when the DSD-attribute fallback separately found something or itself resolved toempty, since that fallback only ever sees what a message actually populates and can never see an attribute the DSD declares but a given response leaves blank, so it cannot vouch for the full declared set on its own. Like the declared-but-empty case, the notes here do not start with"Error:".
Each value's key_context is null in two different situations that a caller must not conflate: from the MSD channel, null means the value is genuinely dataflow-wide; from the DSD-attribute fallback channel (used by providers without a /v2/ endpoint), null means that channel has no per-value key to report at all, even when the value actually attaches to one series or observation rather than to the whole dataflow. A note on the result says which channel supplied the attribute when this applies.
Endpoint Management
Tool | Description | Output Schema |
| Show the session's default provider |
|
| List all configured providers |
|
The session default is set once at startup from the SDMX_ENDPOINT env var and is not mutable at runtime. To target a specific provider for an individual call, pass endpoint=<KEY> to any endpoint-scoped tool.
Resources
sdmx://agencies- List of known SDMX data providerssdmx://agency/{id}/info- Specific agency detailssdmx://formats/guide- Data format comparisonsdmx://syntax/guide- Query syntax reference
Prompts
discovery_guide- Step-by-step data discovery workflowtroubleshooting_guide- Common issue resolutionbest_practices- Use-case specific guidancequery_builder- Interactive query construction
Supported Data Sources
Key | Provider | Description | Constraints |
| Pacific Data Hub | Pacific regional statistics (default) | Actual (single + bulk) |
| Fiji Bureau of Statistics | Fiji official national statistics | Actual (single + bulk) |
| Samoa Bureau of Statistics | Samoa official national statistics | Actual (single + bulk) |
| European Central Bank | European financial statistics | Allowed (single + bulk) |
| UNICEF | Children and youth statistics | Actual (single + bulk) |
| International Monetary Fund | Global financial statistics | Actual (single) |
| OECD | Economic and social statistics | Actual (single) |
| Bank for International Settlements | International financial statistics | Actual (single) |
| Australian Bureau of Statistics | Australian official statistics | Actual (single) |
| International Labour Organization | Labour and employment statistics | Actual (single) |
| Eurostat | European Union official statistics | None |
Target a provider per call:
# Pass endpoint= on any endpoint-scoped tool
list_dataflows(endpoint="ECB", limit=10)
get_dataflow_structure(dataflow_id="DF_CPI", endpoint="FBOS")
# Or rely on the session default (set at startup from SDMX_ENDPOINT env var)
list_dataflows(limit=10)See docs/ENDPOINT_CONFIGURATION.md for provider-specific behaviours and constraint strategies.
Installation
Prerequisites
Python 3.12 or higher
uv (recommended) or pip
Using UV (Recommended)
cd sdmx-mcp-gateway
uv syncUsing pip
cd sdmx-mcp-gateway
pip install -r requirements.txtDependencies
mcp[cli]>=1.26.0- Model Context Protocol SDKpydantic>=2.0.0- Structured output validationhttpx>=0.27.0- Async HTTP clientcertifi>=2024.0.0- SSL certificates
Running the Server
CLI Options
uv run python main_server.py [OPTIONS]
Options:
--transport, -t Transport type: stdio, http, streamable-http (default: stdio)
--host Host for HTTP transport (default: HOST env or 0.0.0.0)
--port, -p Port for HTTP transport (default: PORT env or 8000)
--stateless Run in stateless mode (HTTP only)
--json-response Use JSON responses instead of SSE (HTTP only)
--debug Enable debug loggingDevelopment Mode (STDIO)
# Direct execution
uv run python main_server.py
# With MCP Inspector (opens browser UI)
uv run mcp dev ./main_server.pyProduction Mode (Streamable HTTP)
uv run python main_server.py --transport streamable-http --host 0.0.0.0 --port "${PORT:-8000}"For container platforms such as Vercel, Railway, or Fly, prefer binding to 0.0.0.0
and reading the port from the platform-provided PORT environment variable. The
server now fails fast if the installed MCP SDK ignores the requested HTTP bind
settings, rather than silently falling back to localhost.
MCP Client Configuration
The recommended path is to point your client at the hosted Railway URL. Each section below shows:
Hosted (HTTP): uses
https://sdmx-mcp-gateway-production.up.railway.app/mcp. Nothing to install beyond the client itself.Self-hosted (STDIO): runs the server from a clone of this repo. Requires
uvandgit(see Installation).
Clients that only speak STDIO can still reach the hosted instance via the mcp-remote bridge, which proxies HTTP MCP servers through stdio via npx.
Claude Code
Hosted, one-liner:
claude mcp add --transport http sdmx-gateway https://sdmx-mcp-gateway-production.up.railway.app/mcpOr in .claude/settings.json / ~/.claude/settings.json:
{
"mcpServers": {
"sdmx-gateway": {
"type": "http",
"url": "https://sdmx-mcp-gateway-production.up.railway.app/mcp"
}
}
}Self-hosted (STDIO):
{
"mcpServers": {
"sdmx-gateway": {
"command": "uv",
"args": [
"run",
"--directory",
"/path/to/sdmx-mcp-gateway",
"python",
"main_server.py"
]
}
}
}If
uvis not on your PATH, use the full path (e.g."/home/user/.local/bin/uv").
OpenAI Codex CLI
Hosted, via ~/.codex/config.toml (uses mcp-remote to bridge HTTP into stdio):
[mcp_servers.sdmx]
command = "npx"
args = ["-y", "mcp-remote", "https://sdmx-mcp-gateway-production.up.railway.app/mcp"]
enabled = true
tool_timeout_sec = 120Or via the CLI:
codex mcp add sdmx -- npx -y mcp-remote https://sdmx-mcp-gateway-production.up.railway.app/mcpSelf-hosted:
[mcp_servers.sdmx]
command = "uv"
args = ["run", "--directory", "/path/to/sdmx-mcp-gateway", "python", "main_server.py"]
enabled = true
tool_timeout_sec = 120The
commandfield must be the executable only. Ifuvornpxis not on your PATH, use the full path. Arguments go inargsas a separate array.
Claude Desktop
Claude Desktop does not yet speak HTTP MCP natively, so use mcp-remote to reach the hosted server.
Config file locations:
Linux:
~/.config/Claude/claude_desktop_config.jsonmacOS:
~/Library/Application Support/Claude/claude_desktop_config.jsonWindows:
%APPDATA%\Claude\claude_desktop_config.json
Hosted:
{
"mcpServers": {
"sdmx-gateway": {
"command": "npx",
"args": [
"-y",
"mcp-remote",
"https://sdmx-mcp-gateway-production.up.railway.app/mcp"
]
}
}
}Self-hosted (STDIO):
{
"mcpServers": {
"sdmx-gateway": {
"command": "uv",
"args": [
"run",
"--directory",
"/path/to/sdmx-mcp-gateway",
"python",
"main_server.py"
]
}
}
}On Windows, escape the path:
"C:\\path\\to\\sdmx-mcp-gateway".
Cursor
Open Cursor Settings > MCP.
Add a new global MCP server.
Set the URL to
https://sdmx-mcp-gateway-production.up.railway.app/mcp(Cursor supports Streamable HTTP servers directly).
For a self-hosted instance, use the STDIO command shown for Claude Code.
Zed
Zed uses "Context Servers" for MCP integration. Settings file:
Linux:
~/.config/zed/settings.jsonmacOS:
~/Library/Application Support/Zed/settings.jsonProject-specific:
.zed/settings.jsonin your project root
Add the context_servers key at the top level of your settings.json, alongside other settings like theme and ui_font_size.
Hosted (via mcp-remote):
{
"context_servers": {
"sdmx-gateway": {
"command": {
"path": "npx",
"args": [
"-y",
"mcp-remote",
"https://sdmx-mcp-gateway-production.up.railway.app/mcp"
]
}
}
}
}Self-hosted:
{
"context_servers": {
"sdmx-gateway": {
"command": {
"path": "uv",
"args": [
"run",
"--directory",
"/path/to/sdmx-mcp-gateway",
"python",
"main_server.py"
]
}
}
}
}OpenCode
~/.config/opencode/config.json:
{
"mcpServers": {
"sdmx-gateway": {
"command": "npx",
"args": [
"-y",
"mcp-remote",
"https://sdmx-mcp-gateway-production.up.railway.app/mcp"
]
}
}
}Or, for a self-hosted instance, swap to the uv run ... command shown in the Claude Code section.
Generic MCP Client (Streamable HTTP)
Any client with Streamable HTTP support connects directly to the hosted URL:
https://sdmx-mcp-gateway-production.up.railway.app/mcpTo run your own HTTP instance locally:
uv run python main_server.py --transport http --port 8000Point the client at http://localhost:8000/mcp. Add --stateless --json-response if your client cannot consume Server-Sent Events.
Usage Examples
Progressive Discovery Workflow
# Step 1: Find relevant dataflows
list_dataflows(keywords=["digital", "development"])
# ā Returns: DataflowListResult with matching dataflows
# Step 2: Get structure
get_dataflow_structure("DF_DIGITAL_DEVELOPMENT")
# ā Returns: DataflowStructureResult with dimensions
# Step 3: Find country code
get_dimension_codes("DF_DIGITAL_DEVELOPMENT", "GEO_PICT", search_term="tonga")
# ā Returns: DimensionCodesResult with TO = Tonga
# Step 4: Check availability
get_data_availability("DF_DIGITAL_DEVELOPMENT", dimension_values={"GEO_PICT": "TO"})
# ā Returns: DataAvailabilityResult with time ranges
# Step 5: Build query
build_data_url("DF_DIGITAL_DEVELOPMENT", key="A..TO.", format_type="csv")
# ā Returns: DataUrlResult with ready-to-use URLStructure Relationship Visualization
Understand how SDMX structures relate to each other with Mermaid diagrams:
# See what a DSD references (codelists, concept schemes)
get_structure_diagram("datastructure", "DSD_DF_POP", direction="children")
# ā Returns: StructureDiagramResult with mermaid_diagram field
# See what uses a codelist (impact analysis)
get_structure_diagram("codelist", "CL_FREQ", direction="parents")
# ā Shows which DSDs and concept schemes use this codelist
# Get full relationship graph
get_structure_diagram("dataflow", "DF_POP", direction="both")
# ā Shows both parent and child relationships
# Show version numbers on all nodes (important for impact analysis!)
get_structure_diagram("datastructure", "DSD_SDG", direction="children", show_versions=True)
# ā Displays version numbers like "CL_FREQ v1.0", "CL_GEO v2.0"
# This is critical because different versions are independent -
# a dataflow using CL_FREQ v1.0 won't be affected by changes to v2.0The mermaid_diagram field contains ready-to-render Mermaid code.
Without versions (default):
graph TD
subgraph dataflow["Dataflows ā"]
dataflow_DF_POP["š <b>DF_POP</b><br/>Population Statistics"]
end
subgraph datastructure["Data Structures"]
datastructure_DSD_POP["šļø DSD_POP<br/>Population DSD"]
end
subgraph codelist["Codelists"]
codelist_CL_FREQ["š CL_FREQ<br/>Frequency"]
codelist_CL_GEO["š CL_GEO<br/>Geography"]
end
dataflow_DF_POP -->|"defines structure"| datastructure_DSD_POP
datastructure_DSD_POP -->|"uses codelist"| codelist_CL_FREQ
datastructure_DSD_POP -->|"uses codelist"| codelist_CL_GEOWith show_versions=True (shows exact version dependencies):
graph TD
subgraph datastructure["Data Structures ā"]
datastructure_DSD_SDG["šļø <b>DSD_SDG</b> v3.0<br/>DSD for SDG"]
end
subgraph codelist["Codelists"]
codelist_CL_FREQ["š CL_FREQ v1.0<br/>Frequency"]
codelist_CL_GEO["š CL_GEO v2.0<br/>Geography"]
end
datastructure_DSD_SDG -->|"uses codelist"| codelist_CL_FREQ
datastructure_DSD_SDG -->|"uses codelist"| codelist_CL_GEOComparing Structures
Identify differences between two structures (useful for version upgrades and cross-structure analysis).
Comparing Codelists (compares actual codes):
# Compare two versions of a codelist - what codes changed?
compare_structures(
structure_type="codelist",
structure_id_a="CL_GEO",
version_a="1.0",
version_b="2.0"
)
# ā Shows added/removed/renamed codes between versions
# Compare two different codelists - find intersection and differences
compare_structures(
structure_type="codelist",
structure_id_a="CL_FREQ",
structure_id_b="CL_TIME_FREQ"
)
# ā Shows which codes are unique to each, and which are sharedComparing DSDs (compares codelist/conceptscheme references):
# Compare two versions of a DSD - what codelist references changed?
compare_structures(
structure_type="datastructure",
structure_id_a="DSD_SDG",
version_a="2.0",
version_b="3.0"
)
# ā Shows added/removed/version-changed codelist references
# Compare two different DSDs
compare_structures(
structure_type="datastructure",
structure_id_a="DSD_SDG",
structure_id_b="DSD_EDUCATION"
)
# ā Shows which codelists are unique to each, and which are sharedThe comparison identifies:
ā Added: Items that exist in B but not A
ā Removed: Items that exist in A but not B
š Modified: Same ID but changed (version change for DSD refs, name change for codes)
ā Unchanged: Identical items in both
Example codelist comparison output:
Comparing codelist CL_GEO: v1.0 ā v2.0
Total codes: A has 25, B has 28
Summary: 5 change(s) detected
- ā Added codes: 3
- ā Removed codes: 0
- š Name changed: 2
- ā Unchanged: 23
ā Added codes:
- `PW`: Palau
- `MH`: Marshall Islands
- `FM`: Federated States of MicronesiaExample DSD comparison with diff diagram:
graph LR
subgraph comparison["Structure Comparison"]
A["šļø DSD_SDG<br/>v3.0"]
B["šļø DSD_EDUCATION<br/>v1.0"]
end
subgraph added_group["ā Added"]
add_CL_EDUCATION["š CL_EDUCATION_INDICATORS<br/>v1.0"]
end
subgraph removed_group["ā Removed"]
rem_CL_SDG["š CL_SDG_INDICATORS<br/>v3.0"]
end
subgraph changed_group["š Version Changed"]
chg_CL_GEO["š CL_GEO<br/>v1.0 ā v2.0"]
end
A -.->|removed| rem_CL_SDG
B -->|added| add_CL_EDUCATION
A -.->|was| chg_CL_GEO
B -->|now| chg_CL_GEO
style add_CL_EDUCATION fill:#c8e6c9,stroke:#388e3c
style rem_CL_SDG fill:#ffcdd2,stroke:#d32f2f
style chg_CL_GEO fill:#fff9c4,stroke:#fbc02dTargeting a Provider Per Call
Every endpoint-scoped tool accepts an optional endpoint=<KEY> argument:
list_dataflows(endpoint="ECB", limit=10)
get_dataflow_structure(dataflow_id="EXR", endpoint="ECB")
build_data_url(dataflow_id="DF_CPI", filters={"GEO_AREA": "FJI"}, endpoint="FBOS")Calls without endpoint= use the session's default (set at server startup from the SDMX_ENDPOINT env var). Parallel calls to different providers are safe ā each resolves independently.
Structured Outputs
All tools return Pydantic models with validated, typed data:
# Example: DataflowListResult
{
"discovery_level": "overview",
"agency_id": "SPC",
"total_found": 45,
"showing": 10,
"offset": 0,
"limit": 10,
"dataflows": [
{"id": "DF_GDP", "name": "GDP Statistics", "description": "..."},
...
],
"pagination": {
"has_more": true,
"next_offset": 10,
"total_pages": 5,
"current_page": 1
},
"next_step": "Use get_dataflow_structure() to explore a dataflow"
}Testing
# Run all tests
uv run pytest
# Run with coverage
uv run pytest --cov=. --cov-report=html
# Run specific test categories
uv run pytest tests/unit/
uv run pytest tests/integration/
uv run pytest tests/e2e/Known Limitations
Multi-User Endpoint Isolation
Each MCP session has its own client pool (one SDMXProgressiveClient per endpoint it has touched) and its own mismatch-hint registry. STDIO mode uses a single session; HTTP transport uses Mcp-Session-Id headers for per-user isolation. Sessions timeout after 30 minutes of inactivity. The session default endpoint is immutable at runtime ā set it via the SDMX_ENDPOINT env var at server startup.
See docs/MULTI_USER_CONSIDERATIONS.md for production deployment details.
Project Status
Feature | Status |
SDK upgrade (v1.26.0) | ā Complete |
Structured outputs | ā Complete |
Streamable HTTP transport | ā Complete |
Lifespan context | ā Complete |
Elicitation support | ā Complete |
Icons & metadata | š Pending |
Documentation | ā Complete |
See TODO.md for detailed modernization progress.
Contributing
Key areas for contribution:
Additional SDMX provider support
Enhanced semantic search
Performance optimization
Test coverage expansion
References
License
MIT License - See LICENSE file for details.
Available Tools
20 toolsbuild_data_urlA
Generate final SDMX REST API URLs for data retrieval.
Creates URLs that can be used directly to download data in various formats.
This is the final step in the SDMX query construction process.
Args:
dataflow_id: The dataflow to query
key: The data key (use build_key() to construct), or use filters instead
filters: Dictionary of dimension_id -> code (alternative to key)
start_period: Start of time range (optional)
end_period: End of time range (optional)
format_type: Output format (csv, json, xml)
agency_id: The agency (uses session endpoint if not specified)
endpoint: Optional endpoint key (e.g. "FBOS", "ECB") to target a
specific provider for this call only. Defaults to the session's
current endpoint.
Returns:
Structured result with the complete data URL and usage information
Inputs: dataflow_id (required), key, filters, endpoint, +4 more. Returns: Result from build_data_url() tool.
build_keyA
Build a properly formatted SDMX key from dimension values.
This helper tool constructs the key string with dimensions in the correct order
according to the dataflow structure. Unspecified dimensions are left empty
(meaning "all values").
Use this before build_data_url() to ensure your key has the correct format.
Args:
dataflow_id: The dataflow identifier
filters: Optional dict mapping dimension IDs to values
agency_id: The agency (uses session endpoint if not specified)
endpoint: Optional endpoint key (e.g. "FBOS", "ECB") to target a
specific provider for this call only. Defaults to the session's
current endpoint.
Returns:
Structured result with the constructed key and usage information
Inputs: dataflow_id (required), filters, endpoint, agency_id. Returns: Result from build_key() tool.
check_time_availabilityA
Check whether a specific time period is likely to have data in a dataflow.
Uses the Actual ContentConstraint (FREQ values + TimeRange) to quickly
rule out periods that definitely have no data, without querying the data
itself. The constraint only tells us what CAN'T exist ā a "plausible"
result means "worth querying", not "guaranteed to have data".
Use after identifying a dataflow and before building a data URL.
For confirmed availability, query the data directly via build_data_url().
Three-valued result:
- "no": constraint rules this out ā don't bother querying
- "plausible": period within range and frequency matches ā worth trying
- "plausible_different_frequency": data exists in this time window but
at different granularity (e.g. querying monthly but only annual exists)
Args:
dataflow_id: The dataflow to check
query_period: The period to check (e.g. "2010", "2010-Q1", "2010-01", "2010-W05")
agency_id: The agency (uses session endpoint if not specified)
endpoint: Optional endpoint key (e.g. "FBOS", "ECB") to target a
specific provider for this call only. Defaults to the session's
current endpoint.
Returns:
TimeAvailabilityResult with availability classification and reasoning
Inputs: dataflow_id (required), query_period (required), endpoint, agency_id. Returns: Result from check_time_availability() tool.
compare_dataflow_dimensionsA
Compare dimension structures across two dataflows to understand how they relate.
Use this whenever you want to combine or contrast data from two dataflows.
Returns which dimensions are shared, whether their codes overlap, time period
coverage, and recommended join columns. Works across providers too ā e.g.
compare SPC population data with UNICEF child health indicators.
**When to use this tool:**
- After discovering dataflows with find_code_usage_across_dataflows(), compare
them to understand how they can be joined.
- When a user asks about combining datasets from different topics or providers.
- To check geographic, temporal, and dimensional overlap before writing queries.
Supports cross-provider comparison (e.g., SPC vs IMF) by specifying endpoint_a/b.
When endpoints are omitted, uses the current session endpoint.
Args:
dataflow_id_a: First dataflow identifier
dataflow_id_b: Second dataflow identifier
endpoint_a: Optional endpoint key for dataflow A (e.g., "SPC", "IMF", "ECB")
endpoint_b: Optional endpoint key for dataflow B
ctx: MCP context
Returns:
DataflowDimensionComparisonResult with dimension comparison, overlap stats,
and join column recommendations
Inputs: dataflow_id_a (required), dataflow_id_b (required), endpoint_a, endpoint_b. Returns: Result from compare_dataflow_dimensions().
compare_structuresA
Compare two SDMX structures to identify differences.
Supports comparing different structure types with specialized logic:
**Codelists** (`structure_type="codelist"`):
- Compares actual codes (code IDs and names)
- Shows added/removed/renamed codes
- Perfect for: "What codes changed between CL_GEO v1.0 and v2.0?"
**Data Structure Definitions** (`structure_type="datastructure"`):
- Compares codelist/concept scheme references
- Shows version changes in referenced codelists
- Perfect for: "What codelists were updated in DSD v3.0?"
**Dataflows** (`structure_type="dataflow"`):
- Compares structural references (DSD, constraints)
- Perfect for: "What structures do these dataflows share?"
Args:
structure_type: Type of structure to compare:
- "codelist": Compare codes within codelists
- "datastructure" or "dsd": Compare DSD references
- "dataflow": Compare dataflow references
- "conceptscheme": Compare concept schemes
structure_id_a: First structure identifier
structure_id_b: Second structure identifier (defaults to same as A for version comparison)
version_a: Version of first structure (default "latest")
version_b: Version of second structure (default "latest")
agency_id: Agency ID (uses current endpoint's default if not specified)
show_diagram: Generate a Mermaid diff diagram (default True)
endpoint: Optional endpoint key (e.g. "FBOS", "ECB") to target a
specific provider for this call only. Defaults to the session's
current endpoint.
Returns:
StructureComparisonResult with type-specific changes:
- code_changes: For codelist comparisons
- reference_changes: For DSD/dataflow comparisons
- summary: Counts of added/removed/modified/unchanged
- mermaid_diff_diagram: Visual diff diagram
- interpretation: Human-readable explanation
Examples:
# Compare two versions of a codelist - see what codes changed
>>> compare_structures("codelist", "CL_GEO", version_a="1.0", version_b="2.0")
# Compare two different codelists - find intersection/differences
>>> compare_structures("codelist", "CL_FREQ", "CL_TIME_FREQ")
# Compare DSD versions - see what codelist references changed
>>> compare_structures("datastructure", "DSD_SDG", version_a="2.0", version_b="3.0")
# Compare two different DSDs
>>> compare_structures("datastructure", "DSD_SDG", "DSD_EDUCATION")
Inputs: structure_id_a (required), structure_type (required), endpoint, agency_id, +4 more. Returns: Result from compare_structures() tool showing differences between two structureā¦
find_code_usage_across_dataflowsA
Discover all dataflows that have data for a given code.
Use this as your starting point when exploring what data exists for a
country, indicator, or any other code. For example, to find everything
available for Fiji: find_code_usage_across_dataflows("FJ", dimension_id="GEO_PICT").
Searches all constraints in a single API call.
**When to use this tool:**
- "What datasets have data for Vanuatu?" -> code="VU", dimension_id="GEO_PICT"
- "Which dataflows cover GDP indicators?" -> code="GDP", dimension_id="INDICATOR"
- "What data exists for this country across all topics?" -> start here, then use
compare_dataflow_dimensions() to check how the discovered dataflows relate.
**Workflow A -- search by dimension (direct):**
find_code_usage_across_dataflows("FJ", dimension_id="GEO_PICT")
Returns only matches where "FJ" appears in the GEO_PICT dimension.
**Workflow B -- search by codelist (two steps):**
If you know a code belongs to a codelist (e.g., CL_COM_GEO_PICT) but
not which dimensions use it:
1. Call this tool WITHOUT dimension_id to get all dataflows/dimensions
where the code appears.
2. For each matched dataflow, call get_dataflow_structure() to inspect
the DSD and verify which codelist each matched dimension uses.
**Provider support:** Bulk search requires endpoint support. Currently
supported by SPC (Actual), ECB (Allowed), and UNICEF (Actual). Other
endpoints will return a message explaining the limitation.
Args:
code: The specific code to check (e.g., "FJ")
dimension_id: Optional dimension to restrict search (e.g., "GEO_PICT").
If provided, only matches in this dimension are returned.
If omitted, all dimensions are searched.
agency_id: The agency (uses session endpoint if not specified)
endpoint: Optional endpoint key (e.g. "FBOS", "ECB") to target a
specific provider for this call only. Defaults to the session's
current endpoint.
Returns:
CrossDataflowCodeUsageResult with:
- dataflows_with_data: Dataflows where code is actually used
- summary: Counts of usage
Inputs: code (required), endpoint, agency_id, dimension_id. Returns: Result from find_code_usage_across_dataflows() tool.
get_codelistA
Get codes and values for a specific codelist.
Codelists define the allowed values for dimensions (e.g., country codes, commodity codes).
Use this to find the exact codes needed for your data query.
Args:
codelist_id: The codelist identifier
agency_id: The agency (uses session endpoint if not specified)
version: Version (default: "latest")
search_term: Optional search term to filter codes
endpoint: Optional endpoint key (e.g. "FBOS", "ECB") to target a
specific provider for this call only. Defaults to the session's
current endpoint.
Returns:
Dictionary with codelist information and codes
Inputs: codelist_id (required), version, endpoint, agency_id, +1 more. Returns: object
get_code_usageA
Efficiently check if specific codes are actually used in a dataflow's data.
This uses the Actual ContentConstraint (if available) to determine which
codes have real data, WITHOUT iterating through data queries. This is
much faster than trial-and-error data requests.
Use cases:
- "Is country code 'FJ' actually used in DF_SDG?"
- "Which indicator codes have data?" (leave codes empty)
- "Are these 5 codes I want to use valid AND have data?"
Args:
dataflow_id: The dataflow to check
codes: Optional list of specific codes to check. If empty, returns all used codes.
dimension_id: Optional dimension to check. If empty, checks all dimensions.
agency_id: The agency (uses session endpoint if not specified)
endpoint: Optional endpoint key (e.g. "FBOS", "ECB") to target a
specific provider for this call only. Defaults to the session's
current endpoint.
Returns:
CodeUsageResult with:
- codes_checked: List of codes with their usage status
- all_used_codes: All codes that have data (by dimension)
- summary: Counts of used/unused codes
Examples:
>>> get_code_usage("DF_SDG", codes=["FJ", "WS", "XX"], dimension_id="GEO_PICT")
# Checks if Fiji, Samoa, and "XX" have SDG data
>>> get_code_usage("DF_SDG", dimension_id="INDICATOR")
# Returns all indicator codes that actually have data
Inputs: dataflow_id (required), codes, endpoint, agency_id, +1 more. Returns: Result from get_code_usage() tool.
get_current_endpointA
Get information about the currently active SDMX data source.
Shows which statistical organization's API is being used (e.g., Pacific Data,
European Central Bank, UNICEF).
In multi-user deployments, this returns the endpoint for the current session.
Returns:
Current endpoint name, URL, agency ID, and description
Inputs: no named parameters. Returns: Information about an SDMX endpoint.
get_data_availabilityA
Get actual data availability for a dataflow or specific dimension combinations.
This tool is critical for avoiding empty query results. Use it to check
if data exists before building the final data URL.
Args:
dataflow_id: The dataflow to check
filters: Optional dict of dimension=value pairs to check
agency_id: The agency ID
endpoint: Optional endpoint key (e.g. "FBOS", "ECB") to target a
specific provider for this call only. Defaults to the session's
current endpoint.
Returns:
Information about what data exists, including time ranges and suggestions
Inputs: dataflow_id (required), filters, endpoint, agency_id. Returns: Result from get_data_availability() tool.
get_dataflow_structureA
Get detailed structure information for a specific dataflow.
Returns dimensions, attributes, measures, and codelist references.
Use this after list_dataflows() to understand data organization.
Args:
dataflow_id: The dataflow identifier
agency_id: The agency (uses session endpoint if not specified)
endpoint: Optional endpoint key (e.g. "FBOS", "ECB") to target a
specific provider for this call only. Defaults to the session's
current endpoint.
Returns:
Structured result with dataflow metadata and structure definition
Inputs: dataflow_id (required), endpoint, agency_id. Returns: Result from get_dataflow_structure() tool.
get_dimension_codesA
Get codes for a specific dimension of a dataflow.
This allows drilling down into specific dimensions without loading all codelists at once.
Useful for finding valid values for a particular dimension in your data query.
Args:
dataflow_id: The dataflow identifier
dimension_id: The dimension identifier
limit: Maximum codes to return (default: 50)
offset: Number of codes to skip for pagination (default: 0)
agency_id: The agency (uses session endpoint if not specified)
endpoint: Optional endpoint key (e.g. "FBOS", "ECB") to target a
specific provider for this call only. Defaults to the session's
current endpoint.
Returns:
Structured result with codes for the dimension
Inputs: dataflow_id (required), dimension_id (required), limit, offset, +2 more. Returns: Result from get_dimension_codes() tool.
get_metadata_attributeA
Get every value of one reference metadata attribute, with the slice each applies to.
Use after get_reference_metadata() reports drill_down=true for an
attribute, which means more detail remains than the summary shows. This
can happen because the attribute's values differ across the dataflow (for
example recommended-uses text that differs per country), or because a
single value was identical on every row this query returned but drill_down
stays true since other rows queried differently might differ.
Args:
dataflow_id: The dataflow to read
attribute_id: An attribute id from get_reference_metadata()
key: Optional dimension key to narrow the query. Strongly recommended
for large dataflows: an unfiltered request that is too large to
return is reported back rather than guessed at, but supplying a
key (for example a single indicator or reference area) up front
avoids that round trip.
agency_id: The agency that owns the dataflow
endpoint: Optional endpoint key for this call only
Returns:
Every value of the attribute, each with the dimension key it applies to
Inputs: dataflow_id (required), attribute_id (required), key, endpoint, +1 more. Returns: Result from get_metadata_attribute(): one attribute, every value.
get_reference_metadataA
Get reference metadata for a dataflow: source, methodology, licence, caveats.
Reference metadata is the descriptive material about a dataflow rather
than its structure: who compiled it, from what source, under what licence.
Use it to explain or cite data you have retrieved.
Coverage varies by provider and the result says which channels were
available, so an empty answer can be told apart from an unanswerable one.
Args:
dataflow_id: The dataflow to describe
key: Optional dimension key to narrow the query. Strongly recommended
for large dataflows: SPC's DF_SDG is 5.37 MB unfiltered and 5.6 KB
with a partial key.
agency_id: The agency (uses the session endpoint if not specified)
endpoint: Optional endpoint key (e.g. "FBOS", "ECB") to target a
specific provider for this call only. Defaults to the session's
current endpoint.
ctx: MCP context
Returns:
Reference metadata attributes, their provenance, and channel status
Inputs: dataflow_id (required), key, endpoint, agency_id. Returns: Result from get_reference_metadata().
get_structure_diagramA
Generate an SDMX-aware Mermaid diagram for any structural artifact.
The visualization adapts based on the artifact type to show the most
relevant information following the SDMX information model:
**Dataflow**: Shows full SDMX hierarchy (entry point view)
- Dataflow ā DSD ā Components (Dimensions, Attributes, Measure)
- Components ā Concepts (semantic meaning from ConceptSchemes)
- Components ā Representations (Codelists or free text)
**DSD/DataStructure**: Shows component structure + relationships
- Parent dataflows that use this DSD
- Child codelists and concept schemes referenced
**Codelist**: Shows impact/usage view (building block)
- Parent DSDs/dimensions that reference this codelist
- Useful for impact analysis (what breaks if I change this?)
**ConceptScheme**: Shows usage across structures
- Parent DSDs/components that use these concepts
Args:
structure_type: Type of structure - one of:
- "dataflow": Statistical data publication (shows full hierarchy)
- "datastructure" or "dsd": Data Structure Definition
- "codelist": Code list (enumeration of valid values)
- "conceptscheme": Concept scheme (definitions)
- "categoryscheme": Category scheme (classification)
structure_id: The structure identifier
agency_id: Agency ID (uses current endpoint's default if not specified)
version: Version string (default "latest") - query a specific version
direction: Relationship direction to explore (ignored for dataflow):
- "parents": Show structures that USE this one
- "children": Show structures this one REFERENCES
- "both": Show both directions (default)
show_versions: If True, display version numbers on each node
endpoint: Optional endpoint key (e.g. "FBOS", "ECB") to target a
specific provider for this call only. Defaults to the session's
current endpoint.
Returns:
StructureDiagramResult with:
- mermaid_diagram: Ready-to-render Mermaid code
- nodes: All structures in the relationship graph
- edges: Relationships between structures
- interpretation: Human-readable explanation
Examples:
>>> get_structure_diagram("dataflow", "DF_SDG")
# Shows complete SDG dataflow structure with SDMX hierarchy
>>> get_structure_diagram("codelist", "CL_FREQ", show_versions=True)
# Shows what structures use CL_FREQ (impact analysis)
>>> get_structure_diagram("dsd", "DSD_POP", direction="children")
# Shows codelists and concept schemes used by DSD_POP
Inputs: structure_id (required), structure_type (required), version, endpoint, +3 more. Returns: Result from get_structure_diagram() tool with Mermaid visualization.
list_available_endpointsA
List all available SDMX data sources that can be switched to.
Shows all configured statistical data providers (e.g., SPC, ECB, UNICEF)
and indicates which one is currently active for your session.
You don't need to switch endpoints to compare data across providers.
Use compare_dataflow_dimensions(df_a, df_b, endpoint_a="SPC", endpoint_b="ECB")
to directly compare dataflows from different providers.
In multi-user deployments, the current endpoint is session-specific.
Returns:
List of available endpoints with their descriptions and status
Inputs: no named parameters. Returns: Result from list_available_endpoints() tool.
list_dataflowsA
List available SDMX dataflows, optionally filtered by keywords.
This is typically the first step in SDMX data discovery. Returns a list of
statistical domains (dataflows) available from the specified agency.
If you already know a country code or indicator code, consider using
find_code_usage_across_dataflows() instead ā it directly discovers all
dataflows with data for that code, across all topics.
Args:
keywords: Optional keyword string or list of keywords to filter dataflows
agency_id: The agency to query (uses session endpoint if not specified)
limit: Number of results to return (default: 10)
offset: Number of results to skip for pagination (default: 0)
endpoint: Optional endpoint key (e.g. "FBOS", "ECB") to target a
specific provider for this call only. Defaults to the session's
current endpoint.
fresh: Bypass the module-level dataflow listing cache and force a
live re-fetch from the provider. The fetch still refreshes the
cache for other callers. Defaults to False; use True only when
the point of the call is to prove the provider is reachable
right now (a cached answer would say nothing about that).
Returns:
Structured result with dataflows, pagination info, and navigation hints
Inputs: fresh, limit, offset, endpoint, +2 more. Returns: Result from list_dataflows() tool.
probe_data_urlA
Probe an exact SDMX data query and return whether it contains data.
This answers the question that validation and code-usage checks cannot:
does this exact query return observations right now?
Accepts either a complete data URL or structured parameters.
Uses lightweight probing (firstNObservations=1) to minimise payload.
Args:
data_url: Complete SDMX data URL to probe
dataflow_id: Dataflow ID (alternative to data_url)
filters: Dimension filters (alternative to data_url)
start_period: Start time period
end_period: End time period
agency_id: Owning agency when different from the session default.
Required for OECD sub-agency flows (e.g. pass "OECD.STI.STP"
alongside dataflow_id="DSD_RDS_GERD@DF_GERD_SOF"). Only consulted
when data_url is not provided; ignored when data_url is.
sample_observations_limit: Max sample observations to return
max_distinct_values_per_dimension: Max distinct values per dimension summary
timeout_ms: Probe timeout in milliseconds
endpoint: Optional endpoint key (e.g. "FBOS", "ECB") to target a
specific provider for this call only. Defaults to the session's
current endpoint.
Returns:
Probe result with status, observation count, shape, and sample data
Inputs: filters, data_url, endpoint, agency_id, +6 more. Returns: Result from probe_data_url() tool.
suggest_nonempty_queriesA
Suggest nearby non-empty SDMX queries when the original returns no data.
Given an exact query that may be empty, explores bounded relaxations ā
removing one filter at a time ā and returns validated alternatives ranked
by minimal deviation from the original.
Args:
data_url: The exact SDMX data URL to recover from
relax_dimensions: Only relax these dimensions (None = try all)
max_suggestions: Maximum number of suggestions to return
max_probes: Maximum HTTP probes to make (budget)
strategy: Recovery strategy (currently only least_change)
intent_hint: One of generic, kpi, timeseries, ranking, map
endpoint: Optional endpoint key (e.g. "FBOS", "ECB") to target a
specific provider for this call only. Defaults to the session's
current endpoint.
Returns:
Suggestion result with ranked non-empty alternatives
Inputs: data_url (required), endpoint, strategy, max_probes, +3 more. Returns: Result from suggest_nonempty_queries() tool.
validate_queryA
Validate SDMX query parameters before building the final URL.
Checks syntax according to SDMX 2.1 REST API specification.
Validates that dimension codes actually exist in the dataflow.
Args:
dataflow_id: The dataflow to validate against
key: The data key (dimensions separated by dots)
filters: Dictionary of dimension_id -> code (alternative to key)
start_period: Start of time range
end_period: End of time range
agency_id: The agency
endpoint: Optional endpoint key (e.g. "FBOS", "ECB") to target a
specific provider for this call only. Defaults to the session's
current endpoint.
Returns:
Validation results including any errors, warnings, and validated parameters
Inputs: dataflow_id (required), key, filters, endpoint, +3 more. Returns: Result from validate_query() tool.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelogā¦
TDQS
Scored across 20 tools
Most tools have clearly distinct purposes, but several availability-check tools (get_data_availability, get_code_usage, check_time_availability, probe_data_url) overlap in function and could lead to misselection without careful description reading. The descriptions themselves disambiguate well, so the issue is mild.
All tool names follow a consistent snake_case verb_noun pattern (get_, list_, check_, find_, compare_, validate_, build_, probe_, suggest_). No mixed conventions or vague verbs like 'process' or 'do_thing'.
20 tools is slightly heavy but justified for a comprehensive SDMX gateway covering discovery, structure, availability, query construction, metadata, visualization, and endpoint management. Each tool serves a defined role, though some could arguably be merged.
The tool surface covers the full SDMX data workflow: discovery (list_dataflows, find_code_usage_across_dataflows), structure inspection, availability checks, query building/validation, URL generation, probing, recovery from empty results, reference metadata, and endpoint management. No obvious dead ends or missing core operations for its stated purpose.
Maintenance
Related MCP Connectors
Hosted MCP server for live public-data APIs and Skills for AI agents.
MCP server for building and testing AI agents with multi-model experimentation and insights.
AgencyAI's public MCP for service discovery and AI-readiness assessment.
MCP server connecting AI agents to non-custodial staking data across 130+ networks.
Related MCP Servers
- AlicenseBqualityDmaintenanceA model Context Protocol (MCP) server that provides comprehensive OECD statistics through the SDMX API, supporting AI assistants and chatbots to query OECD datasets in areas such as economy, health, education, and environment.92Apache 2.0
- FlicenseNot gradedqualityDmaintenanceMCP server that lets AI agents discover and call R and Python statistical functions without writing code.-
- AlicenseAqualityCmaintenanceAn MCP server that lets AI assistants discover and retrieve official statistics from SDMX services, returning actual data observations rather than just query URLs.41Apache 2.0
- AlicenseAqualityDmaintenanceMCP server serving official statistics from major data agencies (Statistics Canada, FRED, BLS, World Bank, etc.) as tools with provenance and verification, enabling search, retrieval, analysis, and monitoring via natural language.1157 npmMIT