Weather

Proporciona alertas meteorológicas y pronósticos utilizando la API del Servicio Meteorológico Nacional.

GitHub
1

Documentación

Model Context Protocol (MCP)

🚀 ¿Por qué todo el mundo – de repente! – está obsesionado con MCP/Servidores? (Spoiler: Está redefiniendo la orquestación de IA)

Model Context Protocol (MCP) es un estándar abierto desarrollado por Anthropic a finales de 2024 para abordar un desafío crítico en la integración de IA: conectar asistentes de IA con fuentes de datos y sistemas del mundo real[1][3]. MCP sirve como una interfaz estandarizada para que los modelos de IA interactúen con herramientas externas, bases de datos y API, similar a cómo USB-C funciona como un puerto universal para dispositivos[4][7].

Características y Beneficios Clave

  1. Integración Estandarizada: MCP elimina la necesidad de integraciones personalizadas, permitiendo a los desarrolladores conectar modelos de IA a diversas fuentes de datos usando un solo protocolo.

  2. Descubrimiento Dinámico: Los agentes de IA pueden detectar y utilizar automáticamente los servidores MCP disponibles y sus capacidades sin integración codificada.

  3. Seguridad Mejorada: MCP permite a los desarrolladores implementar medidas de seguridad dentro de los servidores, asegurando que los agentes de IA solo accedan a datos o acciones permitidas.

  4. Flexibilidad: El protocolo es agnóstico al modelo, permitiendo que cualquier modelo de IA (por ejemplo, Claude, GPT-4, LLMs de código abierto) use herramientas habilitadas para MCP.

  5. Crecimiento del Ecosistema: Desde su introducción, MCP ha ganado una tracción significativa, con más de 1,000 servidores MCP construidos por la comunidad disponibles para febrero de 2025.

Impacto en el Desarrollo de IA

MCP está transformando el panorama de la IA al:

  1. Simplificar la Integración: Reduciendo la complejidad de conectar modelos de IA a sistemas externos de un problema "N×M" a un problema "N+M".

  2. Habilitar Flujos de Trabajo Complejos: Facilitando operaciones de múltiples pasos y entre sistemas para agentes de IA, como la planificación de eventos que involucra múltiples plataformas.

  3. Fomentar la Colaboración: Proporcionando un espacio de trabajo compartido para sistemas multiagente, permitiendo que agentes de IA especializados coordinen tareas de manera eficiente.

  4. Mejorar la Personalización: Habilitando la integración segura de asistentes de IA personales con los datos y aplicaciones de los usuarios.

  5. Mejorar la Gobernanza Empresarial: Estandarizando el acceso de IA a herramientas internas y permitiendo un mejor monitoreo y control de las interacciones de IA.

A partir de marzo de 2025, MCP se ha convertido en un tema significativo en la comunidad de IA, con muchos viéndolo como un componente crucial para desarrollar sistemas de IA más integrados y conscientes del contexto. Su naturaleza abierta y el respaldo de un actor importante de IA han contribuido a su rápida adopción y evolución, posicionando a MCP como un posible estándar de facto para la integración en el mundo de la IA.

Model Context Protocol (MCP) - inicio rápido del clima :

Resumen

Este documento proporciona una guía completa para construir un servidor meteorológico simple de Model Context Protocol (MCP) y conectarlo a un host, Claude para Escritorio. El servidor expone dos herramientas: get-alerts y get-forecast, que obtienen alertas meteorológicas y pronósticos usando la API del Servicio Meteorológico Nacional.

Tabla de Contenidos

  1. Introducción
  2. Requisitos Previos
  3. Requisitos del Sistema
  4. Configuración
  5. Construyendo el Servidor
  6. Probando con Claude para Escritorio
  7. Bajo el Capó
  8. Solución de Problemas

Introducción

Esta guía te lleva a través de la creación de un servidor MCP para mejorar los LLMs (como Claude) con datos meteorológicos en tiempo real. El servidor utiliza el marco de trabajo MCP para exponer herramientas que obtienen alertas meteorológicas y pronósticos, abordando la falta de conciencia ambiental nativa del LLM.

Requisitos Previos

Antes de comenzar, asegúrate de tener:

  • Familiaridad con Python
  • Comprensión de LLMs como Claude

Requisitos del Sistema

  • Python 3.10 o superior
  • MCP SDK 1.2.0 o superior

Configuración

  1. Instalar uv:

    window

    powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"

    macos/linux

    curl -LsSf https://astral.sh/uv/install.sh | sh

    Reinicia tu terminal para asegurarte de que el comando uv sea reconocido.

  2. Crear y Configurar el Proyecto:

    window (cd a tu repo_path de desarrollo, ejecuta el siguiente comando en powershell/..)

    # Create a new directory for our project
  uv init weather
  cd weather

  # Create virtual environment and activate it
  uv venv
  .venv\Scripts\activate

  # Install dependencies
  uv add mcp[cli] httpx

  # Create our server file
  new-item weather.py

    macos/linux

    # Create a new directory for our project
uv init weather
cd weather

# Create virtual environment and activate it
uv venv
source .venv/bin/activate

# Install dependencies
uv add "mcp[cli]" httpx

# Create our server file
touch weather.py

Construyendo el Servidor

Importando Paquetes y Configurando la Instancia

Agrega el siguiente código al inicio de tu archivo weather.py:

from typing import Any
import httpx
from mcp.server.fastmcp import FastMCP


# Initialize FastMCP server
mcp = FastMCP("weather")

# Constants
NWS_API_BASE = "https://api.weather.gov"
USER_AGENT = "weather-app/1.0"


#helper function
async def make_nws_request(url: str) -> dict[str, Any] | None:
    """Make a request to the NWS API with proper error handling."""
    headers = {
        "User-Agent": USER_AGENT,
        "Accept": "application/geo+json"
    }
    async with httpx.AsyncClient() as client:
        try:
            response = await client.get(url, headers=headers, timeout=30.0)
            response.raise_for_status()
            return response.json()
        except Exception:
            return None

def format_alert(feature: dict) -> str:
    """Format an alert feature into a readable string."""
    props = feature["properties"]
    return f"""
Event: {props.get('event', 'Unknown')}
Area: {props.get('areaDesc', 'Unknown')}
Severity: {props.get('severity', 'Unknown')}
Description: {props.get('description', 'No description available')}
Instructions: {props.get('instruction', 'No specific instructions provided')}
"""


@mcp.tool()
async def get_alerts(state: str) -> str:
    """Get weather alerts for a US state.

    Args:
        state: Two-letter US state code (e.g. CA, NY)
    """
    url = f"{NWS_API_BASE}/alerts/active/area/{state}"
    data = await make_nws_request(url)

    if not data or "features" not in data:
        return "Unable to fetch alerts or no alerts found."

    if not data["features"]:
        return "No active alerts for this state."

    alerts = [format_alert(feature) for feature in data["features"]]
    return "\n---\n".join(alerts)

@mcp.tool()
async def get_forecast(latitude: float, longitude: float) -> str:
    """Get weather forecast for a location.

    Args:
        latitude: Latitude of the location
        longitude: Longitude of the location
    """
    # First get the forecast grid endpoint
    points_url = f"{NWS_API_BASE}/points/{latitude},{longitude}"
    points_data = await make_nws_request(points_url)

    if not points_data:
        return "Unable to fetch forecast data for this location."

    # Get the forecast URL from the points response
    forecast_url = points_data["properties"]["forecast"]
    forecast_data = await make_nws_request(forecast_url)

    if not forecast_data:
        return "Unable to fetch detailed forecast."

    # Format the periods into a readable forecast
    periods = forecast_data["properties"]["periods"]
    forecasts = []
    for period in periods[:5]:  # Only show next 5 periods
        forecast = f"""
                    {period['name']}:
                    Temperature: {period['temperature']}°{period['temperatureUnit']}
                    Wind: {period['windSpeed']} {period['windDirection']}
                    Forecast: {period['detailedForecast']}
                    """
        forecasts.append(forecast)

    return "\n---\n".join(forecasts)


if __name__ == "__main__":
    # Initialize and run the server
    mcp.run(transport='stdio')

Ejecutando el Servidor

Para verificar tu servidor, ejecuta:

uv run weather.py

Probando tu Servidor con Claude para Escritorio

Configuración

  1. Instalar/Actualizar Claude para Escritorio: Asegúrate de tener la última versión instalada.
  2. Configurar Servidores MCP: Abre o crea el archivo de configuración en ~/Library/Application Support/Claude/claude_desktop_config.json.

alt text

-> REINICIA EL SISTEMA SI NO FUNCIONA

  1. Agregar Configuración del Servidor:

    {
  "mcpServers": {
    "weather": {
      "command": "uv",
      "args": [
        "--directory",
        "/ABSOLUTE/PATH/TO/PARENT/FOLDER/weather",# S:\\Dev\\weather
        "run",
        "weather.py"
      ]
    }
  }
}

    Reemplaza /ABSOLUTE/PATH/TO/PARENT/FOLDER/weather con la ruta absoluta correcta a tu directorio de proyecto. Puede que necesites proporcionar la ruta completa al ejecutable uv en el campo command (usa which uv en MacOS/Linux o where uv en Windows para encontrarlo).

  2. Reinicia Claude para Escritorio.

Prueba con Comandos

  1. Verificar la Detección de Herramientas: Busca el ícono de martillo en Claude para Escritorio. Al hacer clic, debería listar las herramientas get_alerts y get_forecast.

alt text 2. Ejecutar Consultas de Prueba:

- "¿Qué tiempo hace en Sacramento?"
- "¿Cuáles son las alertas meteorológicas activas en Texas?"

Nota: Estas consultas solo funcionan para ubicaciones en EE. UU., ya que utilizan el Servicio Meteorológico Nacional de EE. UU.

Qué Está Pasando Bajo el Capó

  1. El cliente envía tu pregunta a Claude.
  2. Claude analiza las herramientas disponibles y decide cuál usar.
  3. El cliente ejecuta la(s) herramienta(s) elegida(s) a través del servidor MCP.
  4. Los resultados se envían de vuelta a Claude.
  5. Claude formula y muestra una respuesta en lenguaje natural.

Solución de Problemas

  • Obtener registros de Claude para Escritorio

    • mcp.log: Conexiones y fallos generales de MCP.
    • mcp-server-SERVERNAME.log: Registros de errores del servidor nombrado.
    tail -n 20 -f ~/Library/Logs/Claude/mcp*.log

  • El servidor no aparece en Claude

    • Verifica la sintaxis del archivo claude_desktop_config.json.
    • Asegúrate de que la ruta del proyecto sea absoluta.
    • Reinicia Claude para Escritorio por completo.

  • Las llamadas a herramientas fallan silenciosamente

    • Revisa los registros de Claude para ver errores.
    • Verifica que tu servidor se compile y ejecute sin errores.
    • Intenta reiniciar Claude para Escritorio.

  • Nada de esto funciona. ¿Qué hago?

  • Error: No se pudieron recuperar los datos del punto de cuadrícula

    • Coordenadas fuera de EE. UU.
    • Problemas con la API del NWS
    • Limitación de velocidad

    Solución:

  • Error: No hay alertas activas para [ESTADO]

    • No hay alertas meteorológicas actuales para ese estado. Prueba con otro estado.

Para solución de problemas más avanzada, consulta la guía de depuración de MCP.

MCP Inspector

npx @modelcontextprotocol/inspector uv run weather.py

alt text

alt text

hecho con prueba local

Publicado en Github

🔗 Github - aitiwari/weather