mcpField
M
MCP US Weather Client/Server

MCP US Weather Client/Server

Local
github.com/ankitmishraliveDeveloper Tools0Updated 78w ago

About MCP US Weather Client/Server

MCP US Weather Client/Server is a sample MCP server and client for retrieving active weather alerts for US states. It uses the National Weather Service API and demonstrates client interaction with mcp_use and Langchain.

Key features

  1. 01Fetches active alerts by US state
  2. 02Formats weather alert results
  3. 03Example client using mcp_use
  4. 04Conversation memory and LLM integration

Use cases

  1. 01Checking alerts for selected US states
  2. 02Exploring an MCP client and server example
  3. 03Demonstrating alert retrieval in an LLM conversation

MCP support

The server exposes a weather-alert tool and a configuration resource to MCP clients. The repository also includes an example client built with mcp_use.

Configuration

Local server config is the same for every client. Copy it into your client’s MCP config file.

No install method listed yet

We haven’t collected a package or remote endpoint for this server. Follow the instructions in the project README.

Repository

Tools

No tool list yet

Local servers expose tools only once running on your machine, and the maintainer has not provided a tool list.

Details

From the project README

MCP US Weather Client/Server

This was my first encounter with hands on implementation of MCP, i really liked it & i firmly believe MCP is here to stay, i have to implement some more projects to get more more better understanding about the overall ecosystem,About the repository, This repository contains a simple MCP (Model Context Protocol) server that provides weather alert information for US states, leveraging the National Weather Service (NWS) API. It also includes an example client application that demonstrates how to interact with the MCP server using the mcp_use library and Langchain.

Features

  • Weather Alerts: Fetches and formats active weather alerts for a specified US state.
  • MCP Integration: Demonstrates how to build an MCP server using the fastmcp library.
  • Client Example: Provides a client application that uses the server and integrates conversation memory.
  • Langchain Integration: Example showcases LLM integration.

Architecture

graph LR

    %% MCP System
    subgraph MCP_System
        A[Client: client.py]
        B[MCP Agent: mcp_use.MCPAgent]
        C[MCP Client: mcp_use.MCPClient]
        D[FastMCP Server: weather.py]
        E[NWS API: api.weather.gov]

        A --> B
        B --> C
        C --> D
        D --> E
    end

    %% Data Flow
    subgraph Data_Flow
        F[User Input]
        F --> A
        E -->|Geo+JSON| D
        D -->|Weather Data| B
        B -->|LLM Interaction| F
    end

    %% Styling with visible text
    classDef client fill:#f9f,stroke:#333,color:#000,font-weight:bold;
    classDef agent fill:#ccf,stroke:#333,color:#000,font-weight:bold;
    classDef server fill:#fcc,stroke:#333,color:#000,font-weight:bold;
    classDef api fill:#ffc,stroke:#333,color:#000,font-weight:bold;
    classDef user fill:#cfc,stroke:#333,color:#000,font-weight:bold;

    class A client;
    class B,C agent;
    class D server;
    class E api;
    class F user;

    %% Link styling
    linkStyle default stroke:#000,stroke-width:2px;


Prerequisites

Before running the server and client, ensure you have the following installed:

  • Python 3.7+
  • uv (recommended for dependency management - https://github.com/astral-sh/uv)
  • Groq API key. This needs to be added to .env file.
  • mcp_use Library: Make sure you've installed this according to its documentation.

Installation

  1. Clone the repository:

    git clone <your_repository_url>
    cd <repository_directory>
    
  2. Install dependencies (using uv):

    uv add -r requirements.txt
    

    This command uses uv pip install . to install the project and its dependencies based on the pyproject.toml file in the current directory.

  3. Create .env file: Create a .env file in the root directory with the following content, replacing <YOUR_GROQ_API_KEY> with your actual Groq API key:

    GROQ_API_KEY=<YOUR_GROQ_API_KEY>
    

Usage

Running the MCP Weather Server & Client
  1. Start the server:

    uv run mcp dev server/weather.py
    
  2. Start the Client:

    uv run server/client.py
    
Interacting with the Client
  • Type your queries at the prompt. For example: "Get weather alerts for CA, NY or NJ etc".
  • Type exit or quit to end the conversation.
  • Type clear to clear the conversation history.

Example Interactions

The agent will then use the get_alerts tool to fetch weather alerts for California and provide you with the formatted results.

The agent will then use the get_config tool to fetch the resource.

Configuration

server/weather.json

This configuration file describes the tools and resources exposed by the MCP server. It's crucial that this file accurately reflects the definitions in your weather.py file. See the mcp_use documentation for details on the format of this file. The default configuration is in the server folder.

Environment Variables

The client application uses environment variables, specifically GROQ_API_KEY, to authenticate with the Groq API. Make sure to set these variables before running the client. You can set those variables using the .env file.

Output

  • Console Output: This screenshot shows the typical output of the client application during a conversation, demonstrating how the agent interacts with the MCP server and utilizes the get_alerts tool.

image

  • MCP Inspector: This screenshot shows the typical weather.json used with the MCP Inspector

image

Contact

For any inquiries or support, please reach out:

Comments

Markdown supported

New to MCP?

From what the protocol is to installing your first server, these answers cover most first questions.

An open protocol that defines how AI applications connect to external tools and data in a uniform way. Clients talk to the model; MCP servers provide tools, resources and prompt templates. They exchange standard messages, so one server can be reused by many clients.