Weather Edge MCP Server
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., "@Weather Edge MCP Servershow me today's best weather edge opportunities in NYC"
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.
Weather Edge MCP Server
Weather Edge is an MCP server for calibrated Kalshi weather-market signals. It turns public forecast and market data into a compact tool surface for AI agents.
What it does
calibrates NWS daily high-temperature forecasts by city
reads current Kalshi weather market prices
estimates per-bucket probability, edge, and net expected value
exposes the results through MCP tools and an optional FastAPI surface
Related MCP server: SimpleFunctions
Install
pip install weather-edge-mcpMCP usage
Claude Desktop
{
"mcpServers": {
"weather-edge": {
"command": "python",
"args": ["-m", "weather_edge_mcp"]
}
}
}Other MCP clients
Use either of these commands:
weather-edge-mcp
python -m weather_edge_mcpTransport options
weather-edge-mcp --transport stdio
weather-edge-mcp --transport sse --port 8050
weather-edge-mcp --transport streamable-http --port 8050Tools
Tool | Description |
| Calibrated signals for one city's Kalshi weather markets |
| Full scan across all supported cities |
| Bias-adjusted forecast context for one supported city |
| Latest METAR observation from the settlement station |
| Supported cities and calibration parameters |
Supported cities: nyc, chicago, denver, miami, la
Optional web API
Weather Edge also ships an optional FastAPI app:
python -m uvicorn weather_edge_mcp.web_app:app --host 0.0.0.0 --port 8080Routes:
/api/health/api/signals?city=nyc/api/all-signals/dashboard/subscribe
If the optional x402 stack is installed and configured, the paid routes can be gated there. MCP stdio mode stays clean and side-effect free.
Docker
The repo includes a Dockerfile for Glama/container builds.
docker build -t weather-edge-mcp .
docker run --rm weather-edge-mcp --helpArchitecture
src/weather_edge_mcp/
core.py # forecasting, market fetches, calibration, formatting
mcp_server.py # MCP tools
web_app.py # optional FastAPI surface
cli.py # command-line entrypointData sources
National Weather Service forecast API
Aviation Weather METAR API
Kalshi public market API
Development
python -m unittest discover -s tests -v
python -m buildLicense
MIT
Available Tools
5 toolsget_all_signalsA
Run a full scan across all supported cities and rank top weather-market signals.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full responsibility for behavioral disclosure. It describes the action as a 'full scan' but does not mention any side effects, potential rate limits, authorization requirements, or whether the scan is resource-intensive. The agent has no information about safety or performance implications, which is a significant gap for a potentially expensive 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 consists of a single sentence that clearly and efficiently conveys the tool's purpose. Every word is meaningful, with no redundancy or filler. It is appropriately sized for its simplicity.
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 no parameters and an output schema exists (though not shown in this evaluation), the description is largely complete. It states the tool scans all cities and ranks signals. However, it could benefit from noting that this is a broad, potentially expensive operation, and that the output schema details the results. Overall adequate but slightly lacking in operational context.
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 no parameters, and schema coverage is 100% (empty schema). The description adds no parameter-level information because none is needed. With zero parameters, the baseline for this dimension is 4, and the description does not detract from it.
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 it runs a full scan across all supported cities and ranks top weather-market signals. It specifies the verb ('run a full scan'), resource ('signals'), and scope ('all supported cities'), distinguishing it from siblings like get_weather_signals which likely filter by city or other criteria.
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 implicitly indicates when to use this tool: for a comprehensive scan across all cities. However, it does not explicitly state when not to use it or mention alternatives such as get_weather_signals for more targeted queries. The context of sibling tools provides some guidance, but the description lacks explicit exclusions or prerequisites.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_forecastC
Get raw calibrated forecast context for one supported city.
Args: city: One of nyc, chicago, denver, miami, la.
| Name | Required | Description | Default |
|---|---|---|---|
| city | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so the description must carry full behavioral disclosure. It does not mention any behavioral traits such as whether the operation is read-only, any authentication needs, or rate limits. The term 'raw calibrated forecast context' is vague.
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 very short and includes a clear parameter list. Every sentence is functional, but it could be more structured with headings or bullet points.
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 (not shown), the description need not explain return values. However, for a simple tool with one parameter, it is minimally complete but lacks guidance on error conditions or alternative tools.
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% description coverage, but the description compensates by listing the allowed cities (nyc, chicago, denver, miami, la). However, it does not explain the meaning of 'city' beyond these values or provide formatting 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 action ('Get') and resource ('raw calibrated forecast context'), and it is distinct from sibling tools which focus on signals or observations. However, it does not explicitly differentiate itself from siblings.
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 on when to use this tool versus alternatives like get_weather_signals or get_station_observation. The description only lists supported cities without explaining the tool's role.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_station_observationB
Get the latest METAR observation from the settlement station for one city.
Args: city: One of nyc, chicago, denver, miami, la.
| Name | Required | Description | Default |
|---|---|---|---|
| city | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations exist, so the description must carry behavioral disclosure. It mentions the tool provides the latest METAR observation and lists allowed cities, but lacks details on error handling, cache behavior, or output structure. The output schema exists but is not described.
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 very concise with two sentences, including a structured Args section. Every sentence is necessary, though front-loading could be improved by placing the allowed cities list earlier.
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 tool with one parameter and an existing output schema, the description is mostly complete. It covers the purpose, parameter, and allowed values. Missing are any notes on return format or potential errors, but these are mitigated by the output schema.
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 meaning by enumerating allowed city values (nyc, chicago, denver, miami, la) which the input schema does not provide (no enum). Since schema coverage is 0%, this partially compensates, but does not explain format or constraints.
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 it retrieves the latest METAR observation for a single city, which distinguishes it from sibling tools like get_all_signals or get_forecast. However, it does not explicitly contrast with these 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?
The description lists valid city values but provides no guidance on when to use this tool instead of siblings like get_forecast or get_all_signals. No exclusion criteria or context are given.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_weather_signalsA
Get calibrated edge signals for one city's Kalshi weather markets.
Args: city: One of nyc, chicago, denver, miami, la.
| Name | Required | Description | Default |
|---|---|---|---|
| city | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations exist, so the description carries the burden. It implies a read operation ('Get') and lists city options but does not explicitly state side effects, permissions, or rate limits. However, the simple retrieval nature and presence of output schema mitigate missing details.
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 (two sentences), front-loads the purpose, and includes the parameter specification without redundancy. Every word adds value.
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?
With a single parameter and an output schema, the description covers the essential purpose and allowed values. It does not explain return structure (handled by output schema) or any prerequisites, but is sufficient for basic usage.
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% description coverage and no enum, but the description adds the allowed values 'nyc, chicago, denver, miami, la' for the city parameter, fully compensating for the schema gap.
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 specifies the verb 'Get' and the resource 'calibrated edge signals for one city's Kalshi weather markets', clearly distinguishing it from siblings like get_all_signals (broader) and get_forecast (different resource).
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 explicitly lists the allowed city values and states 'one city', but does not explicitly guide when to use this tool vs alternatives like get_all_signals for multiple cities.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_citiesA
List supported cities, settlement stations, and calibration parameters.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description is the sole source of behavioral information. It only describes the action as 'List', implying read-only, but offers no details on side effects, data source, or reliability. More context is needed for safe invocation.
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 sentence of eight words, front-loaded with the verb. Every word is essential, and there is no redundancy or filler.
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 tool has no parameters and an output schema exists, so the description is minimally adequate. However, it does not hint at the structure or size of the output, nor any filtering capabilities. For a trivial tool, this is sufficient but not thorough.
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 zero parameters, so schema description coverage is 100%. The description does not need to explain parameters. Baseline 4 is appropriate as no additional semantic is required.
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 lists supported cities, settlement stations, and calibration parameters. The verb 'List' combined with specific resources differentiates it from sibling tools that deal with signals, forecasts, and observations.
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 on when to use this tool versus alternatives. There is no mention of prerequisites, context, or conditions for invocation.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
TDQS
Each tool has a distinct purpose: listing cities, getting forecasts, getting observations, getting signals for one city, and scanning all cities. No overlap in functionality.
All tool names follow a consistent verb_noun pattern (get_* and list_cities), with no mixing of conventions or ambiguous verbs.
5 tools is well-scoped for a weather market server covering 5 cities. Each tool provides essential functionality without redundancy.
The tool set covers key operations: listing cities, retrieving raw data (forecast, observation), and market signals. A minor gap is the lack of a combined retrieval for all cities' raw data, but overall coverage is solid.
Maintenance
Resources
Unclaimed servers have limited discoverability.
Looking for Admin?
If you are the server author, to access and configure the admin panel.
Related MCP Connectors
Calibrated world model for AI agents. 40 tools: world state, markets, trading. Kalshi + Polymarket.
Calibrated probabilistic foresight for AI agents, powered by live prediction-market signal.
Financial data for AI agents: crypto data, Polymarket odds, weather/oil calibration, trust scoring.
Matched Kalshi and Polymarket markets across sports, crypto, weather, and economics over MCP.
Related MCP Servers
- AlicenseAqualityDmaintenancePrediction market probability oracle for AI agents. 26 tools across 500+ live markets from Kalshi and Polymarket. Cross-source arbitrage detection, structured TPF signals, Kelly Criterion sizing, agent performance tracking, and webhook alerts.9671MIT
- AlicenseAqualityBmaintenance24/7 autonomous monitoring and edge detection for prediction markets (Kalshi & Polymarket). Features causal tree analysis, orderbook depth tracking, cross-venue comparison, and real-time alerts.1619612MIT
- AlicenseAqualityFmaintenanceProvides prediction market intelligence, research, and strategy signals for platforms like Kalshi, Polymarket, and Robinhood. It enables AI assistants to perform market screening, arbitrage detection, and deep causal analysis to support informed trading decisions.271MIT
- AlicenseNot gradedqualityFmaintenanceProvides weather and climate intelligence for AI agents, including current conditions, forecasts, historical data, severe-weather alerts, agricultural outlook, and travel conditions via free and paid tools.MIT
Latest Blog Posts
- Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)By Om-Shree-0709 on .mcpAgent IdentityOAuth 2.1
- Your AI Chatbot Just Exposed Your CEO's Salary to an InternBy Om-Shree-0709 on .Agent IdentityMCP SecurityOAuth Delegation
- Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)By Om-Shree-0709 on .Agentic AiPrompt InjectionWebAssembly
MCP directory API
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/RJW34/weather-edge-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server