# Road511 MCP

> Road511 gives your agent real-time traffic data across US and Canada. It pulls incident reports, live camera feeds, road conditions, and infrastructure details (like EV chargers and rest areas) into one API. Your AI client can track accidents, analyze congestion patterns over time, and map all this data using GeoJSON. Stop jumping between state 511 websites—your agent handles the whole continent's traffic info from a single conversation.

## Overview
- **Category:** data-analytics
- **Price:** Free
- **Tags:** traffic-data, incident-reporting, real-time-monitoring, geojson, infrastructure-analytics, weather-alerts

## Description

Listen up. This isn't some fluffy API for checking a single street corner. The **Road511 MCP Server** feeds your agent real-time traffic data across the whole US and Canada. It pulls everything—accidents, construction, camera locations, even where the EV chargers are—and funnels it into one place. You don't jump between state 511 websites anymore; your agent handles the entire continent from a single conversation.

When you use this server, your agent performs several critical jobs:

**Tracking Active Incidents and Closures:** Your agent pulls active reports on accidents, construction zones, closures, and advisories across US and Canadian highways using `get_events`. You can filter those events by whatever criteria you need. For mapping purposes, it returns *all* current traffic incidents in ready-to-plot **GeoJSON** format via `get_events_geojson`.

**Mapping Infrastructure Details:** If you're building a map layer, you don't have to piece things together. You get general infrastructure details—like camera spots, rest areas, and road surface status—for every jurisdiction using `get_features`. For mapping tools, it packages all the road infrastructure features, including cameras, weather data, and EV chargers, into **GeoJSON** format through `get_features_geojson`.

**Analyzing Performance & Patterns:** You need to know if traffic problems are getting better or worse. Your agent analyzes incident counts over time using `get_trends`, giving you reports on frequency or severity changes for operational reporting. It also calculates median resolution times (the P50/P95 metrics) showing how long different types of incidents usually take to clear, broken down by region and type—that’s what `get_clearance` does.

**Monitoring System Reliability:** You never want your data feed dropping out. Your agent checks the overall API status, response times, and connectivity for all underlying data sources across every single jurisdiction using `get_health`. For a quick overview, `get_summary` gives you a high-level count and health check on all incidents, camera feeds, and data source statuses nationwide.

You'll use these tools to map everything: from the real-time event details found with `get_events`, to plotting infrastructure points using `get_features`. You’re tracking more than just accidents; you're building a comprehensive operational picture of North American travel. It’s all about getting that actionable data directly into your workflow, period.

## Tools

### get_clearance
Retrieves the P50/P95 metrics for how long traffic incidents take to clear, segmented by type and region.

### get_events_geojson
Returns all traffic events in GeoJSON format, making the data ready to plot directly onto a mapping application.

### get_events
Gets a list of active incidents, construction zones, closures, and advisories across US and Canada based on filters you provide.

### get_features_geojson
Returns all road infrastructure features—cameras, weather data, chargers—in GeoJSON format for mapping tools.

### get_features
Pulls general infrastructure details like camera locations, rest areas, and road surface status by jurisdiction.

### get_health
Checks the overall API status, response times, and connectivity of the underlying data sources across multiple states.

### get_summary
Provides a high-level count and health check on all incidents, camera feeds, and data source statuses nationwide.

### get_trends
Analyzes traffic incident counts over time, showing trends in severity or frequency for operational reporting.

## Prompt Examples

**Prompt:** 
```
Show me all active traffic incidents on I-5 in California.
```

**Response:** 
```
Querying Road511 for incidents on I-5 in California... I found 7 active events: Major accident at mile marker 342 near Grapevine — 2 lanes blocked, CHP on scene, estimated clearance 45 minutes. Construction zone between Bakersfield and Lost Hills — right lane closed until 6 PM, expect 15-minute delays. Disabled vehicle at mile marker 198 near Coalinga — shoulder blocked, tow truck dispatched. Weather advisory for mountain sections — chains required, reduce speed. Plus 3 additional minor incidents with minimal impact. Would you like me to plot these on a map or suggest alternate routes?
```

**Prompt:** 
```
Find traffic cameras near downtown Seattle.
```

**Response:** 
```
Searching for traffic cameras near downtown Seattle (lat: 47.6062, lon: -122.3321)... Found 14 active cameras within 10km radius: I-5 at Mercer Street — live feed available, currently showing moderate congestion. SR-99 at Aurora Bridge — live feed available, free-flowing traffic. I-90 at Mount Baker Tunnel — live feed available, heavy eastbound traffic. SR-520 floating bridge — 3 cameras, moderate westbound flow. Plus 10 additional cameras covering major intersections and highway interchanges. All cameras operational with live video feeds. Would you like direct links to any specific camera feed?
```

**Prompt:** 
```
What is the overall traffic health across all states right now?
```

**Response:** 
```
Fetching Road511 system summary... Currently tracking across 65 jurisdictions (50 US states + 13 Canadian provinces). Active incidents: 1,247 (312 major, 523 moderate, 412 minor). Construction zones: 892 active. Closures: 67 active. Data source health: 61 of 65 jurisdictions reporting healthy, 3 degraded, 1 temporarily down. Average data freshness: 2.3 minutes. Camera network: 8,456 active feeds operational. API response time: 142ms average. Would you like a breakdown by specific state or incident type?
```

## Capabilities

### Track Real-Time Incidents
The agent retrieves active accident reports, construction zones, and closures across US and Canadian highways.

### Map Infrastructure Data
You get coordinates and details for cameras, rest areas, and EV chargers in a ready-to-use GeoJSON format.

### Analyze Incident Performance
The agent calculates median resolution times (P50/P95) based on incident type and location data.

### Monitor System Health
You check the API's reliability, data source connectivity status, and last update timestamps for all 65 jurisdictions.

### Identify Traffic Patterns
The agent generates time-series reports showing if incident counts or specific congestion types are increasing or decreasing over a period.

## Use Cases

### Pre-trip route optimization for a delivery driver
The coordinator needs to send a truck across three states. They ask their agent: 'What's the traffic picture on I-80 from Chicago to Denver?' The agent runs `get_events`, pulling real-time closures and accidents, then combines that with live camera feeds (via `get_features_geojson`) to issue a precise alternate route plan.

### Assessing local government performance
A city planner needs data for a grant application. They ask the agent: 'How fast are major incidents clearing in this metropolitan area?' The agent runs `get_clearance`, providing P50/P95 resolution times by incident type, giving them quantifiable metrics.

### Planning a large-scale field event
The organizer needs to know where key infrastructure points are. They ask: 'Show me all available rest areas and weigh stations along the route.' The agent uses `get_features`, providing coordinates for planning logistics stops.

### Analyzing seasonal traffic risk
The safety director needs to know if accident rates are changing. They ask: 'Are major incidents increasing in Texas this quarter?' The agent runs `get_trends` to give a time-series analysis, helping them adjust staffing levels.

## Benefits

- [object Object]
- [object Object]
- [object Object]
- [object Object]
- [object Object]

## How It Works

The bottom line is: you tell your AI client what traffic problem you have, and it runs the necessary tools to get the answer.

1. Subscribe to the server and input your Road511 API key.
2. Your AI client calls the desired tool (e.g., `get_events`) with specific parameters like a state name or highway number.
3. The server executes the query, returns structured data (like GeoJSON), and your agent presents it in plain language.

## Frequently Asked Questions

**How do I check if the Road511 API is working right now?**
Run `get_health`. This tool checks the system's current status, response times, and data source connectivity across all 65 jurisdictions. It's your first diagnostic step.

**I need to plot traffic events on a map. Which tool should I use?**
`get_events_geojson` is what you want. It returns all incident and event properties packaged in GeoJSON format, which mapping tools read directly without extra work.

**How do I find out how long an accident typically takes to clear?**
You use `get_clearance`. This tool calculates the median (P50/P95) resolution time for incidents, letting you benchmark performance by incident type or region.

**What if I need data on infrastructure like cameras and chargers?**
Use `get_features` or `get_features_geojson`. These tools gather general infrastructure details—cameras, rest areas, EV stations—and give them to you in a structured format.

**I want to know if congestion is worsening this quarter. Which tool shows trends?**
`get_trends` analyzes incident counts over time. It gives you data on trend direction (increasing, decreasing) and peak times for analytical reporting.

**How do I use the `get_events` tool to filter for a specific combination of severity, type, and jurisdiction?**
You pass multiple parameters to the `get_events` tool. You specify criteria like 'severity,' 'type' (e.g., construction), and a 'jurisdiction' code (like CA). This ensures your query pulls only the precise events you need for focused analysis, rather than all traffic in that area.

**What is the difference between using `get_events` and `get_features` when querying data?**
`get_events` tracks dynamic incidents—things like accidents or closures. Use it for real-time changes. If you just need static infrastructure details—like camera locations, rest areas, or general road status—then `get_features` provides that core location and type data.

**What should my AI agent do if I exceed the API rate limits when calling these tools?**
If your agent hits a rate limit, it needs to pause before retrying. The system will return a specific error code indicating how long you must wait. Your client must implement an exponential backoff strategy; continuous calls during this cooldown period won't work.

**Can my AI check for traffic incidents on a specific highway like I-405 in California?**
Yes! Use the `get_events` tool with road=I-405 and jurisdiction=CA to filter incidents specifically on that highway. You can further filter by type (incidents, construction, closures) and severity (minor, moderate, major, critical). The results include incident descriptions, affected lanes, estimated clearance times, and alternate route suggestions. For mapping visualization, use `get_events_geojson` to get the same data in GeoJSON format ready for Mapbox or Leaflet.

**How do I find traffic cameras and EV charging stations along my route?**
Use the `get_features` tool with type=cameras to find all traffic cameras in a jurisdiction, or type=ev_chargers for EV charging stations. You can filter by bounding box (bbox) or by radius from a lat/lon point. For mapping applications, use `get_features_geojson` which returns data in GeoJSON format ready for direct integration with mapping libraries. Camera features include live stream URLs and road conditions include surface status and weather impacts.

**Can I analyze traffic incident trends to understand if traffic is getting worse in my state?**
Absolutely! Use `get_trends` with your jurisdiction code (e.g., jurisdiction=CA for California) to get time-series incident data showing whether incidents are increasing, decreasing, or stable over time. Use `get_clearance` to understand how quickly incidents are being resolved (P50 median and P95 resolution times). Combined with `get_summary` for current snapshot data, you can build comprehensive traffic safety and efficiency reports. This is perfect for transportation planning, resource allocation, and operational performance benchmarking.