transit-mcp
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., "@transit-mcpWhat time is the next northbound Blue Line train at Lake Street?"
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.
transit-mcp ๐
Multi-city US Public Transit Model Context Protocol (MCP) server & interactive CLI supporting 13 major metro systems and county networks: Minneapolis-St. Paul (Metro Transit), Boston (MBTA), SF Bay Area (BART), San Francisco (Muni), East Bay (AC Transit), Chicago (CTA), Portland (TriMet), Washington D.C. (WMATA), Montgomery County (Ride On), Fairfax County (Connector), Atlanta (MARTA), Miami (Miami-Dade Transit), and Nashville (WeGo).
Connect any AI assistant (Claude Desktop, Cursor, Antigravity, Claude Code, Windsurf) to live public transit schedules, real-time vehicle countdowns, platform assignments, route stops, and active service disruption alerts.
๐ Supported Cities & Transit Agencies
City / Region | Identifier | Agency | Transit Modes | Bus Coverage | Real-time Departures | Alerts | Open API Access |
Minneapolis-St. Paul |
| Metro Transit | METRO Blue & Green Lines, BRT, Northstar | 100% (100+ local, express, & BRT lines) | โ Live NexTrip | โ Live | 100% Open ( |
Boston |
| MBTA | Subway (Red, Orange, Blue), Green Line, Commuter Rail, Ferry | 100% (All 170+ MBTA bus routes) | โ Live v3 | โ Live | Open v3 REST API ( |
Chicago |
| CTA | "L" Subway & Elevated (Red, Blue, Brn, G, Org, Pink, P, Y) | 100% (All 127 CTA bus routes) | โ Headway / Live | โ Live XML | Open alerts & system feeds ( |
Portland |
| TriMet | MAX Light Rail, Portland Streetcar, WES Rail | 100% (All 80+ TriMet bus routes) | โ Headway / Live | โ Live | Public TriMet feeds ( |
Washington D.C. |
| WMATA | Metrorail (Red, Blue, Orange, Silver, Green, Yellow) | 100% (All 85+ Metrobus routes in DC/MD/VA) | โ Live / Scheduled | โ Live Incidents | WMATA API ( |
Montgomery County (MD) |
| MCDOT Ride On | Flash BRT (Orange, Blue), Ride On extRa (101) | 100% (All 60+ Ride On local & express lines) | โ Live / Scheduled | โ Live | MCDOT Open Data / Scheduled Headways |
Fairfax County (VA) |
| FCDOT Connector | Express Bus (I-66/I-495 HOV), Metro Feeders | 100% (All 45+ Fairfax Connector lines) | โ Live / Scheduled | โ Live | FCDOT Open Data / Scheduled Headways |
San Francisco |
| SFMTA (Muni) | Muni Metro (J, K, L, M, N, T), Cable Cars, Streetcars (E, F) | 100% (All 55+ Muni Rapid, trolleybus, & local buses) | โ Live / Scheduled | โ Live | 511.org REST API / Scheduled Headways |
East Bay (Oakland / Berkeley) |
| AC Transit | Tempo BRT (Line 1T), Transbay Express Buses | 100% (All 70+ Transbay, East Bay local, & All-Nighter buses) | โ Live / Scheduled | โ Live | AC Transit REST API / Scheduled Headways |
Atlanta |
| MARTA | Heavy Rail (Red, Gold, Blue, Green), Atlanta Streetcar | 100% (All 95+ MARTA bus routes) | โ Live / Scheduled | โ Live | MARTA Realtime API ( |
Miami |
| Miami-Dade Transit | Metrorail (Orange, Green), Metromover (3 loops) | 100% (All 80+ Metrobus routes) | โ Scheduled Headways | โ Live | MDT Open Data feeds ( |
Nashville |
| WeGo Public Transit | WeGo Star Commuter Rail | 100% (All 40+ WeGo bus & BRT Lite routes) | โ Scheduled Headways | โ Live | WeGo Public Transit ( |
SF Bay Area |
| BART | Heavy Rail / Rapid Transit, OAK Airport Connector | Rail network (See Muni & AC Transit for regional buses) | โ Live ETD | โ Live BSA | Open REST API with universal key |
๐ Bus Coverage & Known Regional Agency Gaps
Every supported municipal transit agency provides 100% comprehensive bus route coverage across all active lines. When working across metropolitan areas, note the following agency divisions:
San Francisco Bay Area:
BART (
sf_bart): Regional rapid rail spine connecting San Francisco, East Bay, San Mateo, and San Jose.SF Muni (
sf_muni): Complete San Francisco municipal bus, trolleybus, Muni Metro light rail, historic streetcar, and cable car network.AC Transit (
ac_transit): Complete East Bay municipal bus network, Tempo 1T BRT corridor, Transbay express network into Salesforce Transit Center, and All-Nighter service.Known External Gaps: Regional suburban carriers SamTrans (San Mateo) and VTA (Santa Clara / Silicon Valley) remain independent county agencies.
Washington D.C. Capital Region:
WMATA (
dc): Regional Metrorail rapid transit system and interstate Metrobus routes across DC, Maryland, and Virginia.Montgomery County Ride On (
ride_on): Full Montgomery County (MD) feeder network, Flash BRT corridors, and Ride On extRa express lines.Fairfax Connector (
fairfax_connector): Full Fairfax County (VA) feeder network, I-66/I-495 Express Lanes buses, and Reston/Tysons Silver Line feeders.Known External Gaps: Prince George's County TheBus (MD) and City of Alexandria DASH (VA) operate as separate municipal agencies.
Chicago Regional Suburbs:
CTA (
chicago): All 8 CTA "L" rapid transit lines and all 127 CTA city bus routes.Known External Gaps: Suburban buses outside Chicago city limits operated by Pace Suburban Bus and commuter rail operated by Metra are independent agencies.
Related MCP server: MBTA MCP Server
๐ Quick Start
Run CLI via npx (No Install Required)
# List supported cities
npx transit-mcp cities
# View routes in Minneapolis-St. Paul
npx transit-mcp routes --city msp blue
# Get live departures for Embarcadero station in SF
npx transit-mcp departures --city sf_bart EMBR
# View active MBTA subway alerts in Boston
npx transit-mcp alerts --city boston RedGlobal Installation
npm install -g transit-mcp
# Now use the friendly 'transit' command anywhere:
transit cities
transit departures --city msp 51405
transit alerts --city chicago๐ค MCP Client Configuration
transit-mcp connects over stdio following the official Model Context Protocol.
Claude Desktop
Add transit-mcp to your claude_desktop_config.json:
macOS:
~/Library/Application Support/Claude/claude_desktop_config.jsonWindows:
%APPDATA%\Claude\claude_desktop_config.json
{
"mcpServers": {
"transit": {
"command": "npx",
"args": ["-y", "transit-mcp"]
}
}
}Or with a local build:
{
"mcpServers": {
"transit": {
"command": "node",
"args": ["E:/Development/transit-mcp/dist/index.js"]
}
}
}Cursor IDE
Add to .cursor/mcp.json in your project or global Cursor Settings (Cursor Settings -> Features -> MCP Servers):
{
"mcpServers": {
"transit": {
"command": "npx",
"args": ["-y", "transit-mcp"]
}
}
}Claude Code
claude mcp add transit -- npx -y transit-mcp๐ ๏ธ MCP Tools Reference
The server exposes 5 unified MCP tools available across all supported cities:
1. list_supported_cities
Returns metadata for all available cities, agencies, transit modes, and capabilities.
Inputs: None
Returns: Array of
SupportedCityInfo
2. list_routes
Lists transit routes/lines for a supported city with optional text search filtering.
Inputs:
city(string, required): City identifier or alias (e.g.'msp','boston','sf_bart','chicago','portland')query(string, optional): Filter by line name, color, or number (e.g.'Red','Blue','66')
Returns: Array of
TransitRoutewith ID, short name, long name, and mode
3. get_route_stops
Retrieves stops and stations along a specific transit route.
Inputs:
city(string, required): City identifier or aliasroute_id(string, required): Route or line identifier (e.g.'901','Red','12','100')direction(string or number, optional): Direction identifier (e.g.'0','1','Northbound','Inbound')
Returns: Array of
TransitStopwith IDs, names, and GPS coordinates
4. get_departures
Fetches real-time departures, live countdown minutes, platform assignments, delay information, and trip destinations.
Inputs:
city(string, required): City identifier or aliasstop_id(string, required): Stop ID, place code, or station name (e.g.'51405'or'MAAM'for MSP;'place-sstat'or'Alewife'for Boston;'EMBR'or'Embarcadero'for BART;'40380'or'Clark/Lake'for CTA;'8334'or'Pioneer Courthouse Square'for TriMet)
Returns: Array of
TransitDeparturewith countdowns, status, destinations, and timestamps
5. get_service_alerts
Retrieves active service disruptions, elevator outages, maintenance notices, and delay advisories.
Inputs:
city(string, required): City identifier or aliasroute_id(string, optional): Specific route to filter alerts
Returns: Array of
TransitAlertwith severity (info,warning,severe), headline, description, and affected routes
๐ป CLI Commands & Examples
1. transit cities
Lists all supported cities with agency information and features:
transit cities2. transit routes --city <city> [query]
Find routes and lines in a city:
# Search for Blue Line in Minneapolis-St. Paul
transit routes --city msp blue
# Search for Red Line in Boston MBTA
transit routes --city boston Red
# Search for CTA 'L' routes in Chicago
transit routes --city chicago
# Search for BART routes in the SF Bay Area
transit routes --city sf_bart
# Search for Metrorail lines in Washington D.C.
transit routes --city dc
# Search for MARTA rail in Atlanta
transit routes --city atl Red
# Search for Metromover loops in Miami
transit routes --city mia Mover
# Search for WeGo Star in Nashville
transit routes --city bna Star3. transit departures --city <city> <stop>
Inspect real-time departures:
# Minneapolis Mall of America Station
transit departures --city msp 51405
# SF Embarcadero BART Station
transit departures --city sf_bart EMBR
# Boston South Station MBTA
transit departures --city boston place-sstat
# Chicago Clark/Lake CTA 'L' Station
transit departures --city chicago 40380
# Portland Pioneer Courthouse Square
transit departures --city portland 8334
# Washington D.C. Metro Center WMATA Station
transit departures --city dc A01
# Atlanta Airport MARTA Station
transit departures --city atl AIR
# Miami Government Center Metrorail/Metromover Station
transit departures --city mia GOVT
# Nashville Riverfront Commuter Rail Station
transit departures --city bna RIV4. transit alerts --city <city> [route]
Check active service advisories:
transit alerts --city sf_bart
transit alerts --city chicago red
transit alerts --city boston Green
transit alerts --city dc RD
transit alerts --city atl5. transit mcp
Launches the MCP server over stdio (used by LLM desktop agents).
โ๏ธ Environment Variables (Optional)
All supported cities function out-of-the-box using official public endpoints. For higher rate limits or specialized hardware feeds, the following environment variables can optionally be set:
Variable | Agency | Purpose | Default |
| BART (SF) | Custom BART developer key |
|
| MBTA (Boston) | Higher rate limits for MBTA v3 REST API | None (Open access) |
| CTA (Chicago) | Direct CTA Train Tracker GPS hardware feed | None (Uses scheduled headways + open XML alerts) |
| TriMet (Portland) | Direct developer.trimet.org live arrivals feed | None (Uses scheduled headways + open feeds) |
| WMATA (DC) | Direct WMATA Developer API key | None (Uses scheduled headways & public advisories) |
| Ride On (Montgomery Co, MD) | Direct Montgomery County Open Data live predictions | None (Uses high-frequency scheduled headways) |
| Fairfax Connector (VA) | Direct Fairfax County Connector predictions feed | None (Uses high-frequency scheduled headways) |
| SF Muni (SFMTA) | Direct 511.org StopMonitoring live prediction feed | None (Uses high-frequency scheduled headways) |
| AC Transit (East Bay) | Direct AC Transit actrealtime prediction feed | None (Uses high-frequency scheduled headways) |
| MARTA (Atlanta) | Direct MARTA Realtime REST API key | None (Uses scheduled headways & public feeds) |
๐๏ธ Project Architecture
transit-mcp/
โโโ src/
โ โโโ types.ts # Normalized transit data models & interfaces
โ โโโ registry.ts # City adapter registry & alias matcher
โ โโโ server.ts # MCP server implementation (@modelcontextprotocol/sdk)
โ โโโ cli.ts # Commander-based CLI with formatted terminal output
โ โโโ index.ts # Entrypoint & CLI / MCP dispatcher
โ โโโ cities/
โ โโโ msp.ts # Minneapolis-St. Paul (Metro Transit NexTrip v2)
โ โโโ boston.ts # Boston (MBTA v3 REST API)
โ โโโ sf_bart.ts # SF Bay Area (BART REST API)
โ โโโ sf_muni.ts # San Francisco (SFMTA Muni Metro, streetcars, buses)
โ โโโ ac_transit.ts # East Bay (AC Transit Tempo BRT, Transbay buses)
โ โโโ chicago.ts # Chicago (CTA open XML alerts & 'L' system)
โ โโโ cta_routes.ts # Complete Chicago CTA 127 bus routes dictionary
โ โโโ portland.ts # Portland (TriMet MAX & Streetcar)
โ โโโ dc.ts # Washington D.C. (WMATA Metrorail & Metrobus)
โ โโโ ride_on.ts # Montgomery County (Ride On Flash BRT & buses)
โ โโโ fairfax_connector.ts # Fairfax County (Connector express & Metro feeders)
โ โโโ atl.ts # Atlanta (MARTA Rail & Streetcar)
โ โโโ mia.ts # Miami (Miami-Dade Metrorail & Metromover)
โ โโโ bna.ts # Nashville (WeGo Star & BRT Lite)
โโโ test/ # Vitest comprehensive unit & MCP test suite (100% coverage)
โโโ package.json
โโโ tsconfig.json๐งช Development & Testing
# Clone the repository
git clone https://github.com/aminamos/transit-mcp.git
cd transit-mcp
# Install dependencies
npm install
# Run comprehensive test suite
npm test
# Build TypeScript to dist/
npm run build๐ License
MIT ยฉ Amin
Available Tools
5 toolsget_departuresA
Gets real-time departures, live countdown minutes, platform, delay, and status for a stop or station.
| Name | Required | Description | Default |
|---|---|---|---|
| city | Yes | City identifier or alias (e.g. 'msp', 'boston', 'sf_bart', 'chicago', 'portland') | |
| stop_id | Yes | Stop ID, place code, or station name (e.g. '51405' / 'MAAM' for MSP, 'place-sstat' / 'Alewife' for Boston, 'EMBR' / 'Embarcadero' for BART, '40380' / 'Clark/Lake' for CTA, '8334' / 'Pioneer Courthouse Square' for TriMet) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the transparency burden. It discloses that the data is real-time and enumerates the fields returned (countdown, platform, delay, status), which is useful. It does not cover side effects, data-source caveats, or failure behavior, but as a read-only getter this is a moderate gap, not a contradiction.
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?
Single sentence, front-loaded with the core purpose, with the result fields packed in without waste. Every part of the sentence earns its place.
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 two-parameter read-only lookup with no output schema, the description supplies enough shape of the response (countdown, platform, delay, status) and the object type (stop/station). It is slightly light on usage context, but the schema covers parameter formats, and nothing essential is missing for invoking the 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?
Schema description coverage is 100%, so the schema already documents city and stop_id thoroughly. The description adds only the generic 'stop or station' framing and does not contribute new parameter semantics 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 names a precise verb+resource ('Gets real-time departures') and lists the key result fields (live countdown minutes, platform, delay, status). This makes it clearly a live-departure lookup for a stop/station and distinguishes it from sibling tools like list_routes, get_route_stops, and get_service_alerts.
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 intended context is clear: use this tool when an agent needs live departure information for a specific stop or station. It does not explicitly state when not to use it or name alternatives, but no conflicting guidance is present.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_route_stopsA
Retrieves stops and stations along a specific transit route in a supported city.
| Name | Required | Description | Default |
|---|---|---|---|
| city | Yes | City identifier or alias (e.g. 'msp', 'boston', 'sf_bart', 'chicago', 'portland') | |
| route_id | Yes | Route or line identifier (e.g. '901', 'Red', '12') | |
| direction | No | Optional direction (e.g. '0', '1', 'Northbound', 'Inbound') |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full behavioral disclosure burden. It only states what the tool retrieves; it does not mention read-only safety, response format, error behavior, direction handling, or any other runtime behavior. This is a noticeable gap for an unannotated 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?
One clean, front-loaded sentence with no filler. Every word contributes to the purpose, and the description is appropriately sized for this simple tool.
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?
The description plus full schema coverage gives enough to attempt a call, but with no output schema and no annotations, details like return shape, ordering, and city/route constraints are missing. It is adequate but not complete for an agent operating independently.
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 100%, so the schema already documents city, route_id, and direction. The description adds minimal semantic context beyond mentioning 'route', which is already in the schema. Baseline 3 is appropriate.
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 names a specific action ('Retrieves stops and stations') and a specific resource ('transit route'), and it distinguishes itself from sibling tools like get_departures and get_service_alerts. An agent can clearly tell this is the route-stops lookup tool.
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 use when stop/station information for a route is needed, but it gives no explicit when-to-use or when-not-to-use guidance, nor does it mention alternatives. The usage context is inferable but not stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_service_alertsB
Retrieves real-time transit service alerts, disruptions, construction advisories, and delays.
| Name | Required | Description | Default |
|---|---|---|---|
| city | Yes | City identifier or alias (e.g. 'msp', 'boston', 'sf_bart', 'chicago', 'portland') | |
| route_id | No | Optional route or line to filter alerts (e.g. '901', 'Red', 'Blue') |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of behavioral disclosure, but it only says the data is 'real-time.' It does not mention authentication needs, rate limits, response shape, or any side effects. This leaves important operational behavior undisclosed.
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?
A single 11-word sentence that is front-loaded with the action and resource. There is no filler or redundancy, and it earns its place.
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 read tool with full parameter schema coverage, this is mostly adequate. However, without annotations or an output schema, the description does not disclose output format, pagination, or filtering behavior, so there are clear gaps an agent would need to infer.
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 100%, so the baseline is 3. The description adds no parameter-specific meaning beyond what the schema already documents, such as how route_id filters alerts or how city aliases are resolved.
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 'Retrieves' and names a clear resource: real-time transit service alerts, disruptions, construction advisories, and delays. This is distinct from sibling tools like get_departures or list_routes, though it does not explicitly call out those alternatives.
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?
No guidance is provided about when to use this tool versus alternatives such as get_departures or get_route_stops. The description states only what the tool retrieves, not the conditions or context that should lead an agent to choose it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_routesA
Lists public transit routes/lines for a supported city with optional search filtering.
| Name | Required | Description | Default |
|---|---|---|---|
| city | Yes | City identifier or alias (e.g. 'msp', 'boston', 'sf_bart', 'chicago', 'portland') | |
| query | No | Optional search query (e.g. 'Red', 'Blue', 'Green', '66') |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries behavioral burden. It discloses that the tool lists routes and supports optional search filtering, but it does not explain behavior such as whether an unsupported city produces an error, how search filtering matches (substring vs exact), or what the response includes. This is acceptable for a simple read-only listing tool but not richly transparent.
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, front-loaded sentence with no redundant wording. Every element โ action, resource, scope, and filtering capability โ earns its place.
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 low-complexity tool with two parameters and no output schema, the description provides enough to invoke it correctly: it lists routes for a city with optional search filtering. It could be slightly more complete by pointing to list_supported_cities for valid city identifiers or clarifying search matching, but these are minor 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?
Schema description coverage is 100%, so the schema already documents both city and query parameters. The description adds only a generic reference to 'optional search filtering,' which adds no substantive meaning beyond the schema. The baseline of 3 applies because the schema carries the parameter documentation burden.
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 names a specific verb ('Lists'), a specific resource ('public transit routes/lines'), and a scope ('for a supported city'). It also mentions optional search filtering, making the tool's function clear. The resource type distinguishes it from sibling tools that deal with stops, departures, and service alerts.
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 phrase 'for a supported city' implies the caller should know whether a city is supported, but it does not explicitly point to list_supported_cities as the way to discover valid identifiers. No explicit when-to-use or when-not-to-use guidance is provided, though the intended use is reasonably inferable from the description.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_supported_citiesA
Lists all supported US transit cities, transit agencies, modes, and feature capabilities.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It accurately describes the content (cities, agencies, modes, capabilities) but does not mention the return format, whether the operation is read-only (though implied by 'lists'), or any potential pagination or limits. It covers the scope but lacks detail on output structure or edge cases.
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?
A single, front-loaded sentence that wastes no words. It leads with the core action and resource, and packall the key content into ~14 words. No redundancy or padding.
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 list tool with no parameters and no output schema, the description is nearly complete. It names all major categories of information returned (cities, agencies, modes, capabilities) and the scope (US transit). Minor gaps include the exact format of the response (e.g., list of objects vs. simple strings), but the description provides enough for an agent to invoke the tool without ambiguity.
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 the schema is an empty object, so there are no parameter semantics to document. The description does not need to elaborate on parameters, and the baseline for a zero-parameter tool is 4, which is appropriate here.
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 a specific verb ('Lists') and names the exact resource ('supported US transit cities, transit agencies, modes, and feature capabilities'). It clearly differentiates from sibling tools like list_routes and get_departures, which target specific transit data rather than a broad catalog of supported locations and capabilities.
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?
Although the description does not explicitly state when to use this tool versus alternatives, the purpose itself implies it as a discovery toolโagents would call it before using sibling tools that require a city or agency context. No exclusions or conditions are provided, but the context is clear enough for an agent to infer its use case.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
5 tool updates
v1.0.0- First observed
get_departures - First observed
get_route_stops - First observed
get_service_alerts - First observed
list_routes - First observed
list_supported_cities
TDQS
Scored across 5 tools
Each tool targets a distinct resource: city metadata, routes, stops, real-time departures, and alerts. No overlap in purpose; agents can easily select the correct tool based on the desired information.
All tools follow a consistent verb_noun snake_case pattern (list_*, get_*). Naming is predictable and uniform, making it easy to infer tool behavior from the name alone.
With 5 tools covering the core transit use cases (city discovery, route listing, stops, departures, alerts), the set is well-scoped and neither sparse nor bloated. Each tool contributes a distinct piece of the domain.
The tool set covers the main journey of exploring a city's transit system and retrieving real-time data. Minor gaps exist, such as a dedicated stop search or route details endpoint, but agents can still accomplish typical tasks without dead ends.
Maintenance
Related MCP Connectors
Read-only public transit departures, stop search, and city coverage for bus and train users.
Real-time transit stops, routes, arrivals, vehicle positions, and schedules via OneBusAway APIs.
Get real-time NYC bus arrivals, live vehicle locations, and service alerts. Plan trips between anyโฆ
Transitland MCP โ global GTFS aggregator
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceEnables users to interact with Washington DC Metro (WMATA) transit system through natural language queries. Provides real-time train arrivals, service alerts, station information, trip planning, and accessibility updates.818 npmMIT
- AlicenseBqualityFmaintenanceEnables AI clients to access Boston's MBTA public transit data, including real-time predictions, schedules, route planning, and service alerts.321Apache 2.0
- FlicenseNot gradedqualityDmaintenanceEnables AI assistants to access real-time Transport for London data, including tube/bus arrivals, line status, journey planning, and disruptions.1-
- AlicenseNot gradedqualityCmaintenanceEnables querying global transit data including agencies, routes, stops, and departures through a GTFS aggregator.6 npmMIT