The CATA Bus MCP Server provides live and static schedule data for the Centre Area Transportation Authority (CATA) bus system in State College, PA, enabling real-time transit tracking and schedule queries.
List all bus routes – Retrieve all available CATA bus routes with their ID, short name, long name, and color.
Search for stops – Find bus stops by name, ID, or description, returning location details (latitude/longitude).
Get next arrivals – Query upcoming bus arrivals at a specific stop within a configurable time horizon (default 30 minutes), including delay information.
Track vehicle positions – Get real-time locations of buses on a specific route, including coordinates, bearing, and speed.
View service alerts – Retrieve active service alerts such as detours or disruptions, optionally filtered by route.
Health check – Verify the server is running and ready.
Initialize data – Manually trigger the loading/refresh of GTFS static schedule data.
Click on "Install 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., "@CATA Bus MCP Server when is the next N route bus from the HUB?"
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.
A Model Context Protocol (MCP) server that provides live and static schedule data for the Centre Area Transportation Authority (CATA) bus system in State College, PA.
Real-time vehicle positions - Track buses live on their routes
Trip updates - Get delay information and predicted arrivals
Service alerts - Stay informed about detours and disruptions
Static schedule data - Access routes, stops, and scheduled times
Fast in-memory storage - No database required, pure Python performance
Related MCP server: Winnipeg City MCP Server
# Clone the repository
git clone https://github.com/Pranav-Karra-3301/catabus-mcp.git
cd catabus-mcp
# Install dependencies
pip install -e .# Run in stdio mode (for MCP clients)
python -m catabus_mcp.server
# Run in HTTP mode (for testing)
python -m catabus_mcp.server --httpThe HTTP server will be available at http://localhost:7000
Tool | Description | Parameters |
| Get all bus routes | None |
| Find stops by name/ID |
|
| Get upcoming arrivals at a stop |
|
| Track buses on a route |
|
| Get service alerts |
|
# List all routes
curl -X POST http://localhost:7000/mcp \
-H "Content-Type: application/json" \
-d '{"method":"list_routes_tool","params":{}}'
# Search for stops
curl -X POST http://localhost:7000/mcp \
-H "Content-Type: application/json" \
-d '{"method":"search_stops_tool","params":{"query":"HUB"}}'
# Get next arrivals
curl -X POST http://localhost:7000/mcp \
-H "Content-Type: application/json" \
-d '{"method":"next_arrivals_tool","params":{"stop_id":"PSU_HUB","horizon_minutes":30}}'Install the MCP client in ChatGPT
Add this server configuration:
{
"name": "catabus",
"command": "python",
"args": ["-m", "catabus_mcp.server"],
"description": "CATA bus schedule and realtime data"
}Ask questions like:
"When is the next N route bus from the HUB?"
"Are there any service alerts for the V route?"
"Show me all buses currently on the W route"
Add to your Claude Desktop configuration:
{
"mcpServers": {
"catabus": {
"command": "python",
"args": ["-m", "catabus_mcp.server"]
}
}
}# Install dev dependencies
pip install -e ".[dev]"
# Run tests
pytest
# Run with coverage
pytest --cov=catabus_mcp# Format code
black src/
# Lint
ruff check src/
# Type checking
mypy src/catabus_mcp/This server uses official CATA data feeds:
Static GTFS: https://catabus.com/wp-content/uploads/google_transit.zip
GTFS-Realtime Vehicle Positions: https://realtime.catabus.com/InfoPoint/GTFS-Realtime.ashx?Type=VehiclePosition
GTFS-Realtime Trip Updates: https://realtime.catabus.com/InfoPoint/GTFS-Realtime.ashx?Type=TripUpdate
GTFS-Realtime Alerts: https://realtime.catabus.com/InfoPoint/GTFS-Realtime.ashx?Type=Alert
Data is cached locally and updated:
Static GTFS: Daily
Realtime feeds: Every 15 seconds
catabus-mcp/
├── src/catabus_mcp/
│ ├── ingest/ # Data loading and polling
│ │ ├── static_loader.py
│ │ └── realtime_poll.py
│ ├── tools/ # MCP tool implementations
│ │ ├── list_routes.py
│ │ ├── search_stops.py
│ │ ├── next_arrivals.py
│ │ ├── vehicle_positions.py
│ │ └── trip_alerts.py
│ └── server.py # FastMCP server
└── tests/ # Test suiteWarm cache response time: < 100ms for all queries
Memory usage: ~50MB with full GTFS data loaded
Rate limiting: Respects CATA's 10-second minimum between requests
MIT License - See LICENSE file
Transit data provided by Centre Area Transportation Authority (CATA). This project is not affiliated with or endorsed by CATA.
Built by Pranav Karra.
Contributions are welcome! Please:
Fork the repository
Create a feature branch
Write tests for new functionality
Ensure all tests pass
Submit a pull request
Issues: GitHub Issues
Discussions: GitHub Discussions
Add trip planning capabilities
Support for accessibility features
Historical data analysis
Geospatial queries (nearest stop)
Multi-agency support
pip install -e . completes without errors
python -m catabus_mcp.server starts successfully
Static GTFS data loads on startup
Realtime polling begins automatically
list_routes_tool returns CATA routes
search_stops_tool finds stops by query
next_arrivals_tool returns predictions with delays
vehicle_positions_tool shows bus locations
trip_alerts_tool displays active alerts
Tests pass with pytest
Type checking passes with mypy
Version: 0.1.0
Status: Production Ready
Last Updated: 2024
Ultra-fast health check optimized for cloud pre-flight validation.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It mentions 'ultra-fast' and 'optimized for cloud pre-flight validation,' which gives some behavioral context, but lacks details on permissions, rate limits, error handling, or what the health check entails. This is inadequate for a tool with no annotation coverage.
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, efficient sentence that front-loads key information ('Ultra-fast health check') without unnecessary words. Every part earns its place, making it highly concise and well-structured.
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?
Given the tool has 0 parameters, 100% schema coverage, and an output schema exists, the description is minimally adequate. However, for a health check tool with no annotations, it should provide more context on what is checked, success criteria, or typical use cases to be fully complete, especially compared to siblings.
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 input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description does not add parameter details, which is appropriate, but it could have mentioned if any implicit inputs are required. Baseline is 4 for zero parameters, as the schema fully covers the absence of inputs.
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 clearly states the tool performs a 'health check' with the specific purpose of 'cloud pre-flight validation' and mentions it's 'ultra-fast.' This provides a clear verb ('health check') and context, though it doesn't explicitly differentiate from sibling tools like 'initialize_data' or 'list_routes_tool,' which prevents a score of 5.
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 usage for 'cloud pre-flight validation' but does not specify when to use this tool versus alternatives like 'initialize_data' or other siblings. There is no explicit guidance on prerequisites, timing, or exclusions, leaving the agent with minimal context for tool selection.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Manually trigger GTFS data initialization.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. While 'manually trigger' implies a write operation, it doesn't specify whether this is idempotent, what permissions are needed, what side effects occur, or how long initialization takes. For a mutation tool with zero annotation coverage, this is inadequate.
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, efficient sentence with no wasted words. It's appropriately sized and front-loaded, making it easy to parse quickly.
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?
Given the tool has an output schema (which handles return values) and no parameters, the description is minimally adequate. However, as a mutation tool with no annotations, it should provide more behavioral context (e.g., idempotency, side effects) to be fully complete.
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?
There are 0 parameters, and schema description coverage is 100%, so the schema already fully documents the lack of inputs. The description doesn't need to add parameter details, earning a baseline score of 4 for zero-parameter tools.
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 clearly states the action ('manually trigger') and resource ('GTFS data initialization'), providing a specific verb+resource combination. However, it doesn't differentiate this tool from its siblings (like health_check or list_routes_tool), which would require a 5.
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 provides no guidance on when to use this tool versus alternatives or any context about prerequisites. It merely states what the tool does without indicating appropriate usage scenarios or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List all available bus routes.
Returns a list of routes with their ID, short name, long name, and color.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It discloses the return format ('list of routes with their ID, short name, long name, and color'), which is useful behavioral context. However, it doesn't mention potential limitations like pagination, rate limits, or data freshness, which are important for a list operation.
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 extremely concise and well-structured: two sentences that directly state the purpose and return format without any fluff. Every word earns its place, making it easy for an agent to parse quickly.
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?
Given the tool's simplicity (0 parameters, output schema exists), the description is reasonably complete. It explains what the tool does and what it returns, which is sufficient for basic understanding. However, it could improve by addressing behavioral aspects like data scope or limitations, slightly reducing completeness.
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 0 parameters, and schema description coverage is 100%, so no parameter documentation is needed. The description appropriately avoids discussing parameters, earning a high baseline score for not adding unnecessary information.
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 clearly states the tool's purpose: 'List all available bus routes.' It specifies the verb ('List') and resource ('bus routes'), making the function unambiguous. However, it doesn't explicitly differentiate from sibling tools like 'search_stops_tool' or 'vehicle_positions_tool', which prevents a perfect score.
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 provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites, context for usage, or comparisons to siblings like 'search_stops_tool' for filtered results. This lack of usage context leaves the agent without clear direction.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get next arrivals at a specific stop.
Args: stop_id: The stop ID to query horizon_minutes: How many minutes ahead to look (default 30)
Returns: List of upcoming arrivals with trip ID, route ID, arrival time, and delay
| Name | Required | Description | Default |
|---|---|---|---|
| stop_id | Yes | ||
| horizon_minutes | No |
| Name | Required | Description |
|---|---|---|
| result | Yes |
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 mentions the return format but doesn't cover critical aspects like error handling, rate limits, authentication needs, data freshness, or whether this is a read-only operation. For a tool with zero annotation coverage, this leaves significant gaps in understanding its behavior.
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 perfectly structured and front-loaded with the core purpose, followed by organized sections for Args and Returns. Every sentence earns its place with zero wasted words, making it highly efficient and easy to parse.
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?
Given the tool's moderate complexity, no annotations, and the presence of an output schema (which handles return value documentation), the description is adequate but incomplete. It covers parameters well but lacks behavioral context and usage guidelines, making it minimally viable but with clear 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?
The description adds meaningful context beyond the input schema, which has 0% description coverage. It explains that stop_id is 'The stop ID to query' and horizon_minutes defines 'How many minutes ahead to look (default 30)', providing clear semantic meaning that compensates for the schema's lack of descriptions.
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 clearly states the specific action ('Get next arrivals') and resource ('at a specific stop'), distinguishing it from sibling tools like list_routes_tool or search_stops_tool. It precisely defines what the tool does without being vague or tautological.
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 provides no guidance on when to use this tool versus alternatives like trip_alerts_tool or vehicle_positions_tool. It lacks context about prerequisites, exclusions, or typical use cases, offering only basic functional information without comparative guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search for stops by name or ID.
Args: query: Search query string to match against stop names, IDs, or descriptions
Returns: List of matching stops with their ID, name, latitude, and longitude
| Name | Required | Description | Default |
|---|---|---|---|
| query | Yes |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. While it mentions the tool searches and returns a list, it doesn't disclose important behavioral traits like whether this is a read-only operation, if there are rate limits, authentication requirements, or how results are sorted/paginated. The description is minimal on behavioral context.
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 appropriately concise with clear sections for Args and Returns. Both sentences earn their place by explaining the parameter and return value. However, the structure could be slightly improved by integrating the information more fluidly rather than as separate labeled sections.
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?
Given the tool has an output schema (which handles return values) and only one parameter with decent semantic coverage in the description, the description is moderately complete. However, for a search tool with no annotations, it lacks important context about search behavior, limitations, and when to use versus siblings.
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?
With 0% schema description coverage, the description compensates well by explaining that the 'query' parameter matches against stop names, IDs, or descriptions. This adds meaningful semantic context beyond the bare schema type, though it doesn't specify format examples or search behavior details.
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 clearly states the tool's purpose as searching for stops by name or ID, which is a specific verb+resource combination. However, it doesn't explicitly differentiate from sibling tools like 'list_routes_tool' or 'vehicle_positions_tool' that might also involve stop-related data.
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 provides no guidance on when to use this tool versus alternatives. With siblings like 'list_routes_tool' and 'next_arrivals_tool' that might involve stops, there's no indication of when search is preferred over listing or when other tools might be more appropriate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get current service alerts.
Args: route_id: Optional route ID to filter alerts (if None, returns all)
Returns: List of alerts with route ID, header, description, and severity
| Name | Required | Description | Default |
|---|---|---|---|
| route_id | No |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It discloses that the tool retrieves 'current' alerts, implying real-time or recent data, and mentions the return format. However, it lacks details on rate limits, authentication needs, data freshness, or error handling, which are important for behavioral understanding.
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 well-structured and front-loaded with the purpose, followed by parameter and return details. It uses minimal sentences that earn their place, though the 'Args:' and 'Returns:' sections could be integrated more seamlessly into the flow for slightly better conciseness.
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?
Given the tool's low complexity (1 optional parameter) and the presence of an output schema (which handles return values), the description is reasonably complete. It covers the purpose, parameter semantics, and return structure, though it could benefit from more behavioral context like data sources or update frequency.
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 schema description coverage is 0%, so the description must compensate. It explains the 'route_id' parameter as 'Optional route ID to filter alerts (if None, returns all)', adding clear meaning beyond the schema. This adequately covers the single parameter, though it doesn't specify format or examples.
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 clearly states the tool's purpose: 'Get current service alerts.' It specifies the verb ('Get') and resource ('service alerts'), making the function unambiguous. However, it doesn't explicitly differentiate this tool from its siblings (e.g., 'list_routes_tool'), which prevents a perfect score.
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 provides no guidance on when to use this tool versus alternatives. It mentions an optional 'route_id' parameter for filtering but doesn't explain scenarios where filtering is beneficial or when other tools might be more appropriate. This lack of contextual guidance limits its utility for an AI agent.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get current positions of vehicles on a specific route.
Args: route_id: The route ID to filter by (e.g., "BL" for Blue Loop)
Returns: List of vehicle positions with ID, coordinates, bearing, and speed
| Name | Required | Description | Default |
|---|---|---|---|
| route_id | Yes |
| Name | Required | Description |
|---|---|---|
| result | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It describes a read operation ('Get') but does not cover important aspects such as whether this requires authentication, rate limits, data freshness, error handling, or pagination. The description adds minimal behavioral context beyond the basic operation, which is insufficient for a tool with no annotation coverage.
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 appropriately sized and front-loaded, with the core purpose stated first, followed by structured Args and Returns sections. Every sentence earns its place by providing essential information without redundancy, making it efficient and easy to parse.
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?
Given the tool's moderate complexity (single parameter, read-only operation) and the presence of an output schema (which handles return values), the description is reasonably complete. It covers purpose, parameter semantics, and return structure, though it lacks behavioral details like authentication or rate limits. With output schema reducing the need to explain returns, the description is adequate but could be more comprehensive.
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 description adds meaningful semantics beyond the input schema, which has 0% description coverage. It explains that route_id is 'The route ID to filter by' and provides an example ('e.g., "BL" for Blue Loop'), clarifying its purpose and format. With only one parameter, this compensation is adequate, though not exhaustive (e.g., no validation rules).
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 clearly states the tool's purpose with a specific verb ('Get') and resource ('current positions of vehicles on a specific route'). It distinguishes from siblings like list_routes_tool (which lists routes) and next_arrivals_tool (which provides arrival times), though it doesn't explicitly name these alternatives. The purpose is not vague or tautological.
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 usage context by specifying 'on a specific route' and providing an example route_id, but it does not explicitly state when to use this tool versus alternatives like next_arrivals_tool or trip_alerts_tool. There is no guidance on prerequisites, exclusions, or named alternatives, leaving usage somewhat inferred rather than clearly defined.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Each tool has a clearly distinct purpose targeting different aspects of bus system data: health checks, data initialization, route listing, arrival queries, stop searches, alert retrieval, and vehicle tracking. There is no overlap in functionality that would cause agent confusion.
Most tools follow a consistent verb_noun pattern (e.g., list_routes_tool, search_stops_tool, trip_alerts_tool), but 'health_check' and 'initialize_data' deviate by lacking the '_tool' suffix. The naming is still readable and mostly predictable.
With 7 tools, this server is well-scoped for a bus transit system, covering essential operations like health monitoring, data management, route information, stop searches, arrival times, alerts, and vehicle positions without being overwhelming or insufficient.
The toolset provides comprehensive coverage for real-time bus system queries, including data initialization, route and stop information, arrivals, alerts, and vehicle tracking. A minor gap exists in lacking update or deletion tools for data management, but this is reasonable for a read-focused transit API.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
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…
Real-time SF Muni departures, routes, alerts, vehicle positions, and schedules.
Read-only public transit departures, stop search, and city coverage for bus and train users.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/Pranav-Karra-3301/catabus-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server