Facilitating AI-Driven Sustainability: A Service-Oriented Architecture for Interoperable Environmental Data Access

Abstract

Advances in artificial intelligence (AI), particularly agentic AI, have created opportunities to enhance global sustainability by improving the efficiency and accuracy of environmental monitoring and response systems. Agentic AIs autonomously plan and execute towards specific goals with minimal or no human intervention; however, accessing environmental data is challenging and requires expertise due to inherent fragmentation and the diversity of data formats. The Model Context Protocol (MCP) is an open standard that allows AI systems to securely access and interact with diverse software tools and data sources through unified interfaces, reducing the need for custom integrations while enabling more accurate, context-aware assistance. This study introduces WeatherInfo_MCP, an interface that provides the required expertise for AI agents to access National Weather Service (NWS) data. Built on a service-oriented architecture, the system uses a centralized engine to handle robust geocoding and data extraction while providing AI agents with simple, independent tools to retrieve weather data from the NWS API. The system was validated through 14 unit tests and 23 comprehensive protocol compliance tests against the MCP 2025-06-18 specification, achieving a 100% pass rate across all categories, demonstrating its reliability when working with AI agents. We also successfully tested our model alongside a memory MCP to showcase its performance in a multi-MCP environment. While in its earliest version, WeatherInfo_MCP connects to the NWS API, its modular design and compliance with software development and MCP standards facilitate immediate expansion to additional environmental data and tools. WeatherInfo_MCP is released as an open-source tool to support the sustainable development community, enabling broad adoption of AI agents for environmental use cases.

1. Introduction

Weather- and climate-related disasters represent a mounting global challenge, imposing ever-greater costs on societies and threatening more lives each year [1]. The United States was hit by 14 billion-dollar weather disasters in the first half of 2025, causing $101.4 billion in damage [2]. From 1980 to mid-2025, the country suffered more than 417 events exceeding $1 billion each, with a cumulative loss of over $3.1 trillion and more than 17,000 lives lost [3]. Globally, the scale is even more dramatic: the World Meteorological Organization (WMO) reports that the number of weather-related disasters has increased fivefold during the past half-century, primarily due to climate change, population growth in high-risk areas, and improved reporting [4]. Although improved disaster management and early warning systems have reduced fatalities per event, the total exposure and financial toll continue to increase, creating a demand for more effective and inclusive resilience strategies [5].

Informing vulnerable groups about weather hazards and their consequences in a timely manner is vital for overcoming these challenges. Culturally appropriate, community-led interventions and integration of digital tools are promising avenues for increasing the utilization of interventions [6]. Active, low-cost communication and outreach campaigns have demonstrated substantial value, and further research is needed to optimize disaster response and preparedness activities, such as work on heatwaves [7]. Increasingly, programs recognize the need to resolve the interplay between environmental exposure, population sensitivity, adaptive capacity, and behavior as determinants of risk, requiring advances in observational data and individual-scale modeling tools [8].

The recent advancements in artificial intelligence (AI) applications in meteorology are transforming the prediction and communication of environmental risks. Initial advances focused on enhancing forecasting skill and spatial resolution through machine learning, deep learning, and geospatial foundation models [9,10]. Using techniques such as recurrent neural networks, diffusion models, and transformer-based architectures to analyze large, multimodal datasets, AI-driven methodologies have considerably improved accuracy in predicting environmental variables [11,12]. The advent of large language models (LLMs) and multimodal AI systems further expands the range of applications to include scenario planning, advanced early warning, and near-real-time risk assessment for decision-makers and the public [13].

Despite this technological progress, significant barriers persist in the mobilization of accurate, actionable information for crisis management [14,15]. Early warning systems are often closed, lack global reach, and miss relevant risk drivers, which burdens organizations with high costs and time investment [14]. Consistent, robust, and trusted data access remains crucial for enabling AI systems to support reliable and scalable hazard monitoring and adaptive crisis response [16]. AI and advanced Information and Communications Technology (ICT) can help collect, process, analyze, and disseminate vast and heterogeneous data streams [14]. Machine learning algorithms and natural language processing now allow for standardization and normalization of diverse inputs, extraction of risk factors from unstructured data, and integration of social, physical, and health-related signals to support better-informed decisions [17,18]. However, the absence of unified or standardized data access approaches can hinder interoperability, slow critical updates, and introduce errors in high-stakes applications [19].

Addressing the urgent need for reliable, standardized, and open access environmental data systems is foundational for the next generation of AI-enabled early warning and crisis management platforms [20]. By lowering the technical barriers to API integration, standardized protocols can facilitate broader access to environmental intelligence, potentially enabling non-expert developers to build robust decision-support tools. The introduction of the Model Context Protocol (MCP) has paved the way for standardizing access to different tools and datasets for AI agents [21,22]. This article introduces WeatherInfo_MCP, our development of a specialized MCP to help AI agents across diverse environmental applications access the information they need. The initial motivation behind developing WeatherInfo_MCP was to support an agentic AI system for managing heatwave scenarios, highlighting the protocol’s value in separating data extraction from the broader agentic workflow. This separation acts as a common data access layer, fostering correctness and security, and allowing agent developers to focus on core logic rather than duplicative data integration work. This architecture facilitates the shift from the traditional $\mathrm{M}\times \mathrm{N}$ integration problem, where M agents need to interact with N data sources, to a simpler $\mathrm{M}+\mathrm{N}$ solution, where the MCP acts as the intermediary (Figure 1).

The prospects for such integration promise not only better preparedness and reduced losses but also more equitable access to life-saving information worldwide. We will continue with a brief explanation of MCP and then describe the futuristic design of WeatherInfo_MCP v1.00, which applies software architecture standards to make future system expansion easier and straightforward.

2. Materials and Methods

2.1. Model Context Protocol (MCP)

The Model Context Protocol (MCP) is an open standard that was recently developed. It enables AI agents to securely and efficiently use digital tools and datasets [21]. MCP was formally introduced in November 2024, motivated by the rapid expansion of AI agents in different domains [22]. This shift highlights a critical, shared need for reliable methods for AI systems to access, query, and manipulate up-to-date, real-world information. Without MCP, most autonomous AI agents require custom code or proprietary interfaces to connect with new data sources or software platforms [23]. This can lead to increased development overhead, frequent errors, and significant systemic security risks, particularly concerning data privacy and authorization. MCP addresses these challenges by providing a unified, transparent, and extensible technical solution [24]. By providing a standard interface, the hard-coding of data access can be separated from the development of agents, so developers can more easily build robust AI agents that interact correctly with complex information systems—such as climate databases, sensor networks, or data analytics tools—without risking interoperability breakdowns across different platforms.

At its core, MCP structures communications as a series of standardized “tool calls” or function requests [22]. This process allows an agent to request specific operations, fetch data, or trigger actions in external systems using simple, well-defined formats, typically relying on secure, lightweight HTTPS exchanges. MCP servers expose modular capabilities, where each “tool” corresponds to a distinct unit of function—such as retrieving weather data, querying a document archive, or performing a specific risk calculation. This design separates the AI model’s probabilistic reasoning core from the deterministic external data access layer, greatly enhancing system security and observability.

MCP is expected to play a major role in the future of AI deployment for different purposes, including sustainable development and crisis management. Its modular architecture and open ecosystem enable organizations to rapidly innovate and scale AI solutions, ensuring the robustness and reproducibility required for high-stakes applications such as climate risk assessment and autonomous decision support. This standardized approach to grounding LLM-powered agents is essential for transforming siloed AI efforts into resilient, trustworthy, and interoperable agent networks. In the following sections, we introduce our MCP server, WeatherInfo_MCP.

2.2. WeatherInfo_MCP

The design of WeatherInfo_MCP emphasizes modularity, efficiency, and standards-based communication to support robust, maintainable, and extensible service delivery. The package was designed in two focused parts, which are explained as follows: The first part includes a service-oriented core architecture and an object-oriented design of the geospatial data model. The second part is a Model Context Protocol (MCP) layer that exposes the functionality of WeatherInfo_MCP to AI agents through a standardized, stateless interface. Figure 2 shows the system with the separation of these layers.

2.2.1. Service-Oriented Core Architecture and the Object Model

For the WeatherInfo_MCP design, we opted for a service-oriented architecture (SOA) [25]. This approach lets us break the system into independent services that talk to each other through standard interfaces. By decoupling these components, we gained the ability to scale or update specific parts of the software without overhauling the entire codebase. At the core of WeatherInfo_MCP’s architecture is a service class named “Location”, which follows recommended best practices by encapsulating all data access and geospatial operations. Upon instantiation, a location object either accepts an address or direct coordinates. If an address is provided, it is geocoded into latitude and longitude through a controlled process with retry and timeout controls to handle network unreliability.

Immediately after creation, the location object resolves and caches the URL of the nearest National Weather Service (NWS) observation station. This URL serves as a unique, persistent identity attribute of the location. Caching this station link minimizes repeated API calls during subsequent weather data retrievals, thereby reducing unnecessary network traffic. Variable data, such as temperature, humidity, and wind, are accessed on demand through methods of the class, distinguishing between relatively constant properties (location and station identities) and dynamically changing observations.

To enable long-lived or distributed use, the location object supports serialization—conversion to a JSON-compatible dictionary—which can be safely stored, transmitted, and later reconstructed into a live object. This serialization is necessary since the Model Context Protocol operates over JSON-RPC, which requires exchanging JSON-serializable data structures rather than raw Python (version 3.12) objects [26].

This design pattern ensures that each MCP tool call restores a fully functional location instance from its serialized form. This approach enforces isolation between calls, prevents state-sharing-related bugs, and allows session persistence or multi-agent communication where the same location information is reused efficiently.

A key trade-off in this architecture is prioritizing separation of concerns over initial implementation speed. While a monolithic script would have reduced the codebase size, it would have created a dependency between the data extraction logic and the MCP interface. By isolating the location server, we accepted a higher initial development effort to ensure that future changes to the NWS API do not propagate errors to the agent communication layer—a critical requirement for maintaining long-term autonomous systems. In addition, expanding the system to more data sources and capabilities will be more straightforward in future versions.

2.2.2. MCP Layer: Agent Interaction and Protocol Design

WeatherInfo_MCP server uses the Model Context Protocol (MCP) to expose its core functionality to AI agents through stateless functions that are decorated to handle specific agent requests [27]. Each function operates independently to process location data and retrieve specific weather metrics. These functions provide structured outputs with clear documentation to ensure accurate identification and utilization of the server’s capabilities by agents.

This modular design follows established best practices for building reliable and scalable AI systems by providing independently operating tools that rely on a shared central processing unit. By isolating each function, the system ensures that complex requests can be handled concurrently without interference, maximizing stability for decision-making applications. The separation of the MCP layer from the location service class simplifies maintenance and extension, since new weather variables or extraction functions can be added by writing additional stateless MCP tools without altering the core data access code.

To minimize network load, the system consolidates data retrieval into a single step, occurring only when a new location is defined or when a live update is explicitly requested. All subsequent analysis is performed on this locally stored dataset rather than repeatedly querying the external source, aligning with established efficiency standards [28]. This enhanced design, grounded in recognized architectural standards such as SOA and MCP, results in a flexible, maintainable, and efficient system. It is well-suited for integrated, AI-driven environmental monitoring and other related applications that require access to meteorological data.

3. Results

To ensure the reliability of the WeatherInfo_MCP tool, we conducted extensive unit tests and comprehensive MCP tests, following best practices in modern software engineering and the MCP requirements. Unit tests verified the accuracy of each core component (such as location geocoding and weather data processing). In contrast, broader test cases of the MCP layer assessed the tool’s robustness in various real-world scenarios, as explained in more detail in subsequent sections. Additionally, we simulated a simple agentic model integrating WeatherInfo_MCP with a memory MCP. All critical tests were run using industry-standard testing frameworks, and the results are summarized below. This approach assures end-users and stakeholders of the tool’s trustworthiness. The GitHub repo with open-source code is available at this link: https://github.com/Babakjfard/weatherinfo_mcp (accessed on 8 January 2026).

3.1. Unit Tests

Unit testing is a foundational practice in software development where individual components of a program are tested separately to ensure they behave correctly [29]. By testing each part in isolation, developers can quickly identify and fix errors, which leads to higher software quality and easier maintenance to ensure reliability, reproducibility, and credibility. We implemented unit tests for all functions in the two central Python modules of WeatherInfo_MCP. These tests cover crucial capabilities, such as initializing location objects from addresses or coordinates, retrieving weather observation data, and extracting specific weather parameters, including temperature, humidity, and wind. To make the tests efficient and reliable, we used a technique called mocking [30]. Mocking simulates external systems or network calls, allowing tests to run without making real requests to service APIs. This ensures the tests are fast, reproducible, and unaffected by network issues or external service availability.

The test suite was written using Python’s unit test framework supplemented by mocks for network interactions. It includes 14 distinct test cases spanning both core location services and weather tool MCP components, validating both success and error-handling scenarios comprehensively. All tests were passed successfully, underlining the reliability of WeatherInfo_MCP’s fundamental functions. These unit tests provide confidence that each component performs as designed, serving as a robust foundation for building advanced agentic systems that use WeatherInfo_MCP. Such agentic systems can use WeatherInfo_MCP to attain dependable weather information by means of conversation rather than embedded coding or expertise in accessing related APIs. This is shown through a simple example later in this manuscript. Appendix A.1 shows the output of the unit test.

3.2. Rigorous Validation of MCP Tool Compliance

To ensure that the WeatherInfo_MCP tool meets the standards of reliability, interoperability, and robustness expected for modern agentic systems, we conducted a comprehensive test suite in line with the Model Context Protocol (MCP) 2025-06-18 specification and related best practices [24]. Each category of test addresses a specific aspect of system behavior that is critical for correct, predictable functioning in real-world, multi-agent, and multi-MCP environments. Below are the seven test categories over four areas—each completed and passed for WeatherInfo_MCP—along with a brief explanation of their purpose and connection to current standards:

• MCP Protocol Compliance (2025-06-18):
  • Tool Manifest Validation: Validates the presence and correctness of the entire tool manifest. This guarantees the discoverability of the functions for agents.
  • Tool Execution Validation: Confirms the correct execution of declared tools, such as create_location and related utilities, and the delivery of expected outputs for valid input.
• Session and Lifecycle Management
  • Protocol Version Negotiation: Ensures accurate communication of the MCP protocol version.
  • Session Initialization and State Management: Assesses robust session creation, state transitions, maintenance, and cleanup, ensuring stable and predictable operation, especially in continuous or long-running deployments.
• Error Handling & Recovery
  • Investigates system responses to invalid inputs, malformed requests, and external API timeouts. The test verified that the system fails gracefully under stress conditions (such as rapid sequential requests or upstream API outages), preserving data integrity. Multi-user load testing was not conducted because the system is designed to run as an independent instance for each user. This design inherently prevents one user’s heavy usage from slowing down or affecting another’s session.
• WeatherInfo_MCP-Specific Functional Tests
  • Focuses on domain-relevant capabilities unique to WeatherInfo_MCP, including location-aware weather queries, observation retrieval, and alert serving, ensuring correct operation and robustness for real-world environmental health use cases.

Security compliance was not tested in this deployment, as WeatherInfo_MCP handles only public, non-sensitive information and does not introduce risks related to privacy, authorization, or data protection per MCP security requirements. This category will be revisited if future versions require the handling of sensitive data. The primary potential for misuse lies in operational resource consumption, where an autonomous agent might inadvertently generate excessive API requests. While the MCP architecture permits host-side throttling, the ultimate safeguard is enforced by the NWS upstream API rate limits, which automatically reject excessive traffic from a single IP address, preventing systemic disruption.

Table 1. Summary of WeatherInfo_MCP testing coverage and outcomes in accordance with MCP Version 2025-06-18.

No.	Category	Test Name	Total Tests	% Passed	Notes
1	MCP Protocol Compliance 2025-06-18	Tool Manifest, Connection, and Execution Validation	3	100%	Validated initialization, tool manifest (8 tools), and execution of create_location
2	Session and Lifecycle Management	Protocol Version Negotiation	7	100%	Includes protocol version negotiation and lifecycle tests, including session initialization and session state transition
3	Error Handling & Recovery	Error Handling & Recovery	10	100%	Comprehensive error, retry, and timeout handling tests
4	MCP-Specific Functional Tests	MCP-Specific Functional Tests	3	100%	Location creation, weather observation, and alert retrieval
5	Security Compliance	Security Compliance	0	100%	Not tested; system does not handle sensitive information

summarizes the test results and coverage for WeatherInfo_MCP. In total, the testing program comprised 23 unique tests, with every category achieving a 100% pass rate. These results provide comprehensive evidence that WeatherInfo_MCP conforms to core MCP 2025-06-18 standards and is robust for deployment in agentic environments. Given that the primary contribution of this work is infrastructural, this validation of protocol compliance and deterministic function execution (via unit tests) provides the requisite assurance of system stability prior to the introduction of variable AI reasoning layers. Appendix A.2 shows the report of the compliance test.

It is worth noting that the system operates as an I/O-bound application, where total response latency is dominated by the network Round-Trip Time (RTT) and processing time of the upstream NWS API. The internal overhead introduced by WeatherInfo_MCP’s abstraction layer consists of in-memory serialization and logic execution, which is computationally negligible compared to the external HTTP request lifecycle [31]. Therefore, the modular architecture preserves the performance profile of direct API integration without introducing considerable latency.

3.3. A Simple Use Case: An AI Agent Using WeatherInfo_MCP and a Memory MCP

To demonstrate the practical applicability and integration capability of the WeatherInfo_MCP tool within an agent-based system, a working AI agent was developed that incorporates two MCP servers: WeatherMCP and a memory MCP. This configuration enables the agent to provide real-time meteorological data while managing persistent user-related information, such as locations linked to individual names. The setup was designed to test the agent’s ability to maintain personalized context and operate the two MCP instances seamlessly within a single framework. We used OpenAI’s Agent SDK framework with gpt-4o-mini as the backend LLM for our test case, but WeatherInfo_MCP can be used by any agent framework and LLM.

The agent’s instructions guide it to identify the individual upon interaction and check for stored entities representing this person and their associated locations. If a location is not already stored, the agent prompts the individual to provide this information and subsequently saves it using the memory MCP. This strategy ensures that after the initial identification, the location data are persistently linked to the individual, allowing the agent to avoid redundant location queries in subsequent sessions or interactions. Weather information retrieval is then conducted by querying the WeatherInfo_MCP server for up-to-date observations, such as temperature, humidity, wind conditions, and descriptive weather summaries. Figure 3 illustrates this agent workflow.

An example of a session with three interactions illustrates the agent’s capabilities (

Table 2. The outcome generated by the sample agent system using WeatherInfo_MCP alongside a memory MCP. The list includes interactions with a single agent in a single session, testing with different combinations of names and locations *.

Interaction	Speaker	Utterance
1	User	Hi. My name is John Dove and I live in Omaha, Nebraska. What’s the weather like today?
	Agent	John, the current weather in Omaha, Nebraska, is clear with a temperature of about 9 °C (48 °F). The wind is coming from the north-northwest at approximately 24 km/h (15 mph) with gusts up to 33 km/h (21 mph). The relative humidity is around 57%.
2	User	Hi. I am Bobby Jones. Is there any weather alert today?
	Agent	I don’t have your location saved yet. Could you please tell me the city or area where you are located? This will help me check for any weather alerts for your location.
3	User	Hi. I am John Dove. Is there any weather alert today?
	Agent	Hello John Dove. There are no weather alerts for Omaha, Nebraska, today.

* User questions are in italic to ease the distinction from the system replies.

). In the first interaction scenario, we introduced John Dove and specified his location as Omaha, Nebraska. The agent successfully creates entities for John and Omaha, establishes their relationship, and fetches the current weather observations for Omaha from the WeatherInfo_MCP tool. The agent responds with a detailed yet clear summary including temperature, wind speed and direction, and relative humidity. In a subsequent interaction (Interaction 3 in Table 2), the same person—John Dove—inquiries about weather alerts. The agent then retrieves corresponding entities for John and Omaha, establishes their relationship, and fetches active alerts associated with Omaha and reports their status appropriately. Also, using a new name without a related location—Bobby Jones in interaction 2 of Table 2—receives a message from the agent to provide their location.

These demonstrations show a sample of how WeatherInfo_ MCP can be effectively embedded as a component in larger multi-tool AI agent architectures, facilitating dynamic, context-aware user interactions. The agent’s ability to coordinate between persistent memory and live data retrieval highlights the tool’s readiness for real-world applications, complementing the previously described unit and protocol compliance tests with evidence of operational robustness in interactive settings. Detailed agent instruction prompts and relevant code snippets are provided in Appendix B.1 and Appendix B.2 to ensure transparency and reproducibility.

The presented agentic interaction is intentionally designed as a minimal validation scenario to isolate the reliability of the communication protocol from the variability of AI reasoning. In complex environmental modeling, higher-order tasks—such as multi-variable inference or temporal reasoning—rely heavily on the capabilities of other models and tools, such as the language model itself. Introducing such complexity at the validation stage would create confounding variables, making it difficult to distinguish between a failure in the tool’s architecture and a failure in the agent’s planning logic. By restricting the scope to a fundamental query-response cycle, this use case validates the determinism and stability of the underlying infrastructure, establishing a reliable foundation upon which more complex, reasoning-intensive applications can subsequently be built.

To facilitate independent verification of the system’s interoperability, we have deployed a live reference implementation hosted on Hugging Face Spaces (accessible at: https://huggingface.co/spaces/Babak321/Simple_Weather_App, accessed on 25 February 2026). This web-based interface utilizes the WeatherInfo_MCP backend to power a conversational agent and alert notification system in a cloud environment. Note that this deployment is provided strictly as a functional proof-of-concept to demonstrate the stability of the standardized connection. The application-level design of the web app is illustrative and remains outside the scope of the architectural analysis presented in this study.

4. Discussion

Here, we propose WeatherInfo_MCP, a Model Context Protocol implementation built on the National Weather Service (NWS) API to standardize weather data access for AI agents. Our design employs a utility-server pattern and service-oriented architecture (SOA), which strictly separates the core meteorological model logic from the MCP interface layer. This modular approach is a key strength, enhancing maintainability, flexibility, and extensibility, allowing for future integrations (e.g., memory MCPs) with minimal disruption. Crucially, WeatherInfo_MCP conforms rigorously to the latest MCP standard specification (July 2025), confirmed through extensive testing, ensuring seamless interoperability within multi-MCP agent environments.

To validate the operational benefits of WeatherInfo_MCP, we conceptually compared its integration workflow against a traditional direct API implementation. In a traditional setting, an AI agent developer must write custom code to handle HTTP requests, parse complex JSON responses from the NWS API, and manage connection errors. This creates a “tight coupling”—a high level of dependency between components of software, where one module directly relies on the internal implementation details of another—between the agent and the data source, where any change in the NWS API requires updating the agent’s core code.

In contrast, WeatherInfo_MCP abstracts these complexities into a standardized interface.

Table 3. Qualitative comparison of software engineering metrics between direct NWS API integration and the proposed WeatherInfo_MCP architecture.

Feature	Direct NWS AIP Integration	WeatherInfo_MCP (Proposed)
Integration Complexity	High: Requires handling HTTP headers, rate limits, and JSON parsing logic within the agent’s codebase.	Low: Agent uses predefined tools (e.g., get_weather) without needing knowledge of the underlying API protocols.
Development Effort	Linear (M × N): Each new agent requires a fresh integration script for every new data source.	Modular (M + N): Once the MCP server is running, any number of agents can connect instantly without new code.
Error Handling	Manual: Developers must write custom logic to catch timeouts or 500-level errors for every request.	Built-in: The SOA core handles retries, timeouts, and graceful failures automatically before the agent sees a result.
Maintainability	Low: If the NWS API changes its endpoints, every agent’s code must be rewritten.	High: API updates are handled once within the MCP server; agents remain unaffected.

presents a conceptual, architecture-based comparison of these two approaches across key software engineering metrics. Also, the provided sample, the Jupyter notebook in the Notebooks folder of the provided GitHub, shows a reimplementation of the direct API use.

Several MCP weather servers have been developed and publicly released in the past year, providing weather data access through well-known APIs such as OpenWeatherMap, Open-Meteo, or the National Weather Service (Appendix B.3). These servers vary in scope from simple API wrappers offering limited forecast and alert querying to more complex implementations with modular designs and integration examples. Our MCP weather server distinguishes itself through two major strengths that address key challenges for developers and AI researchers working with agentic frameworks. First, it uses an SOA to separate the core meteorological model functionalities from the MCP interface and control logic. Second, our MCP server conforms rigorously to the latest MCP standard specification (version 2025-06-18). To our knowledge, many existing MCP weather servers have not yet undergone such detailed conformance testing, making this a key differentiator for robust and scalable use of WeatherInfo_MCP in AI assistant research and applications. All MCP servers listed in Appendix B.3 were published before the latest MCP standard specification (version 2025-06-18), which makes them all susceptible to failure in such tests and consequently in real-world applications. Among all the servers listed in Appendix B.3, only Weather MCP (third in the table in Appendix B.3) and knmi-weather-mcp (last in the table in Appendix B.3) provide open-source code with separated utility and server functionalities, making them comparable to our SOA benefits. However, the former is focused on data from the Open-Meteo API, and the latter is only focused on the Netherlands. It is important to clarify that our statements reflect the information available from public repositories and documentation of other MCP servers; we have not conducted exhaustive performance or feature testing across all products. Therefore, while we highlight these distinctive aspects of our MCP server, we welcome future benchmarking studies to establish broader performance and capability comparisons within the community.

Despite the discussed strengths, the current implementation is subject to data constraints. This version relies on the NWS API, which restricts geographic coverage to the United States and presents limitations in spatial and temporal resolution, as data are often sourced from the nearest airport or major weather station. Therefore, the initial version (v0.1.0) is not optimized for localized data extraction at the neighborhood level, limiting its current applicability to regional-scale monitoring and broad-context decision support. To overcome this, a feasible extension of the architecture could integrate supplementary, local data sources alongside advanced geocoding services to improve spatial resolution. Furthermore, the long-term success of this tool relies on continuous adaptation to evolving standards and the incorporation of access to other datasets. Specifically, environmental data are characterized by multi-scale spatiotemporal variability, non-uniform reporting standards, and heterogeneous formats (e.g., tabular, vector, and raster). Addressing these challenges requires architectural frameworks that can normalize diverse inputs into a consistent context for AI agents. While future capabilities may introduce new architectural dependencies, the current SOA design ensures a flexible foundation for scalable system expansion. Also, as with any data-centric system, the utility of this tool is directly constrained by the quality, availability, and consistency of the upstream data providers.

5. Conclusions

WeatherInfo_MCP v0.1.0 represents a crucial step toward standardizing reliable and flexible environmental data access for AI-driven applications. Designing robust data access protocols using open standards accelerates transformative advances across disciplines, including public health, emergency management, agriculture, and environmental monitoring [32,33,34]. By providing a universal connectivity layer, this system relieves researchers and system designers of the complex burden of raw data integration from the National Weather Service.

From the perspective of sustainable development, this work contributes to the creation of a resilient digital infrastructure capable of supporting integrated scientific approaches relying on agentic AI. By providing a standardized interface for environmental data access, the system directly facilitates the development and maintainability of AI agents designed for complex sustainability applications and research studies. This interoperability ensures agents’ reliable access to the environmental context needed to address broader socio-economic challenges. Furthermore, by reducing the technical resources required to deploy environmental AI agents, this architecture fosters informational equity, enabling resource-constrained organizations and local governments to leverage advanced decision-making support tools for sustainability and environmental planning. This potentially enables AI agents to deliver highly targeted, individual-level weather data for a specific location while allowing institutional platforms to efficiently process large-scale datasets for coordinated planning.

The broader vision is that establishing such technical infrastructure is a prerequisite for future AI-driven decision support systems. By decoupling data retrieval from agent reasoning, this architecture provides the necessary foundation for applications that improve preparedness and support individuals and communities in taking informed action against accelerating environmental risks and sustainability challenges.