Skip to main content
Glama
BilelSelmiAi2026

Open-Meteo MCP Server

Open-Meteo AI Assistant using Model Context Protocol (MCP)

Overview

The Open-Meteo AI Assistant is a production-style Python project demonstrating how to build an AI application using the Model Context Protocol (MCP).

Unlike a traditional CRUD application, this project exposes weather capabilities through an MCP Server while an AI-powered MCP Client discovers available tools, lets an LLM decide which tool to invoke, executes the selected tool, and transforms structured responses into natural language.

The project also demonstrates Server-Initiated LLM Sampling, where the MCP server requests the connected AI client to generate content while executing a tool.


Architecture

                              User
                                │
                                ▼
                      OpenAI Responses API
                                │
                                ▼
                  assistant/ai_client.py
                     (AI Assistant / MCP Client)
                                │
                                ▼
                     MCP Protocol (stdio)
                                │
                                ▼
                  Open-Meteo MCP Server
                          (main.py)
                                │
            ┌───────────────────┼────────────────────┐
            │                   │                    │
            ▼                   ▼                    ▼
      get_weather       compare_weather     generate_packing_advice
                                                    │
                                                    ▼
                                          weather_client.py
                                                    │
                                                    ▼
                                            Open-Meteo REST API
                                                    │
                                                    ▼
                                      Live weather / forecast data
                                                    │
                                                    ▼
                                   Server-Initiated LLM Sampling
                                                    │
                                                    ▼
                                     assistant/ai_client.py
                                      (sampling callback)
                                                    │
                                                    ▼
                                               OpenAI Model

Project Structure

open-meteo-mcp/
│
├── assistant/
│   ├── client.py
│   ├── ai_client.py
│   └── test_llm.py
│
├── tests/
│
├── main.py
├── weather_client.py
├── weather_models.py
├── errors.py
│
├── .env.example
├── .gitignore
├── pyproject.toml
├── uv.lock
└── README.md

Features

The MCP server currently exposes the following tools:

Tool

Description

search_city

Search for a city

get_weather

Retrieve current weather

get_weather_forecast

Retrieve multi-day weather forecast

compare_weather

Compare weather between two cities

find_warmest_day

Find the warmest forecast day

get_packing_context

Return forecast data for packing recommendations

generate_packing_advice

Demonstrates Server-Initiated LLM Sampling


Technologies

  • Python 3.14

  • Model Context Protocol (MCP)

  • OpenAI Responses API

  • Open-Meteo REST API

  • httpx

  • Pydantic

  • pytest

  • uv


Installation

Clone the repository:

git clone <repository-url>
cd open-meteo-mcp

Install dependencies:

uv sync

Activate the virtual environment:

source .venv/bin/activate

Create a .env file:

OPENAI_API_KEY=your-api-key
OPENAI_MODEL=gpt-4.1-mini

Running the Project

Related MCP server: weather-mcp-server

Start the MCP Inspector

uv run mcp dev main.py

The Inspector allows you to:

  • Discover available MCP tools

  • Execute tools manually

  • Inspect schemas

  • Debug tool responses


Run the AI Assistant

uv run python assistant/ai_client.py

Example:

You:
Compare the weather in Tunis and Munich

Assistant:
Tunis is currently warmer than Munich by 7.5°C.

Example:

You:
What should I pack for three days in Rome?

Assistant:
For your three-day trip to Rome...

Application Workflow

Standard MCP Tool Calling

User
    │
    ▼
OpenAI selects an MCP tool
    │
    ▼
MCP Client
    │
    ▼
MCP Server
    │
    ▼
Open-Meteo API
    │
    ▼
Structured response
    │
    ▼
OpenAI generates the final answer

Server-Initiated LLM Sampling

This project includes an educational implementation of Server-Initiated LLM Sampling.

Instead of the AI client generating all responses itself, the MCP server can request the connected client to invoke an LLM while executing a tool.

Workflow:

User
    │
    ▼
OpenAI selects generate_packing_advice
    │
    ▼
MCP Client
    │
    ▼
MCP Server
    │
    ▼
Open-Meteo API
    │
    ▼
Forecast retrieved
    │
    ▼
ctx.session.create_message(...)
    │
    ▼
Sampling Callback
    │
    ▼
OpenAI generates packing advice
    │
    ▼
Result returned to the MCP Server
    │
    ▼
Final response returned to the user

Note: Server-Initiated LLM Sampling is deprecated in the MCP 2026-07-28 specification. It is included here for educational purposes to demonstrate advanced MCP capabilities.


Example Queries

What's the weather in Paris?

Compare the weather between Tunis and Munich.

Find the warmest day in Rome this week.

What should I pack for five days in Rome?

Running Tests

Run the complete test suite:

uv run pytest -v

Compile all Python files:

uv run python -m py_compile \
main.py \
weather_client.py \
weather_models.py \
errors.py \
assistant/client.py \
assistant/ai_client.py

Learning Outcomes

This project demonstrates:

  • Building an MCP Server

  • Building an MCP Client

  • MCP Tool Discovery

  • MCP Tool Execution

  • OpenAI Tool Calling

  • OpenAI Responses API

  • Server-Initiated LLM Sampling

  • Async Python

  • REST API Integration

  • Pydantic Validation

  • Error Handling

  • Modular Software Architecture

  • Separation of Concerns


Future Improvements

Possible enhancements include:

  • Air Quality API

  • Weather Alerts

  • Historical Weather

  • Docker Support

  • GitHub Actions CI/CD

  • Structured Logging

  • Response Caching

  • GitHub MCP Server

  • Gitea MCP Server

  • PostgreSQL MCP Server

  • Filesystem MCP Server


License

This project is intended for educational and portfolio purposes.

Available Tools

7 tools
compare_weatherB

Compare the current temperatures of two cities.

ParametersJSON Schema
NameRequiredDescriptionDefault
first_cityYes
second_cityYes

Output Schema

ParametersJSON Schema
NameRequiredDescription

No output parameters

TDQS

B3.4/5.0
Behavior2/5

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 only states the core function without explaining what the output looks like, whether it returns a comparison string or both temperatures, handling of missing cities, or units. This is insufficient for an agent to anticipate behavior beyond the stated purpose.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

A single sentence with no redundancy. The purpose is front-loaded and every word earns its place. It is appropriately concise.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the simplicity of the tool, the description is minimally adequate for the core task. An output schema exists, so return values are not required in the description. However, with no annotations and no parameter descriptions, it leaves gaps about error handling and usage context. It is neither over-specified nor severely incomplete, but it could offer more guidance.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters2/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, so the description must compensate. It does not explain the parameters beyond the implicit 'two cities' in the text. The parameter titles ('First City', 'Second City') are self-explanatory, but the description adds no additional meaning about formats, constraints, or units. It fails to fill the gap left by the schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action ('Compare') and the resource ('current temperatures of two cities'), which distinguishes it from sibling tools like get_weather (single city) and get_weather_forecast (forecast rather than current). It leaves no ambiguity about what the tool does.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The purpose implicitly indicates when to use it (when you need to compare current temps of two cities), but there is no explicit guidance on when not to use it or how it differs from calling get_weather twice or other siblings. No exclusions or alternatives are mentioned.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

find_warmest_dayB

Find the warmest forecast day for a city.

ParametersJSON Schema
NameRequiredDescriptionDefault
cityYes
daysNo

Output Schema

ParametersJSON Schema
NameRequiredDescription

No output parameters

TDQS

B3.1/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description must carry the full burden. It states the purpose but does not disclose the return format (e.g., whether it returns a date, day name, or temperature), how ties are broken, or what happens if no forecast is available.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, compact sentence with no redundant or extraneous information. It is highly efficient and easy to parse.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Despite the sibling tools providing context, the description lacks essential details such as the output schema, return type, and edge-case behavior. It is sufficient for a simple use case but incomplete for robust agent decision-making.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters2/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The schema provides parameter names and types but no descriptions. The description does not explain that 'days' controls how many forecast days are considered or what values are acceptable (e.g., must be positive). This leaves ambiguity for the agent.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states a specific action ('Find') and a specific resource ('the warmest forecast day for a city'). It is distinguishable from siblings like get_weather_forecast (which returns all days) and compare_weather (which compares weather across cities).

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance is given on when to use this tool versus alternatives. For example, it does not mention that this is useful when a user asks for the warmest day or that it should be used instead of get_weather_forecast when only the maximum is needed.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

generate_packing_adviceC

Generate packing advice using server-initiated LLM sampling.

The MCP server retrieves the forecast and then requests an LLM completion from the connected MCP client.

ParametersJSON Schema
NameRequiredDescriptionDefault
cityYes
daysNo

Output Schema

ParametersJSON Schema
NameRequiredDescription

No output parameters

TDQS

C2.9/5.0
Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

The description discloses that the tool uses server-initiated LLM sampling and retrieves the forecast, which implies external calls and potential latency/cost. However, it does not mention any side effects, whether it is read-only, or any required permissions. Since no annotations are provided, the description carries the burden but only partially covers behavioral aspects.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is extremely concise, consisting of two short sentences that convey the core functionality without unnecessary verbosity. It gets straight to the point and is easy to parse.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The description provides enough context to understand the basic purpose and flow (retrieve forecast, request LLM). However, it lacks parameter explanations and does not clarify how this tool differs from get_packing_context or what output format to expect. This leaves some gaps for an agent deciding whether to invoke it.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters1/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema defines 'city' as a required string and 'days' as an integer with default 3, but the description provides no explanation of what these parameters mean or how they affect the advice. An agent would not know if 'days' refers to forecast duration, trip length, or something else. This is a significant gap given there are only two parameters.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's purpose: generate packing advice. It also explains the mechanism (server-initiated LLM sampling, retrieving forecast) which distinguishes it from pure weather tools. However, it does not explicitly differentiate itself from the sibling tool 'get_packing_context', which might also relate to packing.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description does not provide explicit guidance on when to use this tool versus alternatives. It implies it should be used for final advice after retrieving the forecast, but there is no direct statement contrasting it with get_packing_context or other tools. An agent would have to infer the appropriate usage context.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_packing_contextC

Return forecast data that can be used for packing advice.

ParametersJSON Schema
NameRequiredDescriptionDefault
cityYes
daysNo

Output Schema

ParametersJSON Schema
NameRequiredDescription

No output parameters

TDQS

C2.4/5.0
Behavior2/5

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 only says 'Return forecast data' without explaining aggregation, filtering, side effects, or how this context differs from raw forecast output. The output schema may document return shape, but behavioral traits remain undisclosed.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness3/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single sentence with no fluff and front-loads the action. However, it is so sparse that it sacrifices useful information; it is concise but under-specified.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

An output schema exists but is not shown, no annotations are provided, parameter descriptions are absent, and sibling differentiation is missing. For a tool with two parameters and a specific packing context, the description leaves too much to inference.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters1/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, and the description does not mention 'city' or 'days' at all. It fails to compensate for the schema's lack of parameter descriptions.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a specific verb ('Return') and resource ('forecast data') with a clear purpose ('packing advice'). However, it does not distinguish this tool from sibling get_weather_forecast, which likely also returns forecast data.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No explicit guidance is given for when to use this tool instead of alternatives like get_weather_forecast, get_weather, or generate_packing_advice. The phrase 'can be used for packing advice' implies a use case but does not state exclusions or alternatives.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_weatherC

Get the current weather for a city.

ParametersJSON Schema
NameRequiredDescriptionDefault
cityYes

Output Schema

ParametersJSON Schema
NameRequiredDescription

No output parameters

TDQS

C2.8/5.0
Behavior1/5

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 does not mention any side effects, permissions, rate limits, or return behavior. The agent is left without information on what the tool does beyond the trivial action, making the tool's behavior opaque.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, concise sentence that delivers the essential purpose without any fluff or redundancy. It follows a clear subject-verb-object structure and is appropriately front-loaded. No unnecessary words or details detract from its clarity.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given that an output schema exists, the description is not required to explain return values. However, the description is minimal and does not provide any context about the type of weather information returned (e.g., temperature, conditions) or how to interpret the result. While the single parameter and clear purpose make it functional, the lack of any additional context or usage nuances slightly reduces completeness.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters1/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The only parameter 'city' is defined in the schema merely as a required string. The description adds no extra meaning, such as expected formats, examples, or the distinction between city names and coordinates. Since schema coverage is 0% and the description does not compensate, the parameter semantics are severely lacking.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action 'Get', the resource 'current weather', and the scope 'for a city'. It effectively distinguishes from sibling tools like get_weather_forecast (which implies future weather) and search_city (which likely returns city metadata). The verb and object are specific and unambiguous.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description does not provide any explicit guidance on when to use this tool versus its siblings. It does not mention alternatives, conditions, or exclusions. While the word 'current' hints at a difference from forecast, the tool lacks direct instructions for an agent to select it confidently among the many related tools.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

get_weather_forecastB

Get a multi-day weather forecast for a city.

ParametersJSON Schema
NameRequiredDescriptionDefault
cityYes
daysNo

Output Schema

ParametersJSON Schema
NameRequiredDescription

No output parameters

TDQS

B3.3/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, and the description mentions no side effects, permissions, caching, or other behavioral details. As a read-only 'get' operation, it is likely safe, but the description does not disclose any such characteristics.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, clear sentence with no redundant words or unnecessary details. It is concise and well-structured.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The description is adequate for a simple forecast tool, but it does not mention any output format, units, or additional context that might help the agent decide among siblings. Given the presence of multiple weather-related tools, slightly more context would improve completeness.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The schema includes 'city' (required) and 'days' (default 3) with self-explanatory names. Since schema coverage is 100%, the description adds no extra meaning beyond the names, keeping the baseline score at 3.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action (Get) and the resource (multi-day weather forecast for a city). The phrase 'multi-day' differentiates it from the sibling tool 'get_weather' which likely returns a single-day forecast, making the purpose unambiguous.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

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 the alternatives (e.g., 'get_weather' for single-day, 'compare_weather' for comparisons). It lacks explicit conditions or usage scenarios.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

search_cityB

Search for a city and return its location details.

ParametersJSON Schema
NameRequiredDescriptionDefault
cityYes

Output Schema

ParametersJSON Schema
NameRequiredDescription

No output parameters

TDQS

B3.1/5.0
Behavior2/5

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 does not disclose whether the operation is read-only, any potential side effects, or error behavior. The nature of a search suggests a safe operation, but this is not stated explicitly.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, clear sentence with no unnecessary words or details. It efficiently conveys the tool's purpose.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

While the output schema is indicated as present, no details are given about the return format or the specific 'location details' included. The description is insufficient for a user to anticipate the full output, leaving the tool's context incomplete.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters1/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The single parameter 'city' is only listed in the schema as a string with no additional description, format, or example. The tool description does not elaborate on expected input, making the parameter semantics almost entirely opaque.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's function: searching for a city and returning location details. It uses a specific verb ('search') and object ('city'), and the result ('location details') is explicit, distinguishing it from the weather-related sibling tools.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies usage when city location details are needed, but it does not explicitly mention alternatives or conditions under which this tool should be preferred over the sibling weather tools. Guidance is minimal but not misleading.

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.

  1. 7 tool updatesv0.1.0
    • First observedcompare_weather
    • First observedfind_warmest_day
    • First observedgenerate_packing_advice
    • First observedget_packing_context
    • First observedget_weather
    • First observedget_weather_forecast
    • First observedsearch_city

TDQS

A3.5/5.0

Scored across 7 tools

Disambiguation5/5

Each tool serves a distinct purpose: city search, current weather, forecast, comparison, warmest day lookup, packing context, and packing advice. No overlap or ambiguity between tool functions.

Naming Consistency5/5

All tool names follow a consistent verb_noun pattern (search_city, get_weather, get_weather_forecast, compare_weather, find_warmest_day, get_packing_context, generate_packing_advice). The verbs and nouns are clear and uniformly formatted.

Tool Count5/5

With 7 tools, the set is well-scoped for a weather domain. It provides enough functionality to cover common queries without being overwhelming or redundant.

Completeness5/5

The tool set covers the full range of expected weather operations: searching locations, retrieving current conditions, forecasts, comparisons, warmest day identification, and even packing-specific context and advice. No obvious gaps for a typical weather assistant.

Maintenance

ActivitySlowing
ResponsivenessNo issues

Related MCP Connectors

Related MCP Servers

  • A
    license
    Not graded
    quality
    D
    maintenance
    Provides weather data from OpenWeatherMap API through MCP tools and a REST API with OpenAPI support. Enables LLM agents to retrieve current weather, forecasts, and temperature ranges by city or coordinates.
    6
    MIT
  • A
    license
    Not graded
    quality
    B
    maintenance
    Provides weather data including current conditions, forecasts, and summaries via Open-Meteo with no API key required, enabling natural language queries through an MCP interface.
    MIT