Government of Canada Open Data MCP Servers

Python-based Model Context Protocol (MCP) servers for accessing Canada's Open Government data. This project includes two complementary MCP servers:

1. GOV CA DATASET MCP - Universal dataset discovery, search, and metadata retrieval across all Canadian government open data
2. GOV CA TRANSPORTATION MCP - Specialized infrastructure querying for bridges, tunnels, airports, ports, and railways with Statistics Canada cost data

Features

Dataset Discovery (gov_mcp)

• Search across 250,000+ datasets from Open Government Canada
• Browse by topic, organization, or jurisdiction (federal/provincial/municipal)
• Get detailed dataset schemas and download URLs
• Track recent dataset updates

Transportation Infrastructure (gov_ca_transportation)

• Query bridge conditions using Statistics Canada national data for all provinces
• Get infrastructure replacement costs from Statistics Canada surveys
• Search airports and ports across Canada
• Query railway infrastructure
• Search tunnels by province and type
• Unified data approach: Uses Statistics Canada Core Public Infrastructure Survey for consistent national coverage

Quick Start

Installation

# Clone and install
cd gov_mcp
pip install -e .

# Or install dependencies directly
pip install -r requirements.txt

Running the Servers

# Dataset Discovery MCP
python -m gov_mcp.server

# Transportation Infrastructure MCP  
python -m gov_ca_transportation.server

Docker Deployment

Both MCP servers can be run as Docker containers individually or together using Docker Compose.

Using Docker Compose (Recommended)

# Start all servers
docker-compose up

# Start in background (detached mode)
docker-compose up -d

# Start a specific server
docker-compose up gov-ca-dataset
docker-compose up gov-ca-transportation

# View logs
docker-compose logs -f

# Stop all servers
docker-compose down

Building Individual Docker Images

# Build Dataset Discovery MCP
docker build -f gov_mcp/Dockerfile -t gov-ca-dataset-mcp .

# Build Transportation Infrastructure MCP
docker build -f gov_ca_transportation/Dockerfile -t gov-ca-transportation-mcp .

Running Individual Containers

# Run Dataset Discovery MCP (port 8002)
docker run -d --name gov-ca-dataset -p 8002:8002 gov-ca-dataset-mcp

# Run Transportation Infrastructure MCP (port 8001)
docker run -d --name gov-ca-transportation -p 8001:8001 gov-ca-transportation-mcp

Docker Endpoints

SSE (Server-Sent Events) Transport

Both MCP servers support an SSE transport for HTTP-based streaming. Start either server with the --sse flag and a port argument to enable the SSE endpoint:

# Start Transportation MCP with SSE on port 8001
python -m gov_ca_transportation.server --sse --port 8001

# Start Dataset Discovery MCP with SSE on port 8002
python -m gov_mcp.server --sse --port 8002

When SSE is enabled, the server logs the SSE endpoint (e.g., http://0.0.0.0:8001/sse). You can connect to that endpoint using a web client, curl, or a Python SSE client.

Example connections:

• Curl (raw stream):

curl -H "Accept: text/event-stream" -N http://localhost:8001/sse

• JavaScript (EventSource):

const es = new EventSource("http://localhost:8001/sse");
es.onmessage = (e) => console.log("SSE message:", e.data);
es.onerror = (err) => console.error("SSE error:", err);

• Python (httpx-sse):

from httpx_sse import EventSource

with EventSource("http://localhost:8001/sse") as event_source:
  for event in event_source:
    # event is an object with .event, .data, .id
    print(event.data)

Notes:

• The SSE endpoint serves MCP events and results over HTTP for compatible clients.
• The MCP server will print the SSE endpoint URL and port when started with --sse.
• SSE-based transports require client support for Server-Sent Events (EventSource), or using Python/HTTP libraries with SSE support like httpx-sse.

Architecture

gov_mcp/                          # Dataset Discovery MCP
├── server.py                     # MCP server with 7 tools
├── api_client.py                 # Open Government Canada API wrapper
├── http_client.py                # HTTP client with retry logic
└── types.py                      # Type definitions

gov_ca_transportation/            # Transportation Infrastructure MCP
├── server.py                     # MCP server with 7 tools
├── api_client.py                 # Statistics Canada + provincial data fetching
├── http_client.py                # HTTP client
└── types.py                      # Type definitions

Data Sources

The Transportation MCP uses Statistics Canada as the primary data source for national coverage:

Available Tools

Dataset Discovery MCP (gov_mcp) - 7 Tools

Transportation Infrastructure MCP (gov_ca_transportation) - 7 Tools

Example Usage

Search for Datasets

# Search for water datasets in Saskatchewan
result = search_datasets(query="water Saskatchewan", limit=20)
# Returns 103 datasets including water quality monitoring data

Analyze Bridge Conditions

# Get bridge conditions for any province using Statistics Canada data
result = analyze_bridge_conditions(region="Saskatchewan")
# Returns: Very Poor: 2.4%, Poor: 16.4%, Fair: 23.7%, Good: 32.4%, Very Good: 10.1%

Get Infrastructure Costs

# Get bridge replacement costs for Ontario
result = get_infrastructure_costs(infrastructure_type="bridge", location="Ontario")
# Returns: Total $81.4B, Priority investment needed: $2.65B (Poor + Very Poor)

Query Bridges

# Get bridge data with StatCan condition distribution
result = query_bridges(province="Ontario", limit=100)
# Returns condition summary + detailed records from provincial sources

Project Structure

gov_mcp/
├── gov_mcp/                    # Dataset Discovery MCP
│   ├── __init__.py
│   ├── server.py               # MCP server
│   ├── api_client.py           # API wrapper
│   ├── http_client.py          # HTTP client
│   ├── types.py                # Type definitions
│   └── Dockerfile              # Docker build for this server
├── gov_ca_transportation/      # Transportation MCP
│   ├── __init__.py
│   ├── server.py               # MCP server
│   ├── api_client.py           # StatCan + provincial data fetcher
│   ├── http_client.py          # HTTP client
│   ├── types.py                # Type definitions
│   └── Dockerfile              # Docker build for this server
├── tests/                      # Test files
├── documentation/              # Additional docs
├── docker-compose.yml          # Docker Compose for all servers
├── .dockerignore               # Docker ignore file
├── pyproject.toml              # Project config
├── requirements.txt            # Dependencies
└── README.md                   # This file

Configuration

VS Code MCP Settings

Add to your VS Code settings.json or MCP config:

{
  "mcpServers": {
    "gov-ca-dataset": {
      "command": "python",
      "args": ["-m", "gov_mcp.server"],
      "cwd": "/path/to/gov_mcp"
    },
    "gov-ca-transportation": {
      "command": "python", 
      "args": ["-m", "gov_ca_transportation.server"],
      "cwd": "/path/to/gov_mcp"
    }
  }
}

Development

Running Tests

pytest tests/

Running Validation

python validate.py

Key Capabilities

• 250,000+ datasets searchable from Open Government Canada
• Statistics Canada integration for authoritative national infrastructure data
• All provinces covered for bridge conditions and infrastructure costs
• Real infrastructure data from provincial/municipal open data portals
• Multiple data formats: GeoJSON, CSV, ZIP (StatCan)
• Condition analysis: Bridge condition percentages, replacement costs by condition
• Geographic filtering: By province or national aggregate

API Sources

License

MIT License - See LICENSE file for details

Contributing

Contributions are welcome! Please:

1. Fork the repository
2. Create a feature branch
3. Add tests for new functionality
4. Submit a pull request