# Parknav MCP

> Parknav provides predictive parking intelligence for urban environments. This MCP Server gives your agent access to real-time block occupancy rates, predicts spot availability hours out, and helps you find the nearest open space using deep learning data.

## Overview
- **Category:** data-analytics
- **Price:** Free
- **Tags:** predictive-analytics, parking-guidance, urban-mobility, real-time-data, route-optimization

## Description

Look, finding parking downtown is always a nightmare. This **Parknav MCP Server** gives your agent something way better than just pointing at a map; it lets you actually *know* where to go and when you'll get there. You connect this server to any AI client, and suddenly, your agent can predict spot availability hours out or check the minute-by-minute usage of entire blocks. It’s about knowing the score before you even hit the curb.

If you need to know what’s happening on the street right now, you've got a few ways to check it. You can use `get_realtime_occupancy` to get the current number of occupied spaces across an entire block or street segment immediately. For more granular details, `get_street_segments` checks the live status of individual sections along an on-street parking area. Need high-level context for a whole neighborhood? Run `get_city_insights` and you'll get general data points about parking conditions across a specified city zone.

Want to know if it’s worth driving out there at all? You can use `predict_availability`. This function estimates the probability of finding an open spot at any location given a specific date and time. It lets your agent forecast spot chances long before you get there. For deeper background, `get_historical_trends` pulls past availability data, showing how parking spots are used across different locations over extended periods of time.

If you're already on the street looking for a quick fix, `get_nearest_spot` finds and returns the coordinates of an currently unoccupied spot that’s closest to wherever you are. And if you just need general intel about what kind of streets you'll be hitting, `get_parking_zones` pulls up local regulations, time limits, and associated fees for any designated parking zone.

When it comes to planning the whole trip, Parknav handles it. You can run `optimize_parking_route`, which calculates a revised travel route that factors in optimal stopping points specifically for parking. This means your agent isn't just giving you directions; it’s building you a plan that accounts for time spent finding and paying for spots along the way.

## Tools

### optimize_parking_route
Calculates and returns a revised travel route that factors in optimal stopping points for parking.

### predict_availability
Estimates the probability of finding an open spot at a location given a specific date and time.

### get_street_segments
Checks the live, granular status of individual sections of an on-street parking area.

### get_historical_trends
Retrieves past availability data to show how parking spots are used at specific locations over time.

### get_parking_zones
Retrieves specific local rules, time limits, and associated fees for designated parking zones.

### get_city_insights
Provides high-level data points about general parking conditions within a specified city area.

### get_nearest_spot
Finds and returns the coordinates of a currently open parking spot closest to a given location.

### get_realtime_occupancy
Gathers the current number of occupied spaces on a block or street segment right now.

## Prompt Examples

**Prompt:** 
```
Will I find parking near Union Square at 6 PM?
```

**Response:** 
```
Predicted availability at 6 PM: 35% (Low). Recommendation: Arrive by 5:30 PM for better chances, or check nearby garages.
```

**Prompt:** 
```
Where is the nearest open spot to me right now?
```

**Response:** 
```
Nearest available spot: 150m away on 4th Street. Current occupancy on that block is 60%.
```

**Prompt:** 
```
Show me the occupancy trends for Market Street.
```

**Response:** 
```
Market Street trends: Peak occupancy (hardest to park) is 12 PM - 2 PM. Lowest occupancy (easiest to park) is 6 AM - 9 AM.
```

## Capabilities

### Predict Future Availability
Your agent predicts the likelihood of finding a parking spot at any specific future time or location.

### Get Live Block Occupancy Rates
You retrieve current, minute-by-minute usage data for designated street blocks in a city zone.

### Locate Nearest Open Spot
The system immediately directs you to the closest currently unoccupied parking spot based on live data.

### Determine Parking Zone Rules
You pull up local regulations, including time limits and associated fees for any given street segment.

### Analyze Historical Patterns
The agent analyzes past data to show how parking availability changes across different days or times of the week.

### Optimize Parking Routes
You generate a planned route that incorporates estimated time spent finding and paying for parking along the way.

## Use Cases

### The Weekend Visitor
A user is planning a trip downtown and asks, 'Will I find parking near the convention center on Saturday?' Your agent uses `predict_availability` to check that time. It replies with a low percentage chance and suggests arriving earlier or using a nearby garage.

### The Delivery Driver
A logistics manager needs to route five stops across town. Instead of just mapping the shortest path, the agent runs `optimize_parking_route`. The result isn't just coordinates; it's a sequence that minimizes time spent searching for legal loading spots.

### The City Planner
A municipal worker needs to justify changing parking rules on Main Street. They use `get_historical_trends` combined with `get_city_insights` to prove that occupancy spikes between 12 PM and 2 PM, making the current time limits insufficient.

### The On-Site Navigator
A user is standing on a busy block and asks, 'Where's the closest empty spot?' The agent runs `get_realtime_occupancy` first to check the area, then calls `get_nearest_spot` to give precise coordinates for immediate use.

## Benefits

- Stop guessing. Instead of just knowing if a street exists, `predict_availability` gives your agent the percentage chance (e.g., 35%) that a spot will be open at 6 PM, letting users plan smarter trips.
- Cut search time in half with `get_nearest_spot`. Your client doesn't just give directions; it gets directed to an actual open space right now.
- `optimize_parking_route` builds better journeys. It doesn't just find the shortest path; it finds the *most efficient* path that accounts for legal stopping times and parking search time.
- Don't get fined or wait forever. By using `get_parking_zones`, your agent automatically checks local rules, so you know if a spot is only allowed for 2 hours or costs $5/hour.
- Go beyond today's traffic. The `get_historical_trends` tool lets city planners see that Tuesday afternoons are always peak time—data essential for smart infrastructure decisions.

## How It Works

The bottom line is you get reliable, actionable location intelligence without having to query multiple legacy databases manually.

1. Subscribe to the server, then provide your unique Parknav API Key and Base URL.
2. Call a specific tool (like `predict_availability`), passing required parameters such as coordinates and desired time/date.
3. Receive structured JSON data that details the predicted availability percentage, current occupancy, or optimal route.

## Frequently Asked Questions

**How far in advance can I check parking with the `predict_availability` tool?**
You can predict availability for specific future dates and times. This uses deep learning models, so it's much better than simple averages because it accounts for day-of-week patterns.

**Does `get_nearest_spot` only find spots on major roads?**
No. It finds the nearest spot regardless of whether it’s a main artery or a smaller side street, as long as live data confirms it's open.

**What is the difference between `get_realtime_occupancy` and `predict_availability`?**
`get_realtime_occupancy` tells you what's happening right now. `predict_availability` forecasts what will happen later, which is essential for planning trips that start hours from now.

**Can I use the API to find out local parking fees?**
Yes. The `get_parking_zones` tool provides access to regulations, including time limits and associated pricing information for specific zones.

**What credentials do I need to use the Parknav MCP Server with my AI client?**
You must provide a valid API key and base URL. Your agent needs these two strings configured in your environment variables for all calls, like those made by `get_city_insights`.

**Are there rate limits when calling the `get_realtime_occupancy` tool?**
Yes, usage is governed by your subscription tier. Exceeding the defined request quota results in a 429 error; you must implement exponential backoff logic in your agent's workflow.

**Can I use `get_historical_trends` to compare availability across different city blocks?**
Yes, the tool accepts an array of coordinates or street IDs. This lets you run comparative analyses on multiple locations in a single call, which is useful for strategic planning.

**Does `optimize_parking_route` account for varying time constraints between stops?**
Yes, you must pass a detailed sequence of waypoints and their associated required duration estimates. The algorithm calculates travel time plus predicted parking search time at each stop.

**How far in advance can Parknav predict availability?**
Parknav's AI can typically predict availability up to 24 hours in advance with high confidence, and up to 7 days with moderate confidence.

**Does it cover off-street garages too?**
Parknav primarily focuses on on-street parking, but also integrates occupancy data from select off-street garages where sensors are available.

**What data sources does Parknav use?**
Parknav combines IoT sensor data, historical trends, city event data, and weather patterns using deep learning models to generate its predictions.