Weather Microservice with MCP + UV - An MCP Server for AI Applications

Overview: What is Weather Microservice with MCP + UV?

The Weather Microservice with MCP + UV is a lightweight and extensible weather API service built to support seamless local development, secure deployment in Docker containers, and integration with various AI applications like Claude Desktop. This server utilizes the Model Context Protocol (MCP) to enable robust data source and tool integration for AI applications.

🔧 Core Features & MCP Capabilities

The core features of this Weather Microservice are powered by MCP, which provides a standardized protocol for integrating diverse tools and data sources within AI applications. Here’s how MCP enhances the Weather Microservice:

• Fast Local Development: With live reloading support via uv, developers can quickly iterate on their code without restarting the server. This is especially useful during development.
• Dockerized Deployment: The service supports Docker, making it easy to deploy in production or staging environments. This ensures consistency and ease of maintenance across different deployment stages.
• Claude Desktop Integration: Pre-integrated setup for quick installation and configuration on Claude Desktop enhances the user experience by providing a seamless solution for AI developers.

Key MCP Capabilities:

• Dependency Management: uv simplifies managing and syncing dependencies, ensuring that all required libraries are available.
• Secure Secrets Loading: Secrets such as API keys and database URLs can be securely loaded from .env files or environment variables.
• Hot Reloading & Live Coding: The ability to mount local code as editable allows developers to make on-the-fly changes during development.

⚙️ MCP Architecture & Protocol Implementation

The Weather Microservice leverages the Model Context Protocol (MCP) for its core architecture. MCP is designed to enable seamless integration between AI applications and various tools and data sources. The protocol defines a structured method for exchanging data and commands, ensuring compatibility across different AI platforms.

Mermaid Diagram: MCP Protocol Flow

graph TD
    A[AI Application] -->|MCP Client| B[MCP Protocol]
    B --> C[MCP Server]
    C --> D[Data Source/Tool]
    style A fill:#e1f5fe
    style C fill:#f3e5f5
    style D fill:#e8f5e8

Mermaid Diagram: Data Architecture

graph LR
    DataSource((Data Source) -->|Fetch| API Gateway -->|Process| Weather Service -->|Transform| Client)
    Client((Client) -->|Send Prompt| MCP Server -->|Execute| Weather Service -->|Return| API Gateway -->|Present| AI Application)
    subgraph Weather Service
        WeatherService([Weather Service]) 
    end

🚀 Getting Started with Installation

To get started, follow these steps to set up and run the Weather Microservice.

Development Mode (with MCP Inspector)

Running the server in development mode allows for live reloading:

uv run mcp dev server.py

You can also add dependencies on-the-fly using uv commands:

uv run mcp dev server.py --with pandas --with numpy

To mount your local code as editable, use the following command:

uv run mcp dev server.py --with-editable .

Direct Execution

For a more controlled deployment or advanced scenarios, you can directly run the server via:

from mcp.server.fastmcp import FastMCP

mcp = FastMCP("My App")

if __name__ == "__main__":
    mcp.run()

Or using uv:

uv run python server.py
# or
uv run mcp run server.py

Docker Support

Building and Running the Docker Image

To build a Docker image, use the following command:

docker build -t weather-service .

And to run it with environment variables mounted:

docker run --env-file .env -p 6274:6274 weather-service

💡 Key Use Cases in AI Workflows

Real-World Scenario: Weather Analysis for AI Applications

Imagine using the Weather Microservice to power an intelligent chatbot that provides real-time weather updates based on user prompts. Here’s how it works:

1. The user asks a question about current weather conditions.
2. The MCP client (as part of the chatbot application) sends a request through the weather service endpoint.
3. The server processes the request, fetches data from its data source or performs necessary calculations.
4. It returns the processed data to the client, which then presents it to the user.

Real-World Scenario: Forecast Tool Integration

Integrating a forecast tool into an AI application can enhance decision-making capabilities. Here’s an example integration:

1. The user requests a 7-day weather forecast for a specific city.
2. The MCP client sends this request through the weather-service endpoint, which then fetches data from the associated API or database.
3. The server processes the forecast and returns it to the application in a structured format.
4. The AI application visualizes the forecast data, aiding in informed decision-making.

🔌 Integration with MCP Clients

The Weather Microservice ensures compatibility with a variety of MCP clients:

MCP Client	Resources	Tools	Prompts	Status
Claude Desktop	✅	✅	✅	Full Support
Continue	✅	✅	❌	No Prompts
Cursor	❌	✅	❌	Tools Only

📊 Performance & Compatibility Matrix

The performance of the Weather Microservice is optimized for various deployment and integration scenarios. The following matrix provides an overview:

Performance Matrix

Deployment Mode	Local Development	Docker Container
Load Speed	Instantaneous	Minimal Delay
Update Frequency	Real-time as code changes	Smooth through Docker rebuilds

🛠️ Advanced Configuration & Security

MCP Configuration Code Sample

Here’s an example of how to configure the Weather Microservice:

{
  "mcpServers": {
    "[server-name]": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-[name]"],
      "env": {
        "API_KEY": "your-api-key"
      }
    }
  }
}

Enhancing Security

Ensure that sensitive data, such as API keys and database URLs, are stored securely. Use environment variables or .env files to manage these.

❓ Frequently Asked Questions (FAQ)

1. How do I set up the Weather Microservice with MCP on Claude Desktop?
   • Install the server using uv run mcp install server.py, then configure it in Claude Desktop as per its documentation.
2. Can I use this Weather Microservice with other AI applications?
   • Yes, it is compatible with Claude Desktop and other MCP clients like Continue and Cursor.
3. What happens if I change the API key during development?
   • Simply update your .env file or environment variables to reflect the new API key, and uv sync will update the dependencies accordingly.
4. How does Docker improve stability in production environments?
   • Docker ensures a consistent runtime environment across different deployment scenarios by containerizing the application with all its dependencies.
5. What if I need advanced features not covered by MCP?
   • Extended functionality can be added via custom scripts or additional tools, while ensuring compatibility with the existing MCP protocol.

👨‍💻 Development & Contribution Guidelines

Contributions are welcome! To contribute to this project:

1. Fork the repository.
2. Create a new branch: git checkout -b [branch-name].
3. Commit your changes: git commit -m 'Add some description'.
4. Push to the branch: git push origin [branch-name].
5. Open a pull request.

🌐 MCP Ecosystem & Resources

For more information on MCP and its ecosystem, visit the Model Context Protocol documentation at ModelContextProtocol.com. Stay updated with the latest developments in AI integration technologies by following our official blog or joining our community forums.

By utilizing the Weather Microservice with MCP + UV, developers can build robust AI applications that are easily integrated and deployable in diverse environments.