Overview

This MCP (Model Context Protocol) server lets developers discover and retrieve context about datasets listed in the AWS Open Data Registry. It exposes a small HTTP service that performs fuzzy search across the registry metadata, ranks matches, and returns structured dataset details in a format suitable for retrieval-augmented generation (RAG) or other model-context workflows.

By providing fuzzy matching and detailed dataset payloads, the server helps bridge the gap between natural-language prompts and the structured records in the AWS Open Data Registry. You can use it as a retrieval layer in LLM applications, data exploration tools, or automation scripts that need to locate datasets by partial names, keywords, or descriptions.

Features

Fuzzy text search across AWS Open Data Registry metadata (title, description, tags)
Scored results and relevance ranking to support retrieval pipelines
Detailed dataset payloads: title, description, contact, formats, links, and preview snippets
MCP-compatible endpoints (manifest + query/resolution) for easy integration with LLM toolchains
Caching and pagination to keep responses fast and manageable
Docker and local development options for quick deployment
Simple JSON API; easy to call from applications, scripts, or other services

Installation / Configuration

Clone the repository and run the server locally or inside Docker. The examples below show common install paths; adjust commands to match the actual repo layout or toolchain used in your environment.

Clone the repo

git clone https://github.com/domdomegg/aws-open-data-mcp.git
cd aws-open-data-mcp

2a) Local Python environment (example)

python -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt
# configure environment variables, then:
export MCP_PORT=8080
export CACHE_PATH="./cache"
python -m aws_open_data_mcp.app

2b) Docker

# build
docker build -t aws-open-data-mcp:latest .

# run with environment variables
docker run -p 8080:8080 \
  -e MCP_PORT=8080 \
  -e CACHE_PATH=/data/cache \
  -v $(pwd)/cache:/data/cache \
  aws-open-data-mcp:latest

Configuration environment variables (examples)

MCP_PORT=8080              # HTTP port for the server
CACHE_PATH=./cache         # Local cache directory for registry snapshots
REGISTRY_URL=<optional>    # Custom AWS Open Data Registry endpoint (if needed)
LOG_LEVEL=info             # Logging verbosity

Note: The server can optionally refresh a local snapshot of the AWS Open Data Registry. Set a refresh cadence in configuration or trigger manual updates via the provided admin endpoint (if included).

Available Resources

The server exposes a concise JSON API. Below is a typical set of endpoints and their purpose:

Endpoint	Method	Description
/mcp/manifest	GET	Returns the MCP manifest describing this retrieval tool (required by MCP clients)
/mcp/query	POST	Query the registry with a text prompt; returns scored search results and metadata snippets
/datasets/{id}	GET	Retrieve full dataset record and links by dataset identifier
/health	GET	Health check for orchestration and readiness

Example: fuzzy search request

curl -X POST http://localhost:8080/mcp/query \
  -H "Content-Type: application/json" \
  -d '{"query":"satellite imagery wildfire California", "limit":5}'

Example response (abbreviated)

{
  "results": [
    {
      "id": "dataset-123",
      "title": "Landsat Collection",
      "score": 92,
      "snippet": "Multispectral Landsat imagery for US and global coverage...",
      "links": ["https://registry.opendata.aws/landsat/"]
    }
  ]
}

Use Cases

Retrieval-augmented generation (RAG): Use the MCP server as the retrieval component that supplies model context (dataset descriptions, sample records, links) in response to natural-language prompts.
Data discovery for analysts: Quickly find relevant AWS Open Data datasets when a team member describes a problem in plain English (e.g., “high-resolution elevation data for Colorado”).
Automated dataset linking: Enrich metadata pipelines by programmatically resolving partial dataset names to registry records (useful for catalog curation).
Prototype dataset-aware assistants: Build chatbots or developer tools that answer questions like “Which open datasets cover US precipitation?” and return direct registry links.
Pre-filtering for pipelines: Use fuzzy scoring to select candidate datasets for downstream processing (ETL, indexing, or model fine-tuning).

Notes and Best Practices

Caching: Enable the cache to avoid repeated registry fetches; refresh periodically to pick up new datasets.
Query tuning: Experiment with fuzzy-matching thresholds and tokenization to optimize recall vs precision for your domain.
Security: If exposing the server publicly, secure it with an API gateway or authentication layer and limit refresh or admin endpoints.
Integration: Consume the /mcp/manifest endpoint to programmatically discover how to call the service from MCP-aware clients and orchestrators.

For code samples, advanced configuration, and contribution guidelines, consult the repository source and the included documentation in the GitHub project.

AWS Open Data MCP Server: Fuzzy Dataset Search