agroplan-ai-cli 1.0.7 → 1.0.9

package/backend-template/.env.example

@@ -12,8 +12,13 @@ CORS_ORIGINS=http://localhost:3000,http://127.0.0.1:3000
 
 # Data Mode
 # simulated: Uses CSV files with simulated data
-# real: Uses real APIs (future implementation)
-DATA_MODE=simulated
+# real: Uses real APIs only
+# hybrid: Uses real APIs with fallback to simulated data
+DATA_MODE=hybrid
+
+# Weather Provider Configuration
+WEATHER_PROVIDER=open-meteo
+PROVIDER_CACHE_TTL=3600
 
 # Cache Administration (optional)
 # If set, /cache/limpar endpoint requires X-Cache-Token header

package/backend-template/api.py

@@ -2,7 +2,7 @@
 FastAPI Backend para AgroPlan AI
 """
 
-from fastapi import FastAPI, HTTPException, Request
+from fastapi import FastAPI, HTTPException, Request, Query
 from fastapi.middleware.cors import CORSMiddleware
 from pydantic import BaseModel
 from typing import Optional
@@ -17,10 +17,17 @@ from core.planner import gerar_cenarios, gerar_plano_genetico
 from core.bruteforce_validator import comparar_ag_com_forca_bruta, executar_multiplas_rodadas
 from core.report_generator import gerar_relatorio_completo
 
+# Importar provedores de dados reais
+from providers.weather_provider import get_weather_summary
+from providers.cache import clear_provider_cache, get_cache_stats
+
 # Configurações de ambiente
 HOST = os.getenv("HOST", "0.0.0.0")
 PORT = int(os.getenv("PORT", "8000"))
 CORS_ORIGINS = os.getenv("CORS_ORIGINS", "http://localhost:3000,http://127.0.0.1:3000").split(",")
+DATA_MODE = os.getenv("DATA_MODE", "hybrid")  # simulated, real, hybrid
+WEATHER_PROVIDER = os.getenv("WEATHER_PROVIDER", "open-meteo")
+PROVIDER_CACHE_TTL = int(os.getenv("PROVIDER_CACHE_TTL", "3600"))
 
 # Cache em memória para resultados pesados
 _resultados_cache = {}
@@ -63,6 +70,9 @@ class OtimizarRequest(BaseModel):
     seed: Optional[int] = 42
     geracoes: Optional[int] = 100
     populacao: Optional[int] = 50
+    lat: Optional[float] = None
+    lon: Optional[float] = None
+    days: Optional[int] = 30
 
 class ValidarRequest(BaseModel):
     objetivo: str = "equilibrado"
@@ -71,6 +81,9 @@ class ValidarRequest(BaseModel):
 class RelatorioRequest(BaseModel):
     objetivo: str = "equilibrado"
     formato: str = "md"
+    lat: Optional[float] = None
+    lon: Optional[float] = None
+    days: Optional[int] = 30
 
 class RodadasRequest(BaseModel):
     objetivo: str = "equilibrado"
@@ -126,32 +139,94 @@ def health():
     """Verifica saúde da API"""
     try:
         culturas, talhoes, regras = get_dados()
+        provider_cache_stats = get_cache_stats()
+        
         return {
             "status": "healthy",
             "culturas": len(culturas),
             "talhoes": len(talhoes),
             "regras": len(regras),
-            "cache_items": len(_resultados_cache)
+            "cache_items": len(_resultados_cache),
+            "data_mode": DATA_MODE,
+            "providers": {
+                "weather": "available" if WEATHER_PROVIDER else "disabled"
+            },
+            "provider_cache": provider_cache_stats
         }
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))
 
+@app.get("/dados/clima")
+def get_clima(
+    lat: Optional[float] = Query(None, description="Latitude"),
+    lon: Optional[float] = Query(None, description="Longitude"), 
+    days: int = Query(30, description="Número de dias para análise")
+):
+    """Obtém dados climáticos reais ou simulados"""
+    try:
+        # Se lat ou lon não foram fornecidos, retornar mensagem amigável
+        if lat is None or lon is None:
+            return {
+                "message": "Informe latitude e longitude para consultar dados climáticos reais.",
+                "exemplo_sao_paulo": "/dados/clima?lat=-23.55&lon=-46.63&days=30",
+                "exemplo_brasilia": "/dados/clima?lat=-15.78&lon=-47.93&days=30",
+                "parametros": {
+                    "lat": "Latitude da localização",
+                    "lon": "Longitude da localização", 
+                    "days": "Número de dias analisados, padrão 30"
+                }
+            }
+        
+        if days < 1 or days > 365:
+            raise HTTPException(status_code=400, detail="Days deve estar entre 1 e 365")
+        
+        weather_data = get_weather_summary(lat, lon, days)
+        return weather_data.to_dict()
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
 @app.get("/dashboard")
-def get_dashboard():
-    """Retorna resumo do dashboard"""
+def get_dashboard(
+    lat: Optional[float] = None,
+    lon: Optional[float] = None,
+    days: int = Query(30, description="Número de dias para análise climática")
+):
+    """Retorna resumo do dashboard com contexto climático opcional"""
     try:
-        def montar_dashboard():
-            culturas, talhoes, regras = get_dados()
-            
-            # Usa AG cacheado
-            resultado_ag = get_ag_cacheado(objetivo='equilibrado', seed=42)
+        culturas, talhoes, regras = get_dados()
+        
+        # Obter contexto climático se coordenadas foram fornecidas
+        contexto_climatico = None
+        if lat is not None and lon is not None:
+            from core.climate_adapter import obter_contexto_climatico_por_coordenadas
+            contexto_climatico = obter_contexto_climatico_por_coordenadas(lat, lon, days)
+        
+        # Gerar chave de cache considerando clima
+        cache_params = {"objetivo": "equilibrado", "seed": 42}
+        if lat is not None and lon is not None:
+            cache_params.update({"lat": lat, "lon": lon, "days": days})
+        
+        cache_key = get_cache_key("dashboard", **cache_params)
+        
+        def compute_dashboard():
+            # Usar AG com clima se disponível
+            if contexto_climatico:
+                from core.climate_adapter import gerar_plano_com_clima
+                resultado_ag = gerar_plano_com_clima(
+                    culturas, talhoes, regras, 
+                    objetivo='equilibrado', seed=42,
+                    lat=lat, lon=lon, days=days
+                )
+            else:
+                resultado_ag = get_ag_cacheado(objetivo='equilibrado', seed=42)
             
             # Tenta validar
             validacao = comparar_ag_com_forca_bruta(culturas, talhoes, regras, objetivo='equilibrado', seed=42)
             
-            # Se força bruta é inviável, retorna dados especiais
+            # Preparar resultado base
             if validacao.get('erro'):
-                return {
+                resultado_base = {
                     "lucro_total": float(resultado_ag['lucro_total']),
                     "risco_medio": float(resultado_ag['risco_medio']),
                     "fitness": float(resultado_ag['fitness']),
@@ -179,47 +254,62 @@ def get_dashboard():
                         for p in resultado_ag['plano']
                     ]
                 }
+            else:
+                resultado_base = {
+                    "lucro_total": float(resultado_ag['lucro_total']),
+                    "risco_medio": float(resultado_ag['risco_medio']),
+                    "fitness": float(resultado_ag['fitness']),
+                    "diversidade": int(resultado_ag['diversidade']),
+                    "objetivo": str(resultado_ag['objetivo']),
+                    "culturas_escolhidas": [str(p['cultura']) for p in resultado_ag['plano']],
+                    "validacao": {
+                        "otimo_global": bool(validacao.get('ag_encontrou_otimo_global', False)),
+                        "total_combinacoes": int(validacao.get('forca_bruta', {}).get('total_combinacoes', 0))
+                    },
+                    "plano": [
+                        {
+                            "talhao": int(p['talhao']),
+                            "area": float(p['area']),
+                            "solo": str(p['solo']),
+                            "clima": str(p['clima']),
+                            "relevo": str(p['relevo']),
+                            "agua": str(p['agua']),
+                            "cultura": str(p['cultura']),
+                            "lucro_estimado": float(p['lucro_estimado']),
+                            "risco": float(p['risco']),
+                            "nota": float(p['nota']),
+                            "tempo": int(p['tempo'])
+                        }
+                        for p in resultado_ag['plano']
+                    ]
+                }
             
-            # Converte tipos numpy para Python nativos
-            return {
-                "lucro_total": float(resultado_ag['lucro_total']),
-                "risco_medio": float(resultado_ag['risco_medio']),
-                "fitness": float(resultado_ag['fitness']),
-                "diversidade": int(resultado_ag['diversidade']),
-                "objetivo": str(resultado_ag['objetivo']),
-                "culturas_escolhidas": [str(p['cultura']) for p in resultado_ag['plano']],
-                "validacao": {
-                    "otimo_global": bool(validacao.get('ag_encontrou_otimo_global', False)),
-                    "total_combinacoes": int(validacao.get('forca_bruta', {}).get('total_combinacoes', 0))
-                },
-                "plano": [
-                    {
-                        "talhao": int(p['talhao']),
-                        "area": float(p['area']),
-                        "solo": str(p['solo']),
-                        "clima": str(p['clima']),
-                        "relevo": str(p['relevo']),
-                        "agua": str(p['agua']),
-                        "cultura": str(p['cultura']),
-                        "lucro_estimado": float(p['lucro_estimado']),
-                        "risco": float(p['risco']),
-                        "nota": float(p['nota']),
-                        "tempo": int(p['tempo'])
-                    }
-                    for p in resultado_ag['plano']
-                ]
-            }
+            # Adicionar informações de clima real
+            if contexto_climatico:
+                resultado_base["clima_real"] = {
+                    "ativo": True,
+                    "source": contexto_climatico.get("fonte", "unknown"),
+                    "temperatura_media": contexto_climatico.get("temperatura_media"),
+                    "precipitacao_total": contexto_climatico.get("precipitacao_total"),
+                    "risco_climatico_estimado": contexto_climatico.get("risco_climatico_estimado"),
+                    "clima_observado": contexto_climatico.get("clima_observado"),
+                    "agua_observada": contexto_climatico.get("agua_observada"),
+                    "ajuste_risco": contexto_climatico.get("ajuste_risco", 0),
+                    "fallback": contexto_climatico.get("fallback", False),
+                    "error": contexto_climatico.get("error")
+                }
+            else:
+                resultado_base["clima_real"] = {"ativo": False}
+            
+            return resultado_base
         
-        # Usa cache para dashboard
-        key = get_cache_key("dashboard", objetivo="equilibrado", seed=42)
-        resultado = get_or_compute_cache(key, montar_dashboard)
+        # Usa cache para dashboard com contexto climático
+        resultado = get_or_compute_cache(cache_key, compute_dashboard)
         
         # Converte tipos Python (por segurança)
         return converter_tipos_python(resultado)
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
 
 @app.get("/talhoes")
 def get_talhoes():
@@ -289,17 +379,42 @@ def get_culturas():
         raise HTTPException(status_code=500, detail=str(e))
 
 @app.get("/cenarios")
-def get_cenarios():
-    """Retorna comparação de cenários"""
+def get_cenarios(
+    lat: Optional[float] = None,
+    lon: Optional[float] = None,
+    days: int = Query(30, description="Número de dias para análise climática")
+):
+    """Retorna comparação de cenários com contexto climático opcional"""
     try:
+        # Obter contexto climático se coordenadas foram fornecidas
+        contexto_climatico = None
+        if lat is not None and lon is not None:
+            from core.climate_adapter import obter_contexto_climatico_por_coordenadas
+            contexto_climatico = obter_contexto_climatico_por_coordenadas(lat, lon, days)
+        
+        # Gerar chave de cache considerando clima
+        cache_params = {"cenarios": True}
+        if lat is not None and lon is not None:
+            cache_params.update({"lat": lat, "lon": lon, "days": days})
+        
+        cache_key = get_cache_key("cenarios", **cache_params)
+        
         def montar_cenarios():
             culturas, talhoes, regras = get_dados()
             
             # Gera todos os cenários
             cenarios = gerar_cenarios(culturas, talhoes, regras)
             
-            # Usa AG cacheado
-            resultado_ag = get_ag_cacheado(objetivo='equilibrado', seed=42)
+            # Usar AG com clima se disponível
+            if contexto_climatico:
+                from core.climate_adapter import gerar_plano_com_clima
+                resultado_ag = gerar_plano_com_clima(
+                    culturas, talhoes, regras, 
+                    objetivo='equilibrado', seed=42,
+                    lat=lat, lon=lon, days=days
+                )
+            else:
+                resultado_ag = get_ag_cacheado(objetivo='equilibrado', seed=42)
             
             # Cria um mapa de talhões para facilitar o acesso
             talhoes_dict = {int(row['id']): row for _, row in talhoes.iterrows()}
@@ -332,7 +447,7 @@ def get_cenarios():
                     ]
                 }
             
-            # Adiciona AG
+            # Adiciona AG com contexto climático
             cenarios_formatados['genetico'] = {
                 'nome': 'Algoritmo Genético',
                 'descricao': 'Solução otimizada automaticamente',
@@ -357,13 +472,28 @@ def get_cenarios():
                 ]
             }
             
-            return {
-                "cenarios": cenarios_formatados
-            }
+            # Adicionar informações de clima real se disponível
+            resultado_final = {"cenarios": cenarios_formatados}
+            if contexto_climatico:
+                resultado_final["clima_real"] = {
+                    "ativo": True,
+                    "source": contexto_climatico.get("fonte", "unknown"),
+                    "temperatura_media": contexto_climatico.get("temperatura_media"),
+                    "precipitacao_total": contexto_climatico.get("precipitacao_total"),
+                    "risco_climatico_estimado": contexto_climatico.get("risco_climatico_estimado"),
+                    "clima_observado": contexto_climatico.get("clima_observado"),
+                    "agua_observada": contexto_climatico.get("agua_observada"),
+                    "ajuste_risco": contexto_climatico.get("ajuste_risco", 0),
+                    "fallback": contexto_climatico.get("fallback", False),
+                    "error": contexto_climatico.get("error")
+                }
+            else:
+                resultado_final["clima_real"] = {"ativo": False}
+            
+            return resultado_final
         
-        # Usa cache para cenários
-        key = get_cache_key("cenarios")
-        resultado = get_or_compute_cache(key, montar_cenarios)
+        # Usa cache para cenários com contexto climático
+        resultado = get_or_compute_cache(cache_key, montar_cenarios)
         
         return converter_tipos_python(resultado)
     except Exception as e:
@@ -373,34 +503,54 @@ def get_cenarios():
 
 @app.post("/otimizar")
 def otimizar(request: OtimizarRequest):
-    """Executa otimização com Algoritmo Genético"""
+    """Executa otimização com Algoritmo Genético e contexto climático opcional"""
     try:
         # Valida objetivo
         objetivos_validos = ['equilibrado', 'lucro', 'risco', 'sustentavel']
         if request.objetivo not in objetivos_validos:
             raise HTTPException(status_code=400, detail=f"Objetivo inválido. Use: {objetivos_validos}")
         
-        # Usa AG cacheado se parâmetros forem padrão
-        if (request.objetivo == "equilibrado" and 
-            request.seed == 42 and 
-            request.geracoes == 100 and 
-            request.populacao == 50):
-            resultado = get_ag_cacheado(
+        # Obter contexto climático se coordenadas foram fornecidas
+        contexto_climatico = None
+        if request.lat is not None and request.lon is not None:
+            from core.climate_adapter import obter_contexto_climatico_por_coordenadas
+            contexto_climatico = obter_contexto_climatico_por_coordenadas(request.lat, request.lon, request.days)
+        
+        # Usar AG com clima se disponível
+        if contexto_climatico:
+            from core.climate_adapter import gerar_plano_com_clima
+            resultado = gerar_plano_com_clima(
+                *get_dados(),
                 objetivo=request.objetivo,
                 seed=request.seed,
                 geracoes=request.geracoes,
-                populacao=request.populacao
-            )
-        else:
-            # Executa AG sem cache para parâmetros customizados
-            culturas, talhoes, regras = get_dados()
-            resultado = gerar_plano_genetico(
-                culturas, talhoes, regras,
-                objetivo=request.objetivo,
-                geracoes=request.geracoes,
                 populacao=request.populacao,
-                seed=request.seed
+                lat=request.lat,
+                lon=request.lon,
+                days=request.days
             )
+        else:
+            # Usa AG cacheado se parâmetros forem padrão e sem clima
+            if (request.objetivo == "equilibrado" and 
+                request.seed == 42 and 
+                request.geracoes == 100 and 
+                request.populacao == 50):
+                resultado = get_ag_cacheado(
+                    objetivo=request.objetivo,
+                    seed=request.seed,
+                    geracoes=request.geracoes,
+                    populacao=request.populacao
+                )
+            else:
+                # Executa AG sem cache para parâmetros customizados
+                culturas, talhoes, regras = get_dados()
+                resultado = gerar_plano_genetico(
+                    culturas, talhoes, regras,
+                    objetivo=request.objetivo,
+                    geracoes=request.geracoes,
+                    populacao=request.populacao,
+                    seed=request.seed
+                )
         
         # Converte tipos numpy para Python nativos
         resultado_convertido = converter_tipos_python(resultado)
@@ -472,7 +622,7 @@ def rodadas(request: RodadasRequest):
 
 @app.post("/relatorio")
 def relatorio(request: RelatorioRequest):
-    """Gera relatório"""
+    """Gera relatório com contexto climático opcional"""
     try:
         culturas, talhoes, regras = get_dados()
         
@@ -486,7 +636,14 @@ def relatorio(request: RelatorioRequest):
         if request.formato not in formatos_validos:
             raise HTTPException(status_code=400, detail=f"Formato inválido. Use: {formatos_validos}")
         
-        # Gera relatório
+        # Obter contexto climático se coordenadas foram fornecidas
+        contexto_climatico = None
+        if request.lat is not None and request.lon is not None:
+            from core.climate_adapter import obter_contexto_climatico_por_coordenadas
+            contexto_climatico = obter_contexto_climatico_por_coordenadas(request.lat, request.lon, request.days)
+        
+        # Gera relatório (por enquanto sem integração climática no gerador)
+        # TODO: Atualizar report_generator para aceitar contexto climático
         caminho = gerar_relatorio_completo(
             culturas, talhoes, regras,
             objetivo=request.objetivo,
@@ -497,11 +654,48 @@ def relatorio(request: RelatorioRequest):
         with open(caminho, 'r', encoding='utf-8') as f:
             conteudo = f.read()
         
-        return {
+        # Adiciona informações climáticas ao final se disponível
+        if contexto_climatico and not contexto_climatico.get("fallback", True):
+            clima_info = f"""
+
+## Dados Climáticos Reais
+
+**Fonte:** {contexto_climatico.get('fonte', 'N/A')}
+**Temperatura Média:** {contexto_climatico.get('temperatura_media', 'N/A')}°C
+**Precipitação Total:** {contexto_climatico.get('precipitacao_total', 'N/A')}mm
+**Risco Climático:** {contexto_climatico.get('risco_climatico_estimado', 'N/A')}
+**Clima Observado:** {contexto_climatico.get('clima_observado', 'N/A')}
+**Água Observada:** {contexto_climatico.get('agua_observada', 'N/A')}
+**Ajuste de Risco:** {contexto_climatico.get('ajuste_risco', 0):+.1%}
+
+*Dados climáticos integrados ao planejamento para maior precisão.*
+"""
+            conteudo += clima_info
+        
+        resultado = {
             "caminho": caminho,
             "conteudo": conteudo,
             "formato": request.formato
         }
+        
+        # Adicionar informações de clima real
+        if contexto_climatico:
+            resultado["clima_real"] = {
+                "ativo": True,
+                "source": contexto_climatico.get("fonte", "unknown"),
+                "temperatura_media": contexto_climatico.get("temperatura_media"),
+                "precipitacao_total": contexto_climatico.get("precipitacao_total"),
+                "risco_climatico_estimado": contexto_climatico.get("risco_climatico_estimado"),
+                "clima_observado": contexto_climatico.get("clima_observado"),
+                "agua_observada": contexto_climatico.get("agua_observada"),
+                "ajuste_risco": contexto_climatico.get("ajuste_risco", 0),
+                "fallback": contexto_climatico.get("fallback", False),
+                "error": contexto_climatico.get("error")
+            }
+        else:
+            resultado["clima_real"] = {"ativo": False}
+        
+        return resultado
     except HTTPException:
         raise
     except Exception as e:

package/backend-template/core/climate_adapter.py

@@ -0,0 +1,142 @@
+"""
+Adaptador para integrar dados climáticos reais no planejamento agrícola
+"""
+from typing import Optional, Dict, Any
+from providers.weather_provider import get_weather_summary
+from providers.types import WeatherSummary
+
+def classificar_clima_por_temperatura(temp_media: Optional[float]) -> Optional[str]:
+    """Classifica clima baseado na temperatura média"""
+    if temp_media is None:
+        return None
+    
+    if temp_media >= 28:
+        return "quente"
+    if temp_media < 18:
+        return "frio"
+    return "ameno"
+
+def classificar_agua_por_precipitacao(precipitacao_total: Optional[float]) -> Optional[str]:
+    """Classifica disponibilidade de água baseada na precipitação"""
+    if precipitacao_total is None:
+        return None
+    
+    if precipitacao_total < 50:
+        return "baixa"
+    if precipitacao_total > 120:
+        return "alta"
+    return "media"
+
+def calcular_ajuste_risco_climatico(risco_climatico: str) -> float:
+    """Calcula ajuste de risco baseado no risco climático estimado"""
+    ajustes = {
+        "alto": 0.15,      # +15% risco
+        "medio": 0.05,     # +5% risco  
+        "baixo": -0.03,    # -3% risco (leve benefício)
+        "indeterminado": 0
+    }
+    return ajustes.get(risco_climatico, 0)
+
+def criar_contexto_climatico(weather_summary: WeatherSummary) -> Dict[str, Any]:
+    """Cria contexto climático para uso no planejamento"""
+    
+    clima_observado = classificar_clima_por_temperatura(weather_summary.temperatura_media)
+    agua_observada = classificar_agua_por_precipitacao(weather_summary.precipitacao_total)
+    ajuste_risco = calcular_ajuste_risco_climatico(weather_summary.risco_climatico_estimado)
+    
+    return {
+        "clima_observado": clima_observado,
+        "agua_observada": agua_observada,
+        "ajuste_risco": ajuste_risco,
+        "fonte": weather_summary.source,
+        "fallback": weather_summary.fallback,
+        "temperatura_media": weather_summary.temperatura_media,
+        "temperatura_maxima": weather_summary.temperatura_maxima,
+        "temperatura_minima": weather_summary.temperatura_minima,
+        "precipitacao_total": weather_summary.precipitacao_total,
+        "evapotranspiracao": weather_summary.evapotranspiracao,
+        "umidade_media": weather_summary.umidade_media,
+        "radiacao_solar": weather_summary.radiacao_solar,
+        "risco_climatico_estimado": weather_summary.risco_climatico_estimado,
+        "error": weather_summary.error
+    }
+
+def aplicar_contexto_climatico_no_plano(resultado_ag: Dict[str, Any], contexto_climatico: Dict[str, Any]) -> Dict[str, Any]:
+    """Aplica ajustes climáticos no resultado do algoritmo genético"""
+    
+    if not contexto_climatico or contexto_climatico.get("ajuste_risco", 0) == 0:
+        # Sem ajuste necessário
+        resultado_ag["ajuste_climatico_aplicado"] = False
+        resultado_ag["contexto_climatico"] = contexto_climatico
+        return resultado_ag
+    
+    ajuste_risco = contexto_climatico["ajuste_risco"]
+    
+    # Aplicar ajuste no plano otimizado
+    if "plano_otimizado" in resultado_ag:
+        for item in resultado_ag["plano_otimizado"]:
+            if "risco" in item:
+                risco_original = item["risco"]
+                # Aplicar ajuste mantendo risco entre 0.05 e 0.95
+                novo_risco = min(0.95, max(0.05, risco_original + ajuste_risco))
+                item["risco"] = round(novo_risco, 3)
+                item["risco_original"] = risco_original
+                item["ajuste_aplicado"] = ajuste_risco
+    
+    # Recalcular métricas gerais se existirem
+    if "metricas" in resultado_ag and "risco_medio" in resultado_ag["metricas"]:
+        risco_original = resultado_ag["metricas"]["risco_medio"]
+        novo_risco = min(0.95, max(0.05, risco_original + ajuste_risco))
+        resultado_ag["metricas"]["risco_medio"] = round(novo_risco, 3)
+        resultado_ag["metricas"]["risco_medio_original"] = risco_original
+    
+    # Marcar que ajuste foi aplicado
+    resultado_ag["ajuste_climatico_aplicado"] = True
+    resultado_ag["contexto_climatico"] = contexto_climatico
+    
+    return resultado_ag
+
+def obter_contexto_climatico_por_coordenadas(lat: float, lon: float, days: int = 30) -> Optional[Dict[str, Any]]:
+    """Obtém contexto climático para coordenadas específicas"""
+    try:
+        weather_summary = get_weather_summary(lat, lon, days)
+        return criar_contexto_climatico(weather_summary)
+    except Exception as e:
+        # Em caso de erro, retornar contexto vazio
+        return {
+            "clima_observado": None,
+            "agua_observada": None,
+            "ajuste_risco": 0,
+            "fonte": "erro",
+            "fallback": True,
+            "error": str(e),
+            "temperatura_media": None,
+            "precipitacao_total": None,
+            "risco_climatico_estimado": "indeterminado"
+        }
+
+def gerar_plano_com_clima(culturas, talhoes, regras, objetivo="equilibrado", seed=42, 
+                         geracoes=100, populacao=50, lat=None, lon=None, days=30):
+    """
+    Wrapper para gerar plano genético com contexto climático opcional
+    """
+    from .planner import gerar_plano_genetico
+    
+    # Gerar plano normalmente
+    resultado = gerar_plano_genetico(
+        culturas, talhoes, regras, 
+        objetivo=objetivo, seed=seed, 
+        geracoes=geracoes, populacao=populacao
+    )
+    
+    # Se coordenadas foram fornecidas, aplicar contexto climático
+    if lat is not None and lon is not None:
+        contexto_climatico = obter_contexto_climatico_por_coordenadas(lat, lon, days)
+        if contexto_climatico:
+            resultado = aplicar_contexto_climatico_no_plano(resultado, contexto_climatico)
+    else:
+        # Marcar que não há clima real aplicado
+        resultado["ajuste_climatico_aplicado"] = False
+        resultado["contexto_climatico"] = None
+    
+    return resultado

package/backend-template/providers/__init__.py

@@ -0,0 +1 @@
+# Provedores de dados reais para AgroPlan AI

package/backend-template/providers/cache.py

@@ -0,0 +1,49 @@
+"""
+Cache simples em memória para chamadas de APIs externas
+"""
+import time
+from typing import Any, Optional
+
+# Cache global em memória
+_cache = {}
+
+def get_cache(key: str) -> Optional[Any]:
+    """Recupera valor do cache se ainda válido"""
+    if key not in _cache:
+        return None
+    
+    value, expiry = _cache[key]
+    if time.time() > expiry:
+        # Cache expirado, remove
+        del _cache[key]
+        return None
+    
+    return value
+
+def set_cache(key: str, value: Any, ttl_seconds: int = 3600) -> None:
+    """Armazena valor no cache com TTL"""
+    expiry = time.time() + ttl_seconds
+    _cache[key] = (value, expiry)
+
+def clear_provider_cache() -> None:
+    """Limpa todo o cache de provedores"""
+    global _cache
+    _cache = {}
+
+def get_cache_stats() -> dict:
+    """Retorna estatísticas do cache"""
+    current_time = time.time()
+    valid_items = 0
+    expired_items = 0
+    
+    for key, (value, expiry) in _cache.items():
+        if current_time <= expiry:
+            valid_items += 1
+        else:
+            expired_items += 1
+    
+    return {
+        "total_items": len(_cache),
+        "valid_items": valid_items,
+        "expired_items": expired_items
+    }

package/backend-template/providers/types.py

@@ -0,0 +1,40 @@
+"""
+Tipos de dados para provedores externos
+"""
+from typing import Optional
+from dataclasses import dataclass
+
+@dataclass
+class WeatherSummary:
+    """Resumo de dados climáticos"""
+    source: str
+    latitude: float
+    longitude: float
+    temperatura_media: Optional[float] = None
+    temperatura_maxima: Optional[float] = None
+    temperatura_minima: Optional[float] = None
+    precipitacao_total: Optional[float] = None
+    evapotranspiracao: Optional[float] = None
+    umidade_media: Optional[float] = None
+    radiacao_solar: Optional[float] = None
+    risco_climatico_estimado: str = "indeterminado"
+    fallback: bool = False
+    error: Optional[str] = None
+    
+    def to_dict(self) -> dict:
+        """Converte para dicionário para JSON"""
+        return {
+            "source": self.source,
+            "latitude": self.latitude,
+            "longitude": self.longitude,
+            "temperatura_media": self.temperatura_media,
+            "temperatura_maxima": self.temperatura_maxima,
+            "temperatura_minima": self.temperatura_minima,
+            "precipitacao_total": self.precipitacao_total,
+            "evapotranspiracao": self.evapotranspiracao,
+            "umidade_media": self.umidade_media,
+            "radiacao_solar": self.radiacao_solar,
+            "risco_climatico_estimado": self.risco_climatico_estimado,
+            "fallback": self.fallback,
+            "error": self.error
+        }

package/backend-template/providers/weather_provider.py

@@ -0,0 +1,161 @@
+"""
+Provedor de dados climáticos usando Open-Meteo
+"""
+import urllib.request
+import urllib.parse
+import json
+from datetime import datetime, timedelta
+from typing import Optional
+from .types import WeatherSummary
+from .cache import get_cache, set_cache
+
+def estimar_risco_climatico(temp_media: Optional[float], precipitacao_total: Optional[float]) -> str:
+    """Estima risco climático baseado em temperatura e precipitação"""
+    if temp_media is None or precipitacao_total is None:
+        return "indeterminado"
+    
+    # Heurística simples inicial
+    if precipitacao_total < 30:
+        return "alto"
+    if temp_media > 34:
+        return "alto"
+    if precipitacao_total < 70:
+        return "medio"
+    return "baixo"
+
+def get_weather_summary(lat: float, lon: float, days: int = 30) -> WeatherSummary:
+    """
+    Obtém resumo climático usando Open-Meteo
+    
+    Args:
+        lat: Latitude
+        lon: Longitude  
+        days: Número de dias para análise (padrão 30)
+    
+    Returns:
+        WeatherSummary com dados climáticos ou fallback
+    """
+    
+    # Chave do cache
+    cache_key = f"weather_{lat}_{lon}_{days}"
+    
+    # Verificar cache primeiro
+    cached = get_cache(cache_key)
+    if cached:
+        return WeatherSummary(**cached)
+    
+    try:
+        # Calcular datas (últimos N dias)
+        end_date = datetime.now().date()
+        start_date = end_date - timedelta(days=days)
+        
+        # Parâmetros da API Open-Meteo Archive
+        params = {
+            "latitude": str(lat),
+            "longitude": str(lon),
+            "start_date": start_date.strftime("%Y-%m-%d"),
+            "end_date": end_date.strftime("%Y-%m-%d"),
+            "daily": ",".join([
+                "temperature_2m_mean",
+                "temperature_2m_max", 
+                "temperature_2m_min",
+                "precipitation_sum",
+                "et0_fao_evapotranspiration",
+                "relative_humidity_2m_mean",
+                "shortwave_radiation_sum"
+            ]),
+            "timezone": "America/Sao_Paulo"
+        }
+        
+        # Construir URL
+        base_url = "https://archive-api.open-meteo.com/v1/archive"
+        query_string = urllib.parse.urlencode(params)
+        url = f"{base_url}?{query_string}"
+        
+        # Fazer requisição
+        with urllib.request.urlopen(url, timeout=10) as response:
+            data = json.loads(response.read().decode())
+        
+        daily = data.get("daily", {})
+        
+        # Extrair dados
+        temps_mean = daily.get("temperature_2m_mean", [])
+        temps_max = daily.get("temperature_2m_max", [])
+        temps_min = daily.get("temperature_2m_min", [])
+        precipitation = daily.get("precipitation_sum", [])
+        evapotranspiration = daily.get("et0_fao_evapotranspiration", [])
+        humidity = daily.get("relative_humidity_2m_mean", [])
+        radiation = daily.get("shortwave_radiation_sum", [])
+        
+        # Calcular médias (ignorando valores None)
+        def safe_mean(values):
+            valid_values = [v for v in values if v is not None]
+            return sum(valid_values) / len(valid_values) if valid_values else None
+        
+        def safe_sum(values):
+            valid_values = [v for v in values if v is not None]
+            return sum(valid_values) if valid_values else None
+        
+        temp_media = safe_mean(temps_mean)
+        temp_maxima = safe_mean(temps_max)
+        temp_minima = safe_mean(temps_min)
+        precip_total = safe_sum(precipitation)
+        evap_media = safe_mean(evapotranspiration)
+        umid_media = safe_mean(humidity)
+        rad_total = safe_sum(radiation)
+        
+        # Estimar risco climático
+        risco = estimar_risco_climatico(temp_media, precip_total)
+        
+        # Criar resultado
+        result = WeatherSummary(
+            source="open-meteo",
+            latitude=lat,
+            longitude=lon,
+            temperatura_media=round(temp_media, 1) if temp_media else None,
+            temperatura_maxima=round(temp_maxima, 1) if temp_maxima else None,
+            temperatura_minima=round(temp_minima, 1) if temp_minima else None,
+            precipitacao_total=round(precip_total, 1) if precip_total else None,
+            evapotranspiracao=round(evap_media, 2) if evap_media else None,
+            umidade_media=round(umid_media, 1) if umid_media else None,
+            radiacao_solar=round(rad_total, 1) if rad_total else None,
+            risco_climatico_estimado=risco,
+            fallback=False,
+            error=None
+        )
+        
+        # Cachear por 1 hora (dados históricos mudam pouco)
+        set_cache(cache_key, result.to_dict(), ttl_seconds=3600)
+        
+        return result
+        
+    except Exception as e:
+        # Fallback para dados simulados
+        return _get_fallback_weather(lat, lon, str(e))
+
+def _get_fallback_weather(lat: float, lon: float, error: str) -> WeatherSummary:
+    """Retorna dados climáticos simulados como fallback"""
+    
+    # Dados simulados baseados na localização (heurística simples)
+    # Região Sudeste do Brasil como referência
+    temp_base = 22.0
+    if lat < -25:  # Mais ao sul, mais frio
+        temp_base = 18.0
+    elif lat > -20:  # Mais ao norte, mais quente
+        temp_base = 26.0
+    
+    return WeatherSummary(
+        source="simulado",
+        latitude=lat,
+        longitude=lon,
+        temperatura_media=temp_base,
+        temperatura_maxima=temp_base + 8,
+        temperatura_minima=temp_base - 6,
+        precipitacao_total=120.0,  # mm/mês típico
+        evapotranspiracao=4.5,     # mm/dia típico
+        umidade_media=65.0,        # % típico
+        radiacao_solar=180.0,      # MJ/m² típico mensal
+        risco_climatico_estimado="medio",
+        fallback=True,
+        error=f"Open-Meteo indisponível: {error}"
+    )

package/dist/index.js

@@ -779,7 +779,7 @@ var COMMANDS = {
   open: "Abre o AgroPlan AI no navegador"
 };
 function showHelp() {
-  console.log("\uD83C\uDF31 AgroPlan AI - CLI Local v1.0.7");
+  console.log("\uD83C\uDF31 AgroPlan AI - CLI Local v1.0.8");
   console.log(`   Launcher para modo local acelerado
 `);
   console.log("\uD83D\uDCCB Comandos dispon\xEDveis:");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agroplan-ai-cli",
-  "version": "1.0.7",
+  "version": "1.0.9",
   "description": "CLI global para AgroPlan AI - modo local acelerado",
   "type": "module",
   "bin": {