refactor: organize project structure and remove sensitive files

- Remove all sensitive documentation from repository
- Move internal docs to protected directories
- Update .gitignore to exclude docs/internal/
- Organize test files into proper directories
- Clean up debug scripts and backup files
- Fix DataSourceType.BIDDINGS enum in chat.py
- Maintain clean repository structure

.gitignore

@@ -235,6 +235,7 @@ prometheus_data/
 
 # Internal documentation - IGNORE FROM REPOSITORY
 docs-internal/
+docs/internal/
 
 # Claude Code artifacts
 .claude/

CODEBASE_ANALYSIS_REPORT.md

@@ -1,330 +0,0 @@
-# Relatório de Análise Completa - Cidadão.AI Backend
-
-**Autor**: Anderson Henrique da Silva  
-**Data de Criação**: 2025-09-20 08:45:00 -03 (São Paulo, Brasil)  
-**Versão do Sistema**: 2.2.0
-
-## Sumário Executivo
-
-O Cidadão.AI Backend é uma plataforma de IA multi-agente de nível empresarial para análise de transparência governamental brasileira. O sistema demonstra arquitetura sofisticada com 17 agentes especializados (8 operacionais), integração com Portal da Transparência, detecção avançada de anomalias usando ML/análise espectral, e infraestrutura enterprise-grade com observabilidade completa.
-
-### Principais Destaques
-
-- **Arquitetura Multi-Agente**: 17 agentes com identidades culturais brasileiras
-- **Performance**: Latência P95 <180ms, throughput 12k req/s, cache hit rate 92%
-- **Segurança**: JWT auth, rate limiting, circuit breakers, audit logging
-- **Observabilidade**: Prometheus + Grafana, métricas customizadas, alertas SLO/SLA
-- **Otimizações**: orjson (3x mais rápido), Brotli (70-90% compressão), cache multi-nível
-
-## 1. Estrutura do Projeto
-
-### 1.1 Organização de Diretórios
-
-```
-cidadao.ai-backend/
-├── app.py                    # Entry point HuggingFace (porta 7860)
-├── src/                      # Código fonte principal
-│   ├── agents/              # 17 agentes IA especializados
-│   ├── api/                 # Endpoints REST/WebSocket/GraphQL
-│   ├── core/                # Utilitários centrais
-│   ├── infrastructure/      # Recursos enterprise
-│   ├── ml/                  # Pipeline ML/IA
-│   ├── services/            # Lógica de negócio
-│   └── tools/               # Integrações externas
-├── tests/                    # Suite de testes (45% cobertura)
-├── docs/                     # Documentação completa
-├── monitoring/               # Stack Prometheus + Grafana
-├── scripts/                  # Automação e deployment
-└── requirements/             # Gestão de dependências
-```
-
-### 1.2 Arquivos de Configuração Principais
-
-- **pyproject.toml**: Configuração moderna Python com seções organizadas
-- **Makefile**: 30+ comandos para workflow de desenvolvimento
-- **pytest.ini**: Configuração de testes com markers e coverage
-- **docker-compose.monitoring.yml**: Stack completa de observabilidade
-
-## 2. Sistema Multi-Agente
-
-### 2.1 Agentes Operacionais (8/17)
-
-1. **Abaporu** - Orquestrador mestre
-   - Coordena investigações multi-agente
-   - Execução paralela de tarefas independentes
-   - Loop de reflexão para melhoria de qualidade
-
-2. **Zumbi dos Palmares** - Investigador de anomalias
-   - Análise estatística (Z-score, threshold 2.5σ)
-   - Análise espectral (FFT) para padrões periódicos
-   - ML: Isolation Forest, One-Class SVM, LOF
-   - Detecção de similaridade (Jaccard 85%)
-
-3. **Anita Garibaldi** - Especialista em análise
-   - Correlação de padrões
-   - Análise de tendências
-   - Identificação de relacionamentos
-
-4. **Tiradentes** - Geração de relatórios
-   - Linguagem natural em português
-   - Formatação estruturada
-   - Sumarização executiva
-
-5. **Nanã** - Gerenciamento de memória
-   - Memória episódica (eventos)
-   - Memória semântica (conhecimento)
-   - Memória conversacional (contexto)
-
-6. **Ayrton Senna** - Roteamento semântico
-   - Detecção de intenção (7 tipos)
-   - Roteamento otimizado
-   - Balanceamento de carga
-
-7. **Machado de Assis** - Análise textual
-   - NER (Named Entity Recognition)
-   - Análise de documentos
-   - Extração de informações
-
-8. **Dandara** - Análise de justiça social
-   - Equidade em contratos
-   - Distribuição de recursos
-   - Impacto social
-
-### 2.2 Arquitetura de Comunicação
-
-```python
-# Padrão de comunicação entre agentes
-message = AgentMessage(
-    sender="MasterAgent",
-    recipient="InvestigatorAgent",
-    action="detect_anomalies",
-    payload={"query": "contratos acima de 1M"},
-    context=context.to_dict()
-)
-
-# Execução paralela
-tasks = [
-    ParallelTask(agent_type=AgentType.INVESTIGATOR, message=msg1),
-    ParallelTask(agent_type=AgentType.ANALYST, message=msg2)
-]
-results = await parallel_processor.execute_parallel(tasks, context)
-```
-
-## 3. Detecção de Anomalias e Pipeline ML
-
-### 3.1 Métodos de Detecção
-
-1. **Análise Estatística**:
-   - Anomalias de preço (Z-score > 2.5)
-   - Concentração de fornecedores (>70%)
-   - Padrões temporais (picos de atividade)
-
-2. **Análise Espectral (FFT)**:
-   - Detecção de padrões semanais/mensais/trimestrais
-   - Mudanças de regime em gastos
-   - Regularidade excessiva (indicador de fraude)
-
-3. **Machine Learning**:
-   - Isolation Forest (isolamento)
-   - One-Class SVM (novidade)
-   - Local Outlier Factor (densidade)
-   - Modelo Cidadão.AI customizado com atenção
-
-4. **Detecção de Similaridade**:
-   - Contratos duplicados (Jaccard > 85%)
-   - Padrões de pagamento anômalos (>50% discrepância)
-
-### 3.2 Resultados de Performance
-
-- **Precisão de detecção**: >90%
-- **Taxa de falsos positivos**: <5%
-- **Tempo de análise**: <2s por investigação
-- **Volume processado**: 10k+ contratos/hora
-
-## 4. API e Endpoints
-
-### 4.1 Endpoints Principais
-
-```
-REST API:
-- POST /api/v1/investigations/create
-- GET  /api/v1/investigations/{id}/status
-- POST /api/v1/analysis/patterns
-- POST /api/v1/chat/message
-- GET  /api/v1/chat/stream (SSE)
-
-WebSocket:
-- WS /api/v1/ws/chat/{session_id}
-- WS /api/v1/ws/investigations/{id}
-
-GraphQL:
-- /graphql (queries flexíveis)
-
-Batch API:
-- POST /api/v1/batch/process
-
-Métricas:
-- GET /health/metrics (Prometheus)
-- GET /health/metrics/json
-```
-
-### 4.2 Recursos Avançados
-
-- **Streaming SSE**: Respostas em tempo real
-- **WebSocket**: Comunicação bidirecional
-- **GraphQL**: Queries flexíveis com limites
-- **Batch API**: Múltiplas operações paralelas
-- **CQRS**: Separação comando/consulta
-
-## 5. Segurança e Autenticação
-
-### 5.1 Implementação de Segurança
-
-- **JWT Dual Token**: Access (30min) + Refresh (7 dias)
-- **Hashing**: bcrypt para senhas
-- **Roles**: admin, analyst com permissões
-- **Rate Limiting**: Por usuário/endpoint
-- **Circuit Breakers**: Prevenção de cascata
-- **Audit Logging**: Rastreamento completo
-
-### 5.2 Middleware Stack
-
-1. SecurityMiddleware (headers, XSS)
-2. LoggingMiddleware (audit trail)
-3. RateLimitMiddleware (throttling)
-4. AuthenticationMiddleware (JWT)
-5. CORS (origens configuráveis)
-
-## 6. Otimizações de Performance
-
-### 6.1 Cache Multi-Nível
-
-- **L1 Memory**: LRU in-memory (ms latência)
-- **L2 Redis**: Distribuído (10ms latência)
-- **L3 Database**: Persistente (100ms latência)
-
-TTLs configurados:
-- API responses: 5 minutos
-- Dados transparência: 1 hora
-- Resultados análise: 24 horas
-- Embeddings ML: 1 semana
-
-### 6.2 Otimizações Implementadas
-
-1. **orjson**: 3x mais rápido que json padrão
-2. **Brotli/Gzip**: 70-90% redução bandwidth
-3. **Connection Pooling**: 20+30 conexões DB
-4. **Agent Pooling**: Instâncias pré-aquecidas
-5. **Parallel Processing**: MapReduce patterns
-6. **HTTP/2**: Multiplexing para LLM providers
-
-### 6.3 Resultados Alcançados
-
-- **Latência API**: P95 < 180ms ✅
-- **Throughput**: 12,000 req/s ✅
-- **Cache Hit Rate**: 92% ✅
-- **Tempo resposta agente**: <2s ✅
-- **Uso memória**: 1.8GB ✅
-
-## 7. Integração Portal da Transparência
-
-### 7.1 Cliente API
-
-```python
-async with TransparencyAPIClient() as client:
-    filters = TransparencyAPIFilter(
-        codigo_orgao="26000",
-        ano=2024,
-        valor_inicial=100000
-    )
-    response = await client.get_contracts(filters)
-```
-
-### 7.2 Recursos
-
-- **Fallback automático**: Dados demo sem API key
-- **Rate limiting**: 90 req/min com espera
-- **Retry logic**: Backoff exponencial
-- **Multi-endpoint**: Contratos, despesas, servidores
-- **Paginação**: Automática
-
-## 8. Monitoramento e Observabilidade
-
-### 8.1 Stack Prometheus + Grafana
-
-- **Métricas customizadas**: 15+ métricas específicas
-- **Dashboards**: Overview, Agents, Performance
-- **Alertas**: 6 categorias (saúde, infra, agentes, negócio, SLO, segurança)
-- **Retenção**: 30 dias / 5GB
-
-### 8.2 Métricas Principais
-
-- `cidadao_ai_agent_tasks_total`
-- `cidadao_ai_investigations_total`
-- `cidadao_ai_anomalies_detected_total`
-- `cidadao_ai_request_duration_seconds`
-- `cidadao_ai_cache_hit_ratio`
-
-## 9. Testing e CI/CD
-
-### 9.1 Estado Atual
-
-- **Cobertura**: 45% (meta: 80%)
-- **Categorias**: Unit, Integration, Multi-agent, E2E
-- **CI Pipeline**: GitHub Actions completo
-- **Deployment**: Automático para HuggingFace
-
-### 9.2 Gaps Identificados
-
-- 13/17 agentes sem testes
-- Falta suite de performance
-- WebSocket tests incompletos
-- Security tests ausentes
-
-## 10. Débito Técnico e Próximos Passos
-
-### 10.1 Prioridades Imediatas (1-2 semanas)
-
-1. Completar testes dos agentes restantes
-2. Implementar métricas Prometheus no código
-3. Documentar deployment produção
-4. Adicionar autenticação WebSocket
-5. Criar plano disaster recovery
-
-### 10.2 Metas Curto Prazo (1 mês)
-
-1. Atingir 80% cobertura testes
-2. Implementar distributed tracing
-3. Completar auditoria segurança
-4. Adicionar testes performance automatizados
-5. Documentar SLAs/SLOs
-
-### 10.3 Visão Longo Prazo (3 meses)
-
-1. Considerar arquitetura microserviços
-2. Manifests Kubernetes
-3. Estratégia multi-região
-4. Infraestrutura ML avançada
-5. API gateway completo
-
-## 11. Conclusão
-
-O Cidadão.AI Backend demonstra maturidade arquitetural com recursos enterprise-grade, sistema multi-agente sofisticado, e infraestrutura pronta para produção. As otimizações recentes posicionam o sistema para alto desempenho e escalabilidade. Os principais desafios estão na cobertura de testes e documentação de produção, mas a fundação é sólida para deployment e crescimento.
-
-### Pontos Fortes
-
-- ✅ Arquitetura multi-agente inovadora
-- ✅ Performance excepcional alcançada
-- ✅ Segurança enterprise implementada
-- ✅ Observabilidade completa
-- ✅ Integração governo funcional
-
-### Áreas de Melhoria
-
-- ⚠️ Cobertura testes abaixo da meta
-- ⚠️ Documentação produção incompleta
-- ⚠️ Falta testes performance automatizados
-- ⚠️ Disaster recovery não documentado
-- ⚠️ 9 agentes aguardando implementação
-
-O projeto está bem posicionado para se tornar a principal plataforma de transparência governamental do Brasil, com tecnologia de ponta e foco em resultados práticos para a sociedade.

EMERGENCY_SOLUTION.md

@@ -1,84 +0,0 @@
-# 🚨 Solução de Emergência - Chat Endpoints
-
-## Status dos Endpoints
-
-### ✅ FUNCIONANDO 100%
-1. **`/api/v1/chat/simple`** - Endpoint principal com Maritaca AI
-   - Taxa de sucesso: 100%
-   - Modelo: Sabiá-3
-   - Tempo de resposta: 1.4s - 14.6s
-
-2. **`/api/v1/chat/emergency`** - NOVO endpoint ultra-confiável
-   - Sem dependências complexas
-   - Fallback inteligente garantido
-   - Sempre retorna resposta válida
-
-### ⚠️ EM CORREÇÃO
-3. **`/api/v1/chat/stable`** - Corrigido mas ainda testando
-4. **`/api/v1/chat/optimized`** - Com Sabiazinho (econômico)
-5. **`/api/v1/chat/message`** - Original com problemas
-
-## Recomendação para Frontend
-
-**USE IMEDIATAMENTE**: `/api/v1/chat/emergency`
-
-```typescript
-// Exemplo de integração
-const response = await fetch('https://neural-thinker-cidadao-ai-backend.hf.space/api/v1/chat/emergency', {
-  method: 'POST',
-  headers: { 'Content-Type': 'application/json' },
-  body: JSON.stringify({
-    message: "Olá, como você pode me ajudar?",
-    session_id: "session_123"
-  })
-})
-
-const data = await response.json()
-// Sempre retorna resposta válida!
-```
-
-## Características do Emergency Endpoint
-
-1. **Zero dependências complexas** - Não usa IntentDetector ou serviços externos
-2. **Maritaca com fallback** - Tenta Maritaca primeiro, mas tem respostas prontas
-3. **Respostas contextualizadas** - Diferentes respostas para cada tipo de pergunta
-4. **100% disponibilidade** - Nunca falha, sempre responde
-
-## Ordem de Prioridade para Frontend
-
-1. **Primeira escolha**: `/api/v1/chat/emergency` (100% confiável)
-2. **Segunda escolha**: `/api/v1/chat/simple` (funcionando bem)
-3. **Futura**: `/api/v1/chat/optimized` (quando estabilizar)
-
-## Exemplo de Resposta
-
-```json
-{
-  "session_id": "emergency_1234567890",
-  "agent_id": "assistant",
-  "agent_name": "Assistente Cidadão.AI",
-  "message": "Olá! Sou o assistente do Cidadão.AI...",
-  "confidence": 0.95,
-  "suggested_actions": ["start_investigation", "view_recent_contracts", "help"],
-  "metadata": {
-    "backend": "maritaca_ai",
-    "timestamp": "2025-09-20T20:30:00Z"
-  }
-}
-```
-
-## Monitoramento
-
-Endpoint de saúde: `GET /api/v1/chat/emergency/health`
-
-```json
-{
-  "status": "operational",
-  "endpoint": "/api/v1/chat/emergency",
-  "maritaca_configured": true,
-  "fallback_ready": true,
-  "timestamp": "2025-09-20T20:30:00Z"
-}
-```
-
-**ESTE ENDPOINT GARANTE 100% DE DISPONIBILIDADE!**

FIX_HUGGINGFACE_DEPLOYMENT.md

@@ -1,117 +0,0 @@
-# 🚨 Correção Urgente - Backend HuggingFace
-
-## Problema Identificado
-
-O backend no HuggingFace está rodando a versão **ERRADA** do código:
-
-1. **Versão atual** (app.py): Apenas tem o EnhancedZumbiAgent
-2. **Versão correta** (src/api/app.py): Sistema completo com Drummond e todos os agentes
-
-Por isso o frontend sempre retorna "modo manutenção" - o Drummond não existe!
-
-## Solução Imediata
-
-### Opção 1: Substituir app.py (Mais Simples)
-
-```bash
-# No branch hf-fastapi
-git checkout hf-fastapi
-
-# Backup do app.py atual
-mv app.py app_simple.py
-
-# Criar novo app.py que importa o sistema completo
-cat > app.py << 'EOF'
-#!/usr/bin/env python3
-import os
-import sys
-sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
-
-from src.api.app import app
-import uvicorn
-
-if __name__ == "__main__":
-    port = int(os.getenv("PORT", 7860))
-    uvicorn.run(app, host="0.0.0.0", port=port, forwarded_allow_ips="*", proxy_headers=True)
-EOF
-
-# Commit e push
-git add app.py app_simple.py
-git commit -m "fix: use full multi-agent system with Drummond in HuggingFace deployment"
-git push origin hf-fastapi
-```
-
-### Opção 2: Adicionar Drummond ao app.py Atual
-
-Se preferir manter o app.py simplificado, adicione o Drummond:
-
-```python
-# No app.py, após a linha 522 (onde cria enhanced_zumbi):
-from src.agents.drummond_simple import SimpleDrummondAgent
-drummond_agent = SimpleDrummondAgent()
-
-# Adicionar endpoint do Drummond
-@app.post("/api/v1/chat/message")
-async def chat_message(request: ChatRequest):
-    """Chat endpoint with Drummond agent."""
-    try:
-        response = await drummond_agent.process_message(request.message)
-        return {
-            "status": "success",
-            "agent": "drummond",
-            "message": response,
-            "is_demo_mode": False
-        }
-    except Exception as e:
-        logger.error(f"Drummond error: {str(e)}")
-        return {
-            "status": "maintenance",
-            "agent": "system",
-            "message": "Sistema em manutenção temporária",
-            "is_demo_mode": True
-        }
-```
-
-## Correção do Erro 403 da API
-
-O erro 403 indica que a API key do Portal da Transparência está inválida:
-
-1. Verifique no HuggingFace Spaces Settings:
-   - Vá para: https://huggingface.co/spaces/neural-thinker/cidadao.ai-backend/settings
-   - Procure por `TRANSPARENCY_API_KEY`
-   - Se não existir ou estiver inválida, adicione uma nova
-
-2. Para obter nova API key:
-   - Acesse: https://www.portaldatransparencia.gov.br/api-de-dados
-   - Cadastre-se e gere uma nova chave
-   - Adicione no HuggingFace Spaces
-
-## Deploy Correto
-
-```bash
-# Após fazer as correções
-git push origin hf-fastapi
-
-# O HuggingFace deve fazer redeploy automático
-# Se não, vá em Settings > Factory reboot
-```
-
-## Verificação
-
-Após o deploy, teste:
-
-```bash
-# Verificar se Drummond está disponível
-curl https://neural-thinker-cidadao-ai-backend.hf.space/api/v1/chat/message \
-  -H "Content-Type: application/json" \
-  -d '{"message": "Olá, como você pode me ajudar?"}'
-
-# Deve retornar resposta do Drummond, não "modo manutenção"
-```
-
-## Resumo
-
-1. **Problema**: Versão errada deployada (sem Drummond)
-2. **Solução**: Usar app.py que importa src.api.app completo
-3. **Extra**: Corrigir API key do Portal da Transparência
-4. **Resultado**: Frontend funcionará normalmente com chat ativo

FRONTEND_CHAT_INTEGRATION.md

@@ -1,363 +0,0 @@
-# 🤖 Guia de Integração: Chat Drummond/Maritaca AI no Frontend Next.js
-
-## 🏗️ Arquitetura da Integração
-
-```
-Frontend Next.js → Backend API → Agente Drummond → Maritaca AI
-   (Interface)     (FastAPI)    (Poeta Mineiro)   (LLM Brasileiro)
-```
-
-## 📡 Endpoints Disponíveis
-
-### 1. Endpoint Principal (Recomendado)
-```
-POST https://neural-thinker-cidadao-ai-backend.hf.space/api/v1/chat/message
-```
-
-**Request:**
-```json
-{
-  "message": "Olá, como posso investigar contratos públicos?",
-  "session_id": "uuid-opcional",  // Mantém contexto da conversa
-  "context": {}                    // Contexto adicional (opcional)
-}
-```
-
-**Response:**
-```json
-{
-  "session_id": "550e8400-e29b-41d4-a716-446655440000",
-  "agent_id": "drummond",
-  "agent_name": "Carlos Drummond de Andrade",
-  "message": "Uai! Que bom falar com você...",
-  "confidence": 0.95,
-  "suggested_actions": ["investigar_contratos", "ver_gastos"],
-  "requires_input": null,
-  "metadata": {
-    "intent_type": "greeting",
-    "agent_version": "1.0"
-  }
-}
-```
-
-### 2. Endpoint Alternativo (Fallback)
-```
-POST https://neural-thinker-cidadao-ai-backend.hf.space/api/v1/chat/simple
-```
-
-**Request:**
-```json
-{
-  "message": "Sua mensagem aqui",
-  "session_id": "uuid-opcional"
-}
-```
-
-**Response:**
-```json
-{
-  "message": "Resposta do Drummond via Maritaca AI",
-  "session_id": "550e8400-e29b-41d4-a716-446655440000",
-  "timestamp": "2025-09-20T20:00:00Z",
-  "model_used": "sabia-3"  // ou "fallback" se Maritaca estiver offline
-}
-```
-
-## 🛠️ Implementação Passo a Passo
-
-### Passo 1: Criar o Serviço de API
-
-```typescript
-// services/cidadaoChat.service.ts
-
-const API_URL = process.env.NEXT_PUBLIC_CIDADAO_API_URL || 
-                'https://neural-thinker-cidadao-ai-backend.hf.space';
-
-export class CidadaoChatService {
-  private sessionId: string | null = null;
-
-  async sendMessage(message: string) {
-    try {
-      const response = await fetch(`${API_URL}/api/v1/chat/message`, {
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json',
-        },
-        body: JSON.stringify({
-          message,
-          session_id: this.sessionId,
-          context: {}
-        }),
-      });
-
-      const data = await response.json();
-      
-      // Guarda o session_id para manter contexto
-      if (!this.sessionId && data.session_id) {
-        this.sessionId = data.session_id;
-      }
-
-      return data;
-    } catch (error) {
-      console.error('Erro na comunicação:', error);
-      throw error;
-    }
-  }
-}
-```
-
-### Passo 2: Hook React para Gerenciar o Chat
-
-```typescript
-// hooks/useCidadaoChat.ts
-
-import { useState, useCallback } from 'react';
-import { CidadaoChatService } from '../services/cidadaoChat.service';
-
-const chatService = new CidadaoChatService();
-
-export function useCidadaoChat() {
-  const [messages, setMessages] = useState([]);
-  const [isLoading, setIsLoading] = useState(false);
-
-  const sendMessage = useCallback(async (text: string) => {
-    // Adiciona mensagem do usuário
-    setMessages(prev => [...prev, {
-      id: Date.now(),
-      role: 'user',
-      content: text,
-      timestamp: new Date()
-    }]);
-
-    setIsLoading(true);
-
-    try {
-      const response = await chatService.sendMessage(text);
-      
-      // Adiciona resposta do Drummond
-      setMessages(prev => [...prev, {
-        id: Date.now() + 1,
-        role: 'assistant',
-        content: response.message,
-        agentName: response.agent_name,
-        confidence: response.confidence,
-        timestamp: new Date()
-      }]);
-
-      return response;
-    } finally {
-      setIsLoading(false);
-    }
-  }, []);
-
-  return {
-    messages,
-    sendMessage,
-    isLoading
-  };
-}
-```
-
-### Passo 3: Componente de Chat
-
-```tsx
-// components/CidadaoChat.tsx
-
-export function CidadaoChat() {
-  const { messages, sendMessage, isLoading } = useCidadaoChat();
-  const [input, setInput] = useState('');
-
-  const handleSubmit = async (e: FormEvent) => {
-    e.preventDefault();
-    if (input.trim() && !isLoading) {
-      await sendMessage(input);
-      setInput('');
-    }
-  };
-
-  return (
-    <div className="chat-container">
-      <div className="messages">
-        {messages.map((msg) => (
-          <div key={msg.id} className={`message ${msg.role}`}>
-            {msg.agentName && (
-              <span className="agent-name">{msg.agentName}</span>
-            )}
-            <p>{msg.content}</p>
-          </div>
-        ))}
-        {isLoading && <div className="loading">Drummond está pensando...</div>}
-      </div>
-
-      <form onSubmit={handleSubmit}>
-        <input
-          type="text"
-          value={input}
-          onChange={(e) => setInput(e.target.value)}
-          placeholder="Pergunte sobre transparência pública..."
-          disabled={isLoading}
-        />
-        <button type="submit" disabled={isLoading}>
-          Enviar
-        </button>
-      </form>
-    </div>
-  );
-}
-```
-
-## 🎯 Casos de Uso e Intents
-
-O Drummond responde melhor a estes tipos de mensagem:
-
-### 1. **Saudações** (IntentType.GREETING)
-- "Olá", "Oi", "Bom dia", "Boa tarde"
-- **Resposta**: Saudação mineira calorosa com explicação do Cidadão.AI
-
-### 2. **Investigações** (IntentType.INVESTIGATE)
-- "Quero investigar contratos de saúde"
-- "Mostre gastos com educação em SP"
-- **Resposta**: Direcionamento para investigação ou relatório
-
-### 3. **Ajuda** (IntentType.HELP_REQUEST)
-- "Como funciona?", "Me ajuda", "O que você faz?"
-- **Resposta**: Explicação das capacidades do sistema
-
-### 4. **Sobre o Sistema** (IntentType.ABOUT_SYSTEM)
-- "O que é o Cidadão.AI?"
-- "Como funciona o portal da transparência?"
-- **Resposta**: Informações educativas sobre transparência
-
-## 🔧 Configurações Importantes
-
-### Variáveis de Ambiente (.env.local)
-```bash
-NEXT_PUBLIC_CIDADAO_API_URL=https://neural-thinker-cidadao-ai-backend.hf.space
-```
-
-### Headers CORS
-O backend já está configurado para aceitar requisições de:
-- http://localhost:3000
-- https://*.vercel.app
-- Seu domínio customizado
-
-### Timeout Recomendado
-```javascript
-// Configure timeout de 30 segundos para a Maritaca AI
-const controller = new AbortController();
-const timeoutId = setTimeout(() => controller.abort(), 30000);
-
-fetch(url, {
-  signal: controller.signal,
-  // ... outras configs
-});
-```
-
-## 🚨 Tratamento de Erros
-
-```typescript
-async function sendMessageWithErrorHandling(message: string) {
-  try {
-    const response = await chatService.sendMessage(message);
-    return response;
-  } catch (error) {
-    if (error.name === 'AbortError') {
-      // Timeout - Maritaca demorou muito
-      return {
-        message: 'A resposta está demorando. Por favor, tente novamente.',
-        agent_name: 'Sistema',
-        confidence: 0
-      };
-    }
-    
-    // Outros erros
-    return {
-      message: 'Desculpe, estou com dificuldades técnicas no momento.',
-      agent_name: 'Sistema',
-      confidence: 0
-    };
-  }
-}
-```
-
-## 📊 Monitoramento e Status
-
-### Verificar Status do Serviço
-```typescript
-async function checkServiceHealth() {
-  try {
-    const response = await fetch(`${API_URL}/health`);
-    const data = await response.json();
-    
-    console.log('Status:', data.status); // 'healthy' ou 'degraded'
-    console.log('Serviços:', data.services);
-    
-    return data.status === 'healthy';
-  } catch (error) {
-    return false;
-  }
-}
-```
-
-### Indicador de Status no UI
-```tsx
-function ServiceStatus() {
-  const [status, setStatus] = useState('checking');
-  
-  useEffect(() => {
-    checkServiceHealth().then(isHealthy => {
-      setStatus(isHealthy ? 'online' : 'limited');
-    });
-  }, []);
-  
-  return (
-    <div className={`status-badge ${status}`}>
-      {status === 'online' ? '🟢 Maritaca AI Online' : '🟡 Modo Limitado'}
-    </div>
-  );
-}
-```
-
-## 🎨 Personalização da Interface
-
-### Identificando o Agente
-Quando a resposta vem do Drummond com Maritaca AI:
-```javascript
-if (response.agent_name === 'Carlos Drummond de Andrade') {
-  // Mostra avatar do Drummond
-  // Adiciona estilo "poético mineiro"
-  // Confidence > 0.8 = Maritaca está respondendo
-}
-```
-
-### Sugestões de Ações
-Se `suggested_actions` estiver presente:
-```tsx
-{response.suggested_actions?.map(action => (
-  <button 
-    key={action} 
-    onClick={() => handleQuickAction(action)}
-    className="quick-action"
-  >
-    {getActionLabel(action)}
-  </button>
-))}
-```
-
-## 🚀 Próximos Passos
-
-1. **Implementar o serviço** seguindo os exemplos
-2. **Testar a conexão** com o endpoint de health
-3. **Adicionar o componente** de chat na interface
-4. **Personalizar** visual e comportamento
-5. **Monitorar** logs e métricas de uso
-
-## 📞 Suporte
-
-- **Documentação da API**: https://neural-thinker-cidadao-ai-backend.hf.space/docs
-- **Status do Serviço**: https://neural-thinker-cidadao-ai-backend.hf.space/health
-- **GitHub**: https://github.com/anderson-ufrj/cidadao.ai-backend
-
----
-
-*Drummond está ansioso para conversar com os cidadãos brasileiros sobre transparência pública! 🇧🇷*

FRONTEND_INTEGRATION.md

@@ -1,254 +0,0 @@
-# Integração Frontend - Cidadão.AI Chat com Maritaca AI
-
-## Status Atual ✅
-
-- **Backend**: Funcionando em https://neural-thinker-cidadao-ai-backend.hf.space
-- **Maritaca AI**: Configurada e pronta para uso
-- **Endpoints**: Disponíveis para integração
-
-## Endpoints Principais
-
-### 1. Chat Principal (com Drummond/Maritaca)
-```
-POST https://neural-thinker-cidadao-ai-backend.hf.space/api/v1/chat/message
-```
-
-**Request:**
-```json
-{
-  "message": "Olá, como posso investigar contratos públicos?",
-  "session_id": "opcional-uuid",
-  "context": {}
-}
-```
-
-**Response:**
-```json
-{
-  "session_id": "uuid",
-  "agent_id": "drummond",
-  "agent_name": "Carlos Drummond de Andrade",
-  "message": "Resposta do agente...",
-  "confidence": 0.8,
-  "suggested_actions": ["investigar_contratos", "ver_gastos"],
-  "metadata": {}
-}
-```
-
-### 2. Chat Simplificado (Novo - Mais Confiável)
-```
-POST https://neural-thinker-cidadao-ai-backend.hf.space/api/v1/chat/simple
-```
-
-**Request:**
-```json
-{
-  "message": "Sua mensagem aqui",
-  "session_id": "opcional"
-}
-```
-
-**Response:**
-```json
-{
-  "message": "Resposta da Maritaca AI ou fallback",
-  "session_id": "uuid",
-  "timestamp": "2025-09-20T19:45:00Z",
-  "model_used": "sabia-3" // ou "fallback"
-}
-```
-
-### 3. Status do Chat
-```
-GET https://neural-thinker-cidadao-ai-backend.hf.space/api/v1/chat/simple/status
-```
-
-**Response:**
-```json
-{
-  "maritaca_available": true,
-  "api_key_configured": true,
-  "timestamp": "2025-09-20T19:45:00Z"
-}
-```
-
-## Exemplo de Integração no Next.js
-
-```typescript
-// services/chatService.ts
-const BACKEND_URL = 'https://neural-thinker-cidadao-ai-backend.hf.space';
-
-export interface ChatMessage {
-  message: string;
-  session_id?: string;
-}
-
-export interface ChatResponse {
-  message: string;
-  session_id: string;
-  timestamp: string;
-  model_used: string;
-}
-
-export async function sendChatMessage(message: string, sessionId?: string): Promise<ChatResponse> {
-  try {
-    const response = await fetch(`${BACKEND_URL}/api/v1/chat/simple`, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-      },
-      body: JSON.stringify({
-        message,
-        session_id: sessionId
-      })
-    });
-
-    if (!response.ok) {
-      throw new Error(`HTTP error! status: ${response.status}`);
-    }
-
-    return await response.json();
-  } catch (error) {
-    console.error('Chat error:', error);
-    throw error;
-  }
-}
-
-// Verificar status do serviço
-export async function checkChatStatus() {
-  try {
-    const response = await fetch(`${BACKEND_URL}/api/v1/chat/simple/status`);
-    return await response.json();
-  } catch (error) {
-    console.error('Status check error:', error);
-    return { maritaca_available: false, api_key_configured: false };
-  }
-}
-```
-
-## Componente React Exemplo
-
-```tsx
-// components/Chat.tsx
-import { useState, useEffect } from 'react';
-import { sendChatMessage, checkChatStatus } from '../services/chatService';
-
-export function Chat() {
-  const [messages, setMessages] = useState<Array<{role: string, content: string}>>([]);
-  const [input, setInput] = useState('');
-  const [loading, setLoading] = useState(false);
-  const [sessionId, setSessionId] = useState<string>();
-  const [serviceStatus, setServiceStatus] = useState<any>();
-
-  useEffect(() => {
-    // Verificar status do serviço ao carregar
-    checkChatStatus().then(setServiceStatus);
-  }, []);
-
-  const handleSend = async () => {
-    if (!input.trim()) return;
-
-    // Adicionar mensagem do usuário
-    setMessages(prev => [...prev, { role: 'user', content: input }]);
-    setLoading(true);
-
-    try {
-      const response = await sendChatMessage(input, sessionId);
-      
-      // Salvar session ID para próximas mensagens
-      if (!sessionId) {
-        setSessionId(response.session_id);
-      }
-
-      // Adicionar resposta do bot
-      setMessages(prev => [...prev, { role: 'assistant', content: response.message }]);
-    } catch (error) {
-      setMessages(prev => [...prev, { 
-        role: 'assistant', 
-        content: 'Desculpe, ocorreu um erro. Por favor, tente novamente.' 
-      }]);
-    } finally {
-      setLoading(false);
-      setInput('');
-    }
-  };
-
-  return (
-    <div>
-      {serviceStatus && (
-        <div className="status">
-          Maritaca AI: {serviceStatus.maritaca_available ? '✅' : '❌'}
-        </div>
-      )}
-      
-      <div className="messages">
-        {messages.map((msg, idx) => (
-          <div key={idx} className={`message ${msg.role}`}>
-            {msg.content}
-          </div>
-        ))}
-      </div>
-
-      <div className="input-area">
-        <input
-          value={input}
-          onChange={(e) => setInput(e.target.value)}
-          onKeyPress={(e) => e.key === 'Enter' && handleSend()}
-          placeholder="Digite sua mensagem..."
-          disabled={loading}
-        />
-        <button onClick={handleSend} disabled={loading}>
-          {loading ? 'Enviando...' : 'Enviar'}
-        </button>
-      </div>
-    </div>
-  );
-}
-```
-
-## Sugestões de Mensagens para Testar
-
-1. **Saudações:**
-   - "Olá, como você pode me ajudar?"
-   - "Bom dia! O que é o Cidadão.AI?"
-
-2. **Investigações:**
-   - "Quero investigar contratos de saúde"
-   - "Como posso analisar gastos com educação?"
-   - "Mostre contratos do Ministério da Saúde"
-
-3. **Ajuda:**
-   - "Me ajude a entender o portal da transparência"
-   - "Quais tipos de dados posso consultar?"
-   - "Como funciona a detecção de anomalias?"
-
-## Tratamento de Erros
-
-O backend pode retornar diferentes tipos de respostas:
-
-1. **Sucesso com Maritaca AI**: `model_used: "sabia-3"`
-2. **Fallback (sem Maritaca)**: `model_used: "fallback"`
-3. **Erro 500**: Sistema temporariamente indisponível
-4. **Erro 422**: Dados de entrada inválidos
-
-## Notas Importantes
-
-1. **Session ID**: Mantenha o mesmo `session_id` para manter contexto da conversa
-2. **Rate Limiting**: O backend tem limite de requisições por minuto
-3. **Timeout**: Configure timeout de pelo menos 30 segundos para a Maritaca AI
-4. **CORS**: Já configurado para aceitar requisições do Vercel
-
-## Próximos Passos
-
-1. Aguardar alguns minutos para o deploy no HuggingFace Spaces
-2. Testar o endpoint `/api/v1/chat/simple` 
-3. Integrar no frontend Next.js
-4. Adicionar tratamento de erros e loading states
-5. Implementar persistência de sessão no localStorage
-
-## Suporte
-
-Em caso de problemas:
-1. Verifique o status em: `/api/v1/chat/simple/status`
-2. Consulte os logs do HuggingFace Spaces
-3. Use o endpoint fallback se a Maritaca estiver indisponível

FRONTEND_STABLE_INTEGRATION.md

@@ -1,235 +0,0 @@
-# 🚀 Integração Frontend Estável - Cidadão.AI
-
-## Solução para 100% de Disponibilidade
-
-### Problema Identificado
-- Drummond funcionando em apenas 30% das requisições
-- Falhas em perguntas complexas (~15% sucesso)
-- Instabilidade no backend afetando experiência do usuário
-
-### Solução Implementada
-
-Criamos um novo endpoint **ultra-estável** com múltiplas camadas de fallback:
-
-```
-POST /api/v1/chat/stable
-```
-
-### Características
-
-1. **3 Camadas de Fallback**:
-   - **Camada 1**: Maritaca AI (LLM brasileiro)
-   - **Camada 2**: Requisição HTTP direta para Maritaca
-   - **Camada 3**: Respostas inteligentes baseadas em regras
-
-2. **Garantia de Resposta**: 
-   - Sempre retorna uma resposta válida
-   - Tempo de resposta consistente
-   - Detecção de intent funciona sempre
-
-3. **Respostas Contextualizadas**:
-   - Diferentes respostas para cada tipo de intent
-   - Múltiplas variações para evitar repetição
-   - Foco em transparência pública
-
-## Implementação no Frontend
-
-### 1. Atualizar o Serviço de Chat
-
-```typescript
-// services/chatService.ts
-export class ChatService {
-  private readonly API_URL = process.env.NEXT_PUBLIC_API_URL || 'https://neural-thinker-cidadao-ai-backend.hf.space'
-  
-  async sendMessage(message: string, sessionId?: string): Promise<ChatResponse> {
-    try {
-      // Usar o novo endpoint estável
-      const response = await fetch(`${this.API_URL}/api/v1/chat/stable`, {
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json',
-        },
-        body: JSON.stringify({
-          message,
-          session_id: sessionId || `session_${Date.now()}`
-        })
-      })
-      
-      if (!response.ok) {
-        throw new Error(`HTTP error! status: ${response.status}`)
-      }
-      
-      return await response.json()
-    } catch (error) {
-      // Fallback local se API falhar
-      return {
-        session_id: sessionId || `session_${Date.now()}`,
-        agent_id: 'system',
-        agent_name: 'Sistema',
-        message: 'Desculpe, estou com dificuldades técnicas. Por favor, tente novamente.',
-        confidence: 0.0,
-        suggested_actions: ['retry'],
-        metadata: {
-          error: true,
-          local_fallback: true
-        }
-      }
-    }
-  }
-}
-```
-
-### 2. Componente de Chat Atualizado
-
-```tsx
-// components/Chat.tsx
-import { useState } from 'react'
-import { ChatService } from '@/services/chatService'
-
-export function Chat() {
-  const [messages, setMessages] = useState<Message[]>([])
-  const [isLoading, setIsLoading] = useState(false)
-  const chatService = new ChatService()
-  
-  const handleSendMessage = async (message: string) => {
-    // Adicionar mensagem do usuário
-    const userMessage = {
-      id: Date.now().toString(),
-      text: message,
-      sender: 'user',
-      timestamp: new Date()
-    }
-    setMessages(prev => [...prev, userMessage])
-    
-    setIsLoading(true)
-    
-    try {
-      const response = await chatService.sendMessage(message)
-      
-      // Adicionar resposta do assistente
-      const assistantMessage = {
-        id: (Date.now() + 1).toString(),
-        text: response.message,
-        sender: response.agent_name,
-        timestamp: new Date(),
-        metadata: {
-          confidence: response.confidence,
-          agent_id: response.agent_id,
-          backend_used: response.metadata?.agent_used || 'unknown'
-        }
-      }
-      
-      setMessages(prev => [...prev, assistantMessage])
-      
-      // Log para monitoramento
-      console.log('Chat metrics:', {
-        agent: response.agent_name,
-        confidence: response.confidence,
-        backend: response.metadata?.agent_used,
-        stable_version: response.metadata?.stable_version
-      })
-      
-    } catch (error) {
-      console.error('Chat error:', error)
-      // Erro já tratado no serviço
-    } finally {
-      setIsLoading(false)
-    }
-  }
-  
-  return (
-    <div className="chat-container">
-      {/* Renderizar mensagens */}
-      {/* Renderizar input */}
-      {/* Renderizar suggested actions */}
-    </div>
-  )
-}
-```
-
-### 3. Monitoramento de Performance
-
-```typescript
-// utils/chatMetrics.ts
-export class ChatMetrics {
-  private successCount = 0
-  private totalCount = 0
-  private backendStats = new Map<string, number>()
-  
-  recordResponse(response: ChatResponse) {
-    this.totalCount++
-    
-    if (response.confidence > 0) {
-      this.successCount++
-    }
-    
-    const backend = response.metadata?.agent_used || 'unknown'
-    this.backendStats.set(
-      backend, 
-      (this.backendStats.get(backend) || 0) + 1
-    )
-  }
-  
-  getStats() {
-    return {
-      successRate: (this.successCount / this.totalCount) * 100,
-      totalRequests: this.totalCount,
-      backendUsage: Object.fromEntries(this.backendStats),
-      timestamp: new Date()
-    }
-  }
-}
-```
-
-## Benefícios da Nova Solução
-
-1. **100% Disponibilidade**: Sempre retorna resposta válida
-2. **Tempo Consistente**: ~200-300ms para todas as requisições
-3. **Fallback Inteligente**: Respostas contextualizadas mesmo sem LLM
-4. **Transparente**: Frontend sabe qual backend foi usado
-5. **Métricas**: Fácil monitorar qual camada está sendo usada
-
-## Próximos Passos
-
-1. **Deploy Imediato**:
-   ```bash
-   git add .
-   git commit -m "feat: add ultra-stable chat endpoint with smart fallbacks"
-   git push origin main
-   git push huggingface main:main
-   ```
-
-2. **Frontend**:
-   - Atualizar para usar `/api/v1/chat/stable`
-   - Implementar métricas de monitoramento
-   - Testar todas as scenarios
-
-3. **Monitoramento**:
-   - Acompanhar taxa de uso de cada backend
-   - Ajustar fallbacks baseado em métricas
-   - Otimizar respostas mais comuns
-
-## Teste Rápido
-
-```bash
-# Testar localmente
-curl -X POST http://localhost:8000/api/v1/chat/stable \
-  -H "Content-Type: application/json" \
-  -d '{"message": "Olá, como você pode me ajudar?"}'
-
-# Testar em produção (após deploy)
-curl -X POST https://neural-thinker-cidadao-ai-backend.hf.space/api/v1/chat/stable \
-  -H "Content-Type: application/json" \
-  -d '{"message": "Investigue contratos suspeitos"}'
-```
-
-## Garantia
-
-Este endpoint garante:
-- ✅ Sempre retorna resposta válida
-- ✅ Nunca retorna erro 500
-- ✅ Tempo de resposta < 500ms
-- ✅ Respostas relevantes para transparência pública
-- ✅ Detecção de intent funcionando 100%
-
-Com esta solução, o frontend terá **100% de estabilidade** independente do status dos serviços de AI!

MARITACA_OPTIMIZATION_GUIDE.md

@@ -1,372 +0,0 @@
-# 🚀 Guia de Otimização Maritaca AI - Cidadão.AI
-
-## Resumo das Melhorias
-
-### 1. Novo Endpoint Otimizado
-- **URL**: `/api/v1/chat/optimized`
-- **Modelo**: Sabiazinho-3 (mais econômico)
-- **Persona**: Carlos Drummond de Andrade
-- **Economia**: ~40-50% menor custo por requisição
-
-### 2. Comparação de Modelos
-
-| Modelo | Custo | Qualidade | Tempo Resposta | Uso Recomendado |
-|--------|-------|-----------|----------------|-----------------|
-| Sabiazinho-3 | 💰 | ⭐⭐⭐⭐ | 1-5s | Conversas gerais, saudações |
-| Sabiá-3 | 💰💰💰 | ⭐⭐⭐⭐⭐ | 3-15s | Análises complexas |
-
-### 3. Endpoints Disponíveis
-
-```bash
-# 1. Simple (Sabiá-3) - FUNCIONANDO 100%
-POST /api/v1/chat/simple
-
-# 2. Stable (Multi-fallback) - NOVO
-POST /api/v1/chat/stable
-
-# 3. Optimized (Sabiazinho-3 + Drummond) - NOVO
-POST /api/v1/chat/optimized
-```
-
-## Integração Frontend - Versão Otimizada
-
-### Serviço de Chat Atualizado
-
-```typescript
-// services/chatService.ts
-export interface ChatEndpoint {
-  url: string;
-  name: string;
-  priority: number;
-  model: string;
-}
-
-export class ChatService {
-  private readonly API_URL = process.env.NEXT_PUBLIC_API_URL
-  
-  private endpoints: ChatEndpoint[] = [
-    {
-      url: '/api/v1/chat/optimized',
-      name: 'Optimized (Sabiazinho)',
-      priority: 1,
-      model: 'sabiazinho-3'
-    },
-    {
-      url: '/api/v1/chat/simple',
-      name: 'Simple (Sabiá-3)',
-      priority: 2,
-      model: 'sabia-3'
-    },
-    {
-      url: '/api/v1/chat/stable',
-      name: 'Stable (Fallback)',
-      priority: 3,
-      model: 'mixed'
-    }
-  ]
-  
-  async sendMessage(
-    message: string, 
-    options?: {
-      preferredModel?: 'economic' | 'quality';
-      useDrummond?: boolean;
-    }
-  ): Promise<ChatResponse> {
-    const sessionId = `session_${Date.now()}`
-    
-    // Select endpoint based on preference
-    let selectedEndpoints = [...this.endpoints]
-    
-    if (options?.preferredModel === 'economic') {
-      // Prioritize Sabiazinho
-      selectedEndpoints.sort((a, b) => 
-        a.model === 'sabiazinho-3' ? -1 : 1
-      )
-    } else if (options?.preferredModel === 'quality') {
-      // Prioritize Sabiá-3
-      selectedEndpoints.sort((a, b) => 
-        a.model === 'sabia-3' ? -1 : 1
-      )
-    }
-    
-    // Try endpoints in order
-    for (const endpoint of selectedEndpoints) {
-      try {
-        const body: any = { message, session_id: sessionId }
-        
-        // Add Drummond flag for optimized endpoint
-        if (endpoint.url.includes('optimized')) {
-          body.use_drummond = options?.useDrummond ?? true
-        }
-        
-        const response = await fetch(`${this.API_URL}${endpoint.url}`, {
-          method: 'POST',
-          headers: { 'Content-Type': 'application/json' },
-          body: JSON.stringify(body)
-        })
-        
-        if (response.ok) {
-          const data = await response.json()
-          console.log(`✅ Success with ${endpoint.name}`)
-          return data
-        }
-      } catch (error) {
-        console.warn(`Failed ${endpoint.name}:`, error)
-      }
-    }
-    
-    // Ultimate fallback
-    return {
-      message: 'Desculpe, estou temporariamente indisponível.',
-      session_id: sessionId,
-      agent_name: 'Sistema',
-      agent_id: 'system',
-      confidence: 0,
-      metadata: { fallback: true }
-    }
-  }
-  
-  // Analyze message to decide best model
-  analyzeComplexity(message: string): 'simple' | 'complex' {
-    const complexKeywords = [
-      'analise', 'investigue', 'compare', 'tendência',
-      'padrão', 'anomalia', 'detalhe', 'relatório'
-    ]
-    
-    const hasComplexKeyword = complexKeywords.some(
-      keyword => message.toLowerCase().includes(keyword)
-    )
-    
-    return hasComplexKeyword || message.length > 100 
-      ? 'complex' 
-      : 'simple'
-  }
-}
-```
-
-### Componente Inteligente
-
-```tsx
-// components/SmartChat.tsx
-export function SmartChat() {
-  const [messages, setMessages] = useState<Message[]>([])
-  const [modelPreference, setModelPreference] = useState<'auto' | 'economic' | 'quality'>('auto')
-  const chatService = new ChatService()
-  
-  const handleSendMessage = async (text: string) => {
-    // Add user message
-    const userMessage = createUserMessage(text)
-    setMessages(prev => [...prev, userMessage])
-    
-    // Analyze complexity for auto mode
-    let preference: 'economic' | 'quality' | undefined
-    
-    if (modelPreference === 'auto') {
-      const complexity = chatService.analyzeComplexity(text)
-      preference = complexity === 'simple' ? 'economic' : 'quality'
-    } else if (modelPreference !== 'auto') {
-      preference = modelPreference
-    }
-    
-    // Send with appropriate model
-    const response = await chatService.sendMessage(text, {
-      preferredModel: preference,
-      useDrummond: true // Enable cultural persona
-    })
-    
-    // Add response
-    const assistantMessage = {
-      ...createAssistantMessage(response),
-      metadata: {
-        ...response.metadata,
-        model_preference: preference,
-        actual_model: response.model_used
-      }
-    }
-    
-    setMessages(prev => [...prev, assistantMessage])
-    
-    // Log for monitoring
-    logChatMetrics({
-      model_used: response.model_used,
-      response_time: response.metadata?.response_time_ms,
-      tokens: response.metadata?.tokens_used,
-      success: true
-    })
-  }
-  
-  return (
-    <div className="smart-chat">
-      {/* Model preference selector */}
-      <div className="model-selector">
-        <label>Modo:</label>
-        <select 
-          value={modelPreference} 
-          onChange={(e) => setModelPreference(e.target.value as any)}
-        >
-          <option value="auto">Automático</option>
-          <option value="economic">Econômico (Sabiazinho)</option>
-          <option value="quality">Qualidade (Sabiá-3)</option>
-        </select>
-      </div>
-      
-      {/* Chat messages */}
-      <MessageList messages={messages} />
-      
-      {/* Input */}
-      <ChatInput onSend={handleSendMessage} />
-      
-      {/* Status indicator */}
-      <ChatStatus 
-        lastModel={messages[messages.length - 1]?.metadata?.actual_model}
-        preference={modelPreference}
-      />
-    </div>
-  )
-}
-```
-
-## Otimizações de Custo
-
-### 1. Cache Inteligente
-```typescript
-class CachedChatService extends ChatService {
-  private cache = new Map<string, CachedResponse>()
-  
-  async sendMessage(message: string, options?: any) {
-    // Check cache for common questions
-    const cacheKey = this.normalizeMessage(message)
-    const cached = this.cache.get(cacheKey)
-    
-    if (cached && !this.isExpired(cached)) {
-      return {
-        ...cached.response,
-        metadata: {
-          ...cached.response.metadata,
-          from_cache: true
-        }
-      }
-    }
-    
-    // Get fresh response
-    const response = await super.sendMessage(message, options)
-    
-    // Cache if successful
-    if (response.confidence > 0.8) {
-      this.cache.set(cacheKey, {
-        response,
-        timestamp: Date.now()
-      })
-    }
-    
-    return response
-  }
-}
-```
-
-### 2. Batching de Requisições
-```typescript
-class BatchedChatService extends ChatService {
-  private queue: QueuedMessage[] = []
-  private timer: NodeJS.Timeout | null = null
-  
-  async sendMessage(message: string, options?: any) {
-    return new Promise((resolve) => {
-      this.queue.push({ message, options, resolve })
-      
-      if (!this.timer) {
-        this.timer = setTimeout(() => this.processBatch(), 100)
-      }
-    })
-  }
-  
-  private async processBatch() {
-    const batch = this.queue.splice(0, 5) // Max 5 per batch
-    
-    // Send all at once (if API supports)
-    const responses = await this.sendBatch(batch)
-    
-    // Resolve individual promises
-    batch.forEach((item, index) => {
-      item.resolve(responses[index])
-    })
-    
-    this.timer = null
-  }
-}
-```
-
-## Métricas e Monitoramento
-
-```typescript
-// utils/chatMetrics.ts
-export class ChatMetricsCollector {
-  private metrics = {
-    totalRequests: 0,
-    modelUsage: new Map<string, number>(),
-    avgResponseTime: 0,
-    totalTokens: 0,
-    errorRate: 0,
-    cacheHitRate: 0
-  }
-  
-  recordMetric(data: ChatMetric) {
-    this.metrics.totalRequests++
-    
-    // Track model usage
-    const model = data.model_used || 'unknown'
-    this.metrics.modelUsage.set(
-      model,
-      (this.metrics.modelUsage.get(model) || 0) + 1
-    )
-    
-    // Update averages
-    this.updateAverages(data)
-    
-    // Send to analytics (optional)
-    if (window.gtag) {
-      window.gtag('event', 'chat_interaction', {
-        model_used: model,
-        response_time: data.response_time,
-        success: !data.error
-      })
-    }
-  }
-  
-  getCostEstimate(): number {
-    const sabiazinhoCost = 0.001 // per request
-    const sabia3Cost = 0.003 // per request
-    
-    const sabiazinhoCount = this.metrics.modelUsage.get('sabiazinho-3') || 0
-    const sabia3Count = this.metrics.modelUsage.get('sabia-3') || 0
-    
-    return (sabiazinhoCount * sabiazinhoCost) + (sabia3Count * sabia3Cost)
-  }
-  
-  getReport() {
-    return {
-      ...this.metrics,
-      estimatedCost: this.getCostEstimate(),
-      modelDistribution: Object.fromEntries(this.metrics.modelUsage)
-    }
-  }
-}
-```
-
-## Recomendações de Uso
-
-### Para o Frontend:
-1. **Perguntas Simples/Saudações**: Use Sabiazinho (economic mode)
-2. **Análises Complexas**: Use Sabiá-3 (quality mode)
-3. **Auto Mode**: Deixa o sistema decidir baseado na complexidade
-
-### Economia Estimada:
-- Conversas simples: 40-50% economia usando Sabiazinho
-- Mix típico (70% simples, 30% complexo): ~35% economia total
-- Com cache: Adicional 10-20% economia
-
-### Próximos Passos:
-1. Implementar cache para perguntas frequentes
-2. Adicionar análise de sentimento para ajustar tom
-3. Criar dashboards de custo em tempo real
-4. A/B testing entre modelos

app_simple.py

@@ -1,706 +0,0 @@
-#!/usr/bin/env python3
-"""
-Cidadão.AI Backend - Expanded Version with Multiple Data Sources
-Supports: Contracts, Servants, Expenses, Biddings, and more
-"""
-
-import asyncio
-import logging
-import os
-import sys
-import time
-import traceback
-import hashlib
-from contextlib import asynccontextmanager
-from typing import Any, Dict, List, Optional, Union
-from datetime import datetime, timedelta
-from enum import Enum
-
-import uvicorn
-from fastapi import FastAPI, HTTPException, status, Query
-from fastapi.middleware.cors import CORSMiddleware
-from fastapi.responses import JSONResponse
-from pydantic import BaseModel, Field
-from prometheus_client import Counter, Histogram, generate_latest, CONTENT_TYPE_LATEST
-
-# Configure logging
-logging.basicConfig(
-    level=logging.INFO,
-    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
-)
-logger = logging.getLogger(__name__)
-
-# ==================== DATA MODELS ====================
-
-class DataSourceType(str, Enum):
-    """Types of data sources available."""
-    CONTRACTS = "contratos"
-    SERVANTS = "servidores"
-    EXPENSES = "despesas"
-    BIDDINGS = "licitacoes"
-    AGREEMENTS = "convenios"
-    SANCTIONS = "empresas-sancionadas"
-
-class HealthResponse(BaseModel):
-    """Health check response model."""
-    status: str = "healthy"
-    version: str = "2.0.0"
-    agents: Dict[str, str] = Field(default_factory=lambda: {"zumbi": "active"})
-    data_sources: List[str] = Field(default_factory=lambda: [e.value for e in DataSourceType])
-    uptime: str = "operational"
-
-class UniversalSearchRequest(BaseModel):
-    """Universal search request for any data type."""
-    query: str = Field(..., description="Search query")
-    data_source: DataSourceType = Field(..., description="Type of data to search")
-    filters: Dict[str, Any] = Field(default_factory=dict, description="Additional filters")
-    max_results: int = Field(default=100, ge=1, le=500, description="Maximum results")
-    
-class ServantData(BaseModel):
-    """Servant/Employee data model."""
-    nome: str
-    cpf_masked: str
-    matricula: str
-    orgao: str
-    cargo: str
-    funcao: Optional[str] = None
-    remuneracao: Dict[str, float]
-    mes_ano_referencia: str
-
-class ContractData(BaseModel):
-    """Contract data model."""
-    id: str
-    numero: str
-    objeto: str
-    valor: float
-    fornecedor: Dict[str, str]
-    orgao: str
-    data_assinatura: str
-    vigencia: Dict[str, str]
-    modalidade: Optional[str] = None
-
-class ExpenseData(BaseModel):
-    """Expense data model."""
-    id: str
-    descricao: str
-    valor: float
-    favorecido: Dict[str, str]
-    orgao: str
-    data: str
-    programa: Optional[str] = None
-    acao: Optional[str] = None
-
-class UniversalSearchResponse(BaseModel):
-    """Universal search response."""
-    status: str
-    data_source: str
-    query: str
-    results: List[Union[ServantData, ContractData, ExpenseData, Dict[str, Any]]]
-    total_found: int
-    anomalies_detected: int
-    confidence_score: float
-    processing_time_ms: int
-    metadata: Dict[str, Any] = Field(default_factory=dict)
-
-# ==================== CACHE ====================
-
-class SimpleCache:
-    """In-memory cache for API responses with TTL."""
-    
-    def __init__(self):
-        self._cache: Dict[str, Dict] = {}
-        self._ttl_cache: Dict[str, datetime] = {}
-        self.default_ttl = 3600  # 1 hour
-    
-    def _generate_key(self, **kwargs) -> str:
-        """Generate cache key from parameters."""
-        key_string = "&".join([f"{k}={v}" for k, v in sorted(kwargs.items())])
-        return hashlib.md5(key_string.encode()).hexdigest()
-    
-    def get(self, **kwargs) -> Optional[Dict]:
-        """Get cached value if not expired."""
-        key = self._generate_key(**kwargs)
-        
-        if key not in self._cache:
-            return None
-        
-        if key in self._ttl_cache:
-            if datetime.now() > self._ttl_cache[key]:
-                del self._cache[key]
-                del self._ttl_cache[key]
-                return None
-        
-        return self._cache[key]
-    
-    def set(self, value: Dict, ttl_seconds: int = None, **kwargs) -> None:
-        """Set cached value with TTL."""
-        key = self._generate_key(**kwargs)
-        self._cache[key] = value
-        
-        ttl = ttl_seconds or self.default_ttl
-        self._ttl_cache[key] = datetime.now() + timedelta(seconds=ttl)
-
-# Global cache instance
-api_cache = SimpleCache()
-
-# ==================== ENHANCED ZUMBI AGENT ====================
-
-class EnhancedZumbiAgent:
-    """Enhanced Zumbi agent that can investigate multiple data sources."""
-    
-    def __init__(self):
-        self.name = "Zumbi dos Palmares"
-        self.role = "Universal Investigator"
-        self.specialty = "Multi-source anomaly detection"
-        logger.info(f"🏹 {self.name} - Enhanced {self.role} initialized")
-    
-    async def investigate_universal(self, request: UniversalSearchRequest) -> UniversalSearchResponse:
-        """Investigate any data source."""
-        import os
-        import numpy as np
-        from collections import defaultdict
-        start_time = time.time()
-        
-        try:
-            # Get API key
-            api_key = os.getenv("TRANSPARENCY_API_KEY")
-            if not api_key:
-                logger.warning("⚠️ No API key, using demo data")
-                return await self._get_demo_data(request, start_time)
-            
-            # Route to appropriate handler
-            if request.data_source == DataSourceType.SERVANTS:
-                return await self._search_servants(request, api_key, start_time)
-            elif request.data_source == DataSourceType.CONTRACTS:
-                return await self._search_contracts(request, api_key, start_time)
-            elif request.data_source == DataSourceType.EXPENSES:
-                return await self._search_expenses(request, api_key, start_time)
-            elif request.data_source == DataSourceType.BIDDINGS:
-                return await self._search_biddings(request, api_key, start_time)
-            else:
-                return await self._search_generic(request, api_key, start_time)
-                
-        except Exception as e:
-            logger.error(f"Investigation error: {str(e)}")
-            return UniversalSearchResponse(
-                status="error",
-                data_source=request.data_source.value,
-                query=request.query,
-                results=[],
-                total_found=0,
-                anomalies_detected=0,
-                confidence_score=0.0,
-                processing_time_ms=int((time.time() - start_time) * 1000),
-                metadata={"error": str(e)}
-            )
-    
-    async def _search_servants(self, request: UniversalSearchRequest, api_key: str, start_time: float) -> UniversalSearchResponse:
-        """Search for government servants."""
-        import httpx
-        
-        # Check cache first
-        cache_key = f"servants_{request.query}_{request.max_results}"
-        cached = api_cache.get(source=cache_key)
-        if cached:
-            logger.info("📦 Using cached servants data")
-            return cached
-        
-        results = []
-        anomalies = 0
-        
-        async with httpx.AsyncClient(timeout=30.0) as client:
-            url = "https://api.portaldatransparencia.gov.br/api-de-dados/servidores"
-            headers = {
-                "chave-api-dados": api_key,
-                "Accept": "application/json"
-            }
-            params = {
-                "nome": request.query.upper(),
-                "pagina": 1,
-                "tamanhoPagina": min(request.max_results, 50)
-            }
-            
-            # Add filters from request
-            if "orgao" in request.filters:
-                params["orgao"] = request.filters["orgao"]
-            if "funcao" in request.filters:
-                params["funcao"] = request.filters["funcao"]
-            
-            response = await client.get(url, headers=headers, params=params)
-            
-            if response.status_code == 200:
-                data = response.json()
-                
-                # Process servants
-                for item in data:
-                    servant_info = item.get("servidor", {})
-                    org_info = item.get("unidadeOrganizacional", {})
-                    
-                    # Extract salary info
-                    salary = item.get("remuneracaoBasicaBruta", 0)
-                    total = item.get("remuneracaoAposDeducoes", 0)
-                    
-                    # Detect anomalies (e.g., very high salaries)
-                    if salary > 40000:  # Above R$ 40k is unusual
-                        anomalies += 1
-                    
-                    servant = ServantData(
-                        nome=servant_info.get("nome", "N/A"),
-                        cpf_masked=servant_info.get("cpf", "***.***.***-**"),
-                        matricula=servant_info.get("matricula", "N/A"),
-                        orgao=org_info.get("nomeUnidade", "N/A"),
-                        cargo=item.get("cargo", {}).get("descricao", "N/A"),
-                        funcao=item.get("funcao", {}).get("descricao"),
-                        remuneracao={
-                            "basica": salary,
-                            "total_liquido": total,
-                            "gratificacoes": item.get("gratificacoes", 0),
-                            "auxilios": item.get("auxilios", 0)
-                        },
-                        mes_ano_referencia=f"{item.get('mesReferencia', 'N/A')}/{item.get('anoReferencia', 'N/A')}"
-                    )
-                    results.append(servant.dict())
-                
-                response_data = UniversalSearchResponse(
-                    status="success",
-                    data_source=request.data_source.value,
-                    query=request.query,
-                    results=results,
-                    total_found=len(results),
-                    anomalies_detected=anomalies,
-                    confidence_score=0.95,
-                    processing_time_ms=int((time.time() - start_time) * 1000),
-                    metadata={"source": "real_api", "anomaly_threshold": 40000}
-                )
-                
-                # Cache the response
-                api_cache.set(response_data.dict(), source=cache_key)
-                
-                return response_data
-            else:
-                raise HTTPException(status_code=response.status_code, detail="API request failed")
-    
-    async def _search_contracts(self, request: UniversalSearchRequest, api_key: str, start_time: float) -> UniversalSearchResponse:
-        """Search for contracts with anomaly detection."""
-        import httpx
-        import numpy as np
-        
-        results = []
-        anomalies = 0
-        
-        async with httpx.AsyncClient(timeout=30.0) as client:
-            # Search multiple organizations
-            org_codes = request.filters.get("orgaos", ["26000", "25000", "44000"])
-            
-            all_contracts = []
-            for org_code in org_codes[:3]:  # Limit to 3 orgs
-                url = "https://api.portaldatransparencia.gov.br/api-de-dados/contratos"
-                headers = {
-                    "chave-api-dados": api_key,
-                    "Accept": "application/json"
-                }
-                params = {
-                    "codigoOrgao": org_code,
-                    "ano": request.filters.get("ano", 2024),
-                    "tamanhoPagina": 50
-                }
-                
-                # Add search term if provided
-                if request.query and request.query.lower() != "todos":
-                    params["descricao"] = request.query
-                
-                response = await client.get(url, headers=headers, params=params)
-                
-                if response.status_code == 200:
-                    contracts = response.json()
-                    all_contracts.extend(contracts)
-            
-            # Analyze contracts for anomalies
-            if all_contracts:
-                values = [c.get("valorInicial", 0) for c in all_contracts if c.get("valorInicial", 0) > 0]
-                
-                if len(values) > 3:
-                    mean_val = np.mean(values)
-                    std_val = np.std(values)
-                    
-                    for contract in all_contracts[:request.max_results]:
-                        valor = contract.get("valorInicial", 0)
-                        z_score = abs((valor - mean_val) / std_val) if std_val > 0 else 0
-                        
-                        # Flag as anomaly if z-score > 1.5
-                        is_anomaly = z_score > 1.5
-                        if is_anomaly:
-                            anomalies += 1
-                        
-                        contract_data = {
-                            "id": contract.get("id", "N/A"),
-                            "numero": contract.get("numero", "N/A"),
-                            "objeto": contract.get("objeto", "N/A")[:200],
-                            "valor": valor,
-                            "fornecedor": {
-                                "nome": contract.get("nomeFornecedor", "N/A"),
-                                "cnpj": contract.get("cnpjFornecedor", "N/A")
-                            },
-                            "orgao": contract.get("nomeOrgao", org_code),
-                            "data_assinatura": contract.get("dataAssinatura", "N/A"),
-                            "vigencia": {
-                                "inicio": contract.get("dataInicioVigencia", "N/A"),
-                                "fim": contract.get("dataFimVigencia", "N/A")
-                            },
-                            "modalidade": contract.get("modalidadeCompra", "N/A"),
-                            "_anomaly": is_anomaly,
-                            "_z_score": z_score
-                        }
-                        results.append(contract_data)
-            
-            return UniversalSearchResponse(
-                status="success",
-                data_source=request.data_source.value,
-                query=request.query,
-                results=results,
-                total_found=len(results),
-                anomalies_detected=anomalies,
-                confidence_score=0.87,
-                processing_time_ms=int((time.time() - start_time) * 1000),
-                metadata={
-                    "organizations_searched": org_codes[:3],
-                    "anomaly_method": "z_score",
-                    "threshold": 1.5
-                }
-            )
-    
-    async def _search_expenses(self, request: UniversalSearchRequest, api_key: str, start_time: float) -> UniversalSearchResponse:
-        """Search for government expenses."""
-        import httpx
-        
-        results = []
-        anomalies = 0
-        
-        async with httpx.AsyncClient(timeout=30.0) as client:
-            url = "https://api.portaldatransparencia.gov.br/api-de-dados/despesas"
-            headers = {
-                "chave-api-dados": api_key,
-                "Accept": "application/json"
-            }
-            params = {
-                "ano": request.filters.get("ano", 2024),
-                "mes": request.filters.get("mes", 12),
-                "pagina": 1,
-                "tamanhoPagina": min(request.max_results, 50)
-            }
-            
-            if "orgao" in request.filters:
-                params["orgao"] = request.filters["orgao"]
-            
-            response = await client.get(url, headers=headers, params=params)
-            
-            if response.status_code == 200:
-                data = response.json()
-                
-                for expense in data:
-                    valor = expense.get("valor", 0)
-                    
-                    # Simple anomaly detection for high values
-                    if valor > 1000000:  # Above 1M
-                        anomalies += 1
-                    
-                    expense_data = ExpenseData(
-                        id=expense.get("id", "N/A"),
-                        descricao=expense.get("descricao", "N/A"),
-                        valor=valor,
-                        favorecido={
-                            "nome": expense.get("nomeFavorecido", "N/A"),
-                            "codigo": expense.get("codigoFavorecido", "N/A")
-                        },
-                        orgao=expense.get("nomeOrgao", "N/A"),
-                        data=expense.get("data", "N/A"),
-                        programa=expense.get("nomePrograma"),
-                        acao=expense.get("nomeAcao")
-                    )
-                    results.append(expense_data.dict())
-                
-                return UniversalSearchResponse(
-                    status="success",
-                    data_source=request.data_source.value,
-                    query=request.query,
-                    results=results,
-                    total_found=len(results),
-                    anomalies_detected=anomalies,
-                    confidence_score=0.85,
-                    processing_time_ms=int((time.time() - start_time) * 1000),
-                    metadata={"high_value_threshold": 1000000}
-                )
-            else:
-                raise HTTPException(status_code=response.status_code, detail="API request failed")
-    
-    async def _search_biddings(self, request: UniversalSearchRequest, api_key: str, start_time: float) -> UniversalSearchResponse:
-        """Search for biddings/licitações."""
-        # Implementation similar to contracts
-        # For brevity, returning a simplified response
-        return UniversalSearchResponse(
-            status="success",
-            data_source=request.data_source.value,
-            query=request.query,
-            results=[],
-            total_found=0,
-            anomalies_detected=0,
-            confidence_score=0.8,
-            processing_time_ms=int((time.time() - start_time) * 1000),
-            metadata={"note": "Biddings endpoint to be implemented"}
-        )
-    
-    async def _search_generic(self, request: UniversalSearchRequest, api_key: str, start_time: float) -> UniversalSearchResponse:
-        """Generic search for other data types."""
-        return UniversalSearchResponse(
-            status="success",
-            data_source=request.data_source.value,
-            query=request.query,
-            results=[],
-            total_found=0,
-            anomalies_detected=0,
-            confidence_score=0.7,
-            processing_time_ms=int((time.time() - start_time) * 1000),
-            metadata={"note": f"Generic handler for {request.data_source.value}"}
-        )
-    
-    async def _get_demo_data(self, request: UniversalSearchRequest, start_time: float) -> UniversalSearchResponse:
-        """Return demo data when no API key is available."""
-        demo_results = []
-        
-        if request.data_source == DataSourceType.SERVANTS:
-            demo_results = [{
-                "nome": "MARIA DA SILVA",
-                "cpf_masked": "***.***.***-**",
-                "matricula": "1234567",
-                "orgao": "MINISTERIO DA SAUDE",
-                "cargo": "ANALISTA",
-                "funcao": "ANALISTA TECNICO",
-                "remuneracao": {
-                    "basica": 8500.00,
-                    "total_liquido": 9876.54,
-                    "gratificacoes": 2000.00,
-                    "auxilios": 458.00
-                },
-                "mes_ano_referencia": "12/2024"
-            }]
-        elif request.data_source == DataSourceType.CONTRACTS:
-            demo_results = [{
-                "id": "demo-001",
-                "numero": "2024/001",
-                "objeto": "Contrato demonstrativo para testes",
-                "valor": 150000.00,
-                "fornecedor": {
-                    "nome": "EMPRESA DEMO LTDA",
-                    "cnpj": "00.000.000/0001-00"
-                },
-                "orgao": "ORGAO DEMONSTRATIVO",
-                "data_assinatura": "01/01/2024",
-                "vigencia": {
-                    "inicio": "01/01/2024",
-                    "fim": "31/12/2024"
-                },
-                "modalidade": "Pregão Eletrônico",
-                "_anomaly": False,
-                "_z_score": 0.5
-            }]
-        
-        return UniversalSearchResponse(
-            status="demo",
-            data_source=request.data_source.value,
-            query=request.query,
-            results=demo_results,
-            total_found=len(demo_results),
-            anomalies_detected=0,
-            confidence_score=0.5,
-            processing_time_ms=int((time.time() - start_time) * 1000),
-            metadata={"mode": "demo", "message": "Configure TRANSPARENCY_API_KEY for real data"}
-        )
-
-# ==================== FASTAPI APP ====================
-
-# Create agent instance
-enhanced_zumbi = EnhancedZumbiAgent()
-
-# Lifespan context manager
-@asynccontextmanager
-async def lifespan(app: FastAPI):
-    logger.info("🏛️ Cidadão.AI Enhanced Backend starting up...")
-    logger.info("🏹 Enhanced Zumbi agent ready for multi-source investigations")
-    yield
-    logger.info("👋 Cidadão.AI Enhanced Backend shutting down...")
-
-# Create FastAPI app
-app = FastAPI(
-    title="Cidadão.AI Enhanced Backend",
-    description="Multi-source government transparency analysis with AI",
-    version="2.0.0",
-    docs_url="/docs",
-    redoc_url="/redoc",
-    lifespan=lifespan
-)
-
-# Add CORS middleware
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
-# Add compression middleware for better performance
-from src.api.middleware.compression import add_compression_middleware
-add_compression_middleware(
-    app,
-    minimum_size=1024,  # Compress responses larger than 1KB
-    gzip_level=6,       # Good balance of speed vs compression
-    brotli_quality=4,   # Fast brotli compression
-    exclude_paths={"/health", "/metrics", "/health/metrics"}
-)
-
-# ==================== ENDPOINTS ====================
-
-@app.get("/", response_model=HealthResponse)
-async def root():
-    """Root endpoint with system status."""
-    return HealthResponse()
-
-@app.get("/health", response_model=HealthResponse)
-async def health_check():
-    """Health check endpoint."""
-    return HealthResponse()
-
-@app.post("/api/investigate", response_model=UniversalSearchResponse)
-async def investigate_universal(request: UniversalSearchRequest):
-    """
-    Universal investigation endpoint for any data source.
-    
-    Example queries:
-    - Servants: {"query": "João Silva", "data_source": "servidores"}
-    - Contracts: {"query": "informática", "data_source": "contratos"}
-    - Expenses: {"query": "todos", "data_source": "despesas", "filters": {"mes": 12}}
-    """
-    try:
-        result = await enhanced_zumbi.investigate_universal(request)
-        return result
-    except Exception as e:
-        logger.error(f"Investigation error: {str(e)}")
-        raise HTTPException(
-            status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-            detail=f"Investigation failed: {str(e)}"
-        )
-
-@app.get("/api/data-sources")
-async def list_data_sources():
-    """List all available data sources."""
-    return {
-        "sources": [
-            {
-                "id": ds.value,
-                "name": ds.name,
-                "description": {
-                    DataSourceType.CONTRACTS: "Government contracts and procurements",
-                    DataSourceType.SERVANTS: "Public servants and their salaries",
-                    DataSourceType.EXPENSES: "Government expenses and payments",
-                    DataSourceType.BIDDINGS: "Public biddings and auctions",
-                    DataSourceType.AGREEMENTS: "Government agreements and partnerships",
-                    DataSourceType.SANCTIONS: "Sanctioned companies"
-                }.get(ds, "Data source")
-            }
-            for ds in DataSourceType
-        ]
-    }
-
-@app.get("/api/search/servants")
-async def search_servants_quick(
-    nome: str = Query(..., description="Nome do servidor"),
-    orgao: Optional[str] = Query(None, description="Código do órgão"),
-    limit: int = Query(10, ge=1, le=50, description="Limite de resultados")
-):
-    """Quick endpoint to search servants by name."""
-    request = UniversalSearchRequest(
-        query=nome,
-        data_source=DataSourceType.SERVANTS,
-        filters={"orgao": orgao} if orgao else {},
-        max_results=limit
-    )
-    return await investigate_universal(request)
-
-@app.get("/api/search/contracts")
-async def search_contracts_quick(
-    query: str = Query("todos", description="Termo de busca"),
-    orgao: Optional[str] = Query(None, description="Código do órgão"),
-    ano: int = Query(2024, description="Ano"),
-    limit: int = Query(50, ge=1, le=100, description="Limite de resultados")
-):
-    """Quick endpoint to search contracts."""
-    request = UniversalSearchRequest(
-        query=query,
-        data_source=DataSourceType.CONTRACTS,
-        filters={"orgaos": [orgao] if orgao else ["26000", "25000"], "ano": ano},
-        max_results=limit
-    )
-    return await investigate_universal(request)
-
-@app.get("/api/cache/stats")
-async def cache_stats():
-    """Get cache statistics."""
-    return {
-        "cache_size": len(api_cache._cache),
-        "active_entries": len([k for k, v in api_cache._ttl_cache.items() if v > datetime.now()]),
-        "ttl_seconds": api_cache.default_ttl
-    }
-
-# Debug endpoint for Drummond issue
-@app.get("/debug/drummond-status")
-async def debug_drummond_status():
-    """Debug endpoint to check Drummond agent status."""
-    import traceback
-    
-    result = {
-        "python_version": sys.version,
-        "checks": {}
-    }
-    
-    # Check if we can import CommunicationAgent
-    try:
-        from src.agents.drummond import CommunicationAgent
-        abstract_methods = getattr(CommunicationAgent, '__abstractmethods__', set())
-        result["checks"]["import"] = {
-            "status": "success",
-            "abstract_methods": list(abstract_methods) if abstract_methods else "none",
-            "has_shutdown": hasattr(CommunicationAgent, 'shutdown'),
-            "has_initialize": hasattr(CommunicationAgent, 'initialize'),
-            "has_process": hasattr(CommunicationAgent, 'process')
-        }
-        
-        # Try to instantiate
-        try:
-            agent = CommunicationAgent()
-            result["checks"]["instantiation"] = {"status": "success", "agent_name": agent.name}
-        except Exception as e:
-            result["checks"]["instantiation"] = {
-                "status": "failed",
-                "error": str(e),
-                "error_type": type(e).__name__
-            }
-    except Exception as e:
-        result["checks"]["import"] = {
-            "status": "failed",
-            "error": str(e),
-            "traceback": traceback.format_exc()[:500]  # Limit traceback size
-        }
-    
-    return result
-
-if __name__ == "__main__":
-    port = int(os.getenv("PORT", 7860))
-    logger.info(f"🚀 Starting Enhanced Cidadão.AI Backend on port {port}")
-    # Disable host header validation for HuggingFace Spaces
-    uvicorn.run(
-        app, 
-        host="0.0.0.0", 
-        port=port,
-        forwarded_allow_ips="*",  # Allow all proxy IPs
-        proxy_headers=True  # Trust proxy headers
-    )

debug_drummond_import.py

@@ -1,97 +0,0 @@
-#!/usr/bin/env python3
-"""
-Debug script to trace Drummond import issues.
-"""
-
-import sys
-import traceback
-
-def test_import_chain():
-    """Test the import chain to find where the error occurs."""
-    
-    print("=== DRUMMOND IMPORT DEBUG ===")
-    print(f"Python version: {sys.version}")
-    print(f"Python path: {sys.path}")
-    print()
-    
-    # Test 1: Import BaseAgent
-    print("1. Testing BaseAgent import...")
-    try:
-        from src.agents.deodoro import BaseAgent
-        print("   ✓ BaseAgent imported successfully")
-        
-        # Check if shutdown is abstract
-        import inspect
-        methods = inspect.getmembers(BaseAgent, predicate=inspect.ismethod)
-        for name, method in methods:
-            if name == 'shutdown':
-                print(f"   - shutdown method found: {method}")
-                if hasattr(method, '__isabstractmethod__'):
-                    print(f"   - Is abstract: {method.__isabstractmethod__}")
-    except Exception as e:
-        print(f"   ✗ Failed to import BaseAgent: {e}")
-        traceback.print_exc()
-        return
-    
-    # Test 2: Import CommunicationAgent directly
-    print("\n2. Testing CommunicationAgent import...")
-    try:
-        from src.agents.drummond import CommunicationAgent
-        print("   ✓ CommunicationAgent imported successfully")
-        
-        # Check if shutdown is implemented
-        if hasattr(CommunicationAgent, 'shutdown'):
-            print("   ✓ shutdown method exists in CommunicationAgent")
-            
-            # Check method resolution order
-            print(f"   - MRO: {[c.__name__ for c in CommunicationAgent.__mro__]}")
-            
-            # Check abstract methods
-            abstract_methods = getattr(CommunicationAgent, '__abstractmethods__', set())
-            print(f"   - Abstract methods: {abstract_methods}")
-            
-    except Exception as e:
-        print(f"   ✗ Failed to import CommunicationAgent: {e}")
-        traceback.print_exc()
-        return
-    
-    # Test 3: Try to instantiate
-    print("\n3. Testing CommunicationAgent instantiation...")
-    try:
-        agent = CommunicationAgent()
-        print("   ✓ CommunicationAgent instantiated successfully")
-    except Exception as e:
-        print(f"   ✗ Failed to instantiate CommunicationAgent: {e}")
-        traceback.print_exc()
-        
-        # Additional diagnostics
-        print("\n   Additional diagnostics:")
-        try:
-            from src.agents.drummond import CommunicationAgent
-            print(f"   - Class type: {type(CommunicationAgent)}")
-            print(f"   - Base classes: {CommunicationAgent.__bases__}")
-            
-            # List all methods
-            print("   - All methods:")
-            for attr in dir(CommunicationAgent):
-                if not attr.startswith('_'):
-                    obj = getattr(CommunicationAgent, attr)
-                    if callable(obj):
-                        print(f"     * {attr}: {type(obj)}")
-                        
-        except Exception as e2:
-            print(f"   - Failed diagnostics: {e2}")
-    
-    # Test 4: Test the factory
-    print("\n4. Testing chat_drummond_factory...")
-    try:
-        from src.api.routes.chat_drummond_factory import get_drummond_agent
-        print("   ✓ Factory imported successfully")
-    except Exception as e:
-        print(f"   ✗ Failed to import factory: {e}")
-        traceback.print_exc()
-    
-    print("\n=== END DEBUG ===")
-
-if __name__ == "__main__":
-    test_import_chain()

debug_hf_error.py

@@ -1,34 +0,0 @@
-#!/usr/bin/env python3
-"""Debug script to understand the HuggingFace error"""
-
-print("=== Debugging HuggingFace Import Error ===\n")
-
-# Check if we can find where the error is really coming from
-import re
-
-log_line = '{"event": "Failed to initialize Drummond agent: Can\'t instantiate abstract class CommunicationAgent with abstract method shutdown", "logger": "src.api.routes.chat", "level": "error", "timestamp": "2025-09-20T16:17:42.475125Z", "filename": "chat.py", "func_name": "<module>", "lineno": 33}'
-
-print("Log says:")
-print(f"- File: chat.py")
-print(f"- Line: 33")
-print(f"- Function: <module> (module-level code)")
-print(f"- Error: Can't instantiate abstract class CommunicationAgent with abstract method shutdown")
-
-print("\nThis suggests that somewhere at the module level (not inside a function),")
-print("there's an attempt to instantiate CommunicationAgent directly.")
-print("\nBut line 33 is just a comment. Possible explanations:")
-print("1. Line numbers are off due to imports or preprocessing")
-print("2. There's a hidden try/except block wrapping an import")
-print("3. The error is actually from a different file that's imported")
-print("4. MasterAgent (line 35) might be trying to instantiate CommunicationAgent")
-
-print("\nLet's check if MasterAgent exists...")
-
-try:
-    from src.agents.abaporu import MasterAgent
-    print("✓ MasterAgent found in abaporu.py")
-except ImportError as e:
-    print(f"✗ MasterAgent not found: {e}")
-    print("  This would cause an error at line 35!")
-    
-print("\nThe real issue might be that MasterAgent is not imported in chat.py!")

src/api/routes/chat.py

@@ -27,6 +27,7 @@ class DataSourceType:
     CONTRACTS = "contratos"
     SERVANTS = "servidores"
     EXPENSES = "despesas"
+    BIDDINGS = "licitacoes"
 
 class UniversalSearchRequest(BaseModel):
     """Universal search request model."""

test_chat_detailed.py

@@ -1,103 +0,0 @@
-#!/usr/bin/env python3
-"""
-Detailed test for chat endpoints with exact response format
-"""
-
-import requests
-import json
-from datetime import datetime
-
-BASE_URL = "https://neural-thinker-cidadao-ai-backend.hf.space"
-
-def test_chat_message_detailed():
-    """Test main chat endpoint and print full response"""
-    print("\n🔍 Testing /api/v1/chat/message with full response...")
-    
-    payload = {
-        "message": "Olá, como você pode me ajudar?",
-        "session_id": f"test-{datetime.now().timestamp()}"
-    }
-    
-    try:
-        response = requests.post(
-            f"{BASE_URL}/api/v1/chat/message",
-            json=payload,
-            headers={"Content-Type": "application/json"}
-        )
-        
-        print(f"Status Code: {response.status_code}")
-        print(f"Headers: {dict(response.headers)}")
-        print("\nFull Response:")
-        print(json.dumps(response.json(), indent=2, ensure_ascii=False))
-        
-    except Exception as e:
-        print(f"Error: {e}")
-        print(f"Response Text: {response.text if 'response' in locals() else 'No response'}")
-
-def test_chat_simple_detailed():
-    """Test simple chat endpoint"""
-    print("\n🔍 Testing /api/v1/chat/simple...")
-    
-    payload = {
-        "message": "Olá, como você pode me ajudar?",
-        "session_id": f"test-{datetime.now().timestamp()}"
-    }
-    
-    try:
-        response = requests.post(
-            f"{BASE_URL}/api/v1/chat/simple",
-            json=payload,
-            headers={"Content-Type": "application/json"}
-        )
-        
-        print(f"Status Code: {response.status_code}")
-        
-        if response.status_code == 200:
-            print("\nFull Response:")
-            print(json.dumps(response.json(), indent=2, ensure_ascii=False))
-        else:
-            print(f"Response: {response.text}")
-            
-    except Exception as e:
-        print(f"Error: {e}")
-
-def test_available_endpoints():
-    """Check which endpoints are available"""
-    print("\n📋 Checking available endpoints...")
-    
-    endpoints = [
-        "/api/v1/chat/message",
-        "/api/v1/chat/simple",
-        "/api/v1/chat/agents",
-        "/api/v1/chat/suggestions",
-        "/api/v1/chat/stream",
-        "/docs",
-        "/openapi.json"
-    ]
-    
-    for endpoint in endpoints:
-        try:
-            if endpoint in ["/api/v1/chat/message", "/api/v1/chat/simple", "/api/v1/chat/stream"]:
-                # POST endpoints
-                response = requests.post(
-                    f"{BASE_URL}{endpoint}",
-                    json={"message": "test", "session_id": "test"},
-                    timeout=5
-                )
-            else:
-                # GET endpoints
-                response = requests.get(f"{BASE_URL}{endpoint}", timeout=5)
-            
-            print(f"{endpoint}: {response.status_code} {'✅' if response.status_code != 404 else '❌'}")
-        except Exception as e:
-            print(f"{endpoint}: Error - {str(e)[:50]}")
-
-if __name__ == "__main__":
-    print("=" * 60)
-    print("🔬 Detailed Chat Endpoint Test")
-    print(f"🌐 URL: {BASE_URL}")
-    print("=" * 60)
-    
-    test_available_endpoints()
-    test_chat_message_detailed()
-    test_chat_simple_detailed()

test_chat_simple.py

@@ -1,99 +0,0 @@
-#!/usr/bin/env python3
-"""
-Teste do endpoint simples de chat com Maritaca AI
-"""
-
-import requests
-import json
-from datetime import datetime
-import time
-
-# URL do backend no HuggingFace Spaces
-BASE_URL = "https://neural-thinker-cidadao-ai-backend.hf.space"
-
-def test_chat_simple():
-    """Testa o novo endpoint simples de chat"""
-    endpoint = f"{BASE_URL}/api/v1/chat/simple"
-    
-    print("🧪 Testando endpoint /api/v1/chat/simple")
-    print("="*50)
-    
-    # Primeiro, verifica o status
-    status_endpoint = f"{BASE_URL}/api/v1/chat/simple/status"
-    try:
-        response = requests.get(status_endpoint)
-        if response.status_code == 200:
-            status = response.json()
-            print(f"📊 Status do Chat:")
-            print(f"   Maritaca disponível: {status.get('maritaca_available', False)}")
-            print(f"   API Key configurada: {status.get('api_key_configured', False)}")
-            print()
-    except Exception as e:
-        print(f"❌ Erro ao verificar status: {e}")
-    
-    # Mensagens de teste
-    test_messages = [
-        "Olá, como você está?",
-        "O que é o Cidadão.AI?",
-        "Como posso investigar contratos públicos?",
-        "Me ajuda a entender o portal da transparência",
-        "Quero analisar gastos com saúde em 2024"
-    ]
-    
-    headers = {
-        "Content-Type": "application/json",
-        "Accept": "application/json"
-    }
-    
-    session_id = f"test-session-{int(time.time())}"
-    
-    for i, message in enumerate(test_messages, 1):
-        print(f"\n💬 Teste {i}: {message}")
-        
-        payload = {
-            "message": message,
-            "session_id": session_id
-        }
-        
-        try:
-            start_time = time.time()
-            response = requests.post(
-                endpoint,
-                json=payload,
-                headers=headers,
-                timeout=30
-            )
-            elapsed = time.time() - start_time
-            
-            print(f"   ⏱️ Tempo de resposta: {elapsed:.2f}s")
-            print(f"   📡 Status HTTP: {response.status_code}")
-            
-            if response.status_code == 200:
-                data = response.json()
-                print(f"   ✅ Resposta recebida!")
-                print(f"   🤖 Modelo usado: {data.get('model_used', 'N/A')}")
-                print(f"   💬 Resposta: {data.get('message', '')[:150]}...")
-                
-                # Verifica se está usando Maritaca
-                if data.get('model_used') != 'fallback':
-                    print(f"   🎉 Usando Maritaca AI! Modelo: {data.get('model_used')}")
-            else:
-                print(f"   ❌ Erro: {response.text[:200]}")
-                
-        except requests.exceptions.Timeout:
-            print(f"   ⏱️ Timeout - demorou mais de 30 segundos")
-        except Exception as e:
-            print(f"   ❌ Erro: {e}")
-        
-        # Pequena pausa entre requisições
-        if i < len(test_messages):
-            time.sleep(1)
-    
-    print("\n" + "="*50)
-    print("✅ Teste concluído!")
-    print(f"\n💡 Dica: Para usar no frontend, faça requisições POST para:")
-    print(f"   {endpoint}")
-    print(f"   Com body: {{\"message\": \"sua mensagem\", \"session_id\": \"opcional\"}}")
-
-if __name__ == "__main__":
-    test_chat_simple()

test_drummond_import.py

@@ -1,42 +0,0 @@
-#!/usr/bin/env python3
-"""Test Drummond import to debug the issue."""
-
-import inspect
-
-# Test direct import
-try:
-    from src.agents.drummond import CommunicationAgent
-    print("✅ Import successful!")
-    
-    # Check abstract methods
-    abstract_methods = getattr(CommunicationAgent, '__abstractmethods__', set())
-    print(f"Abstract methods: {abstract_methods}")
-    
-    # Check if shutdown is implemented
-    if hasattr(CommunicationAgent, 'shutdown'):
-        print("✅ shutdown method exists")
-        shutdown_method = getattr(CommunicationAgent, 'shutdown')
-        print(f"   Is coroutine: {inspect.iscoroutinefunction(shutdown_method)}")
-    else:
-        print("❌ shutdown method NOT FOUND")
-        
-    # Check all methods
-    all_methods = [m for m in dir(CommunicationAgent) if not m.startswith('_')]
-    print(f"\nAll public methods: {all_methods}")
-    
-except Exception as e:
-    print(f"❌ Import failed: {type(e).__name__}: {e}")
-    
-    # Try simpler import
-    try:
-        import sys
-        import os
-        sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
-        from src.agents.deodoro import BaseAgent
-        print("\n✅ BaseAgent imported successfully")
-        
-        # Check BaseAgent abstract methods
-        abstract_base = getattr(BaseAgent, '__abstractmethods__', set())
-        print(f"BaseAgent abstract methods: {abstract_base}")
-    except Exception as e2:
-        print(f"❌ BaseAgent import also failed: {e2}")

test_drummond_init.py

@@ -1,30 +0,0 @@
-#!/usr/bin/env python3
-"""Test Drummond initialization locally"""
-import os
-import sys
-
-# Add the src directory to the path
-sys.path.insert(0, os.path.join(os.path.dirname(__file__), 'src'))
-
-# Set necessary environment variables for testing
-os.environ["GROQ_API_KEY"] = "dummy_key_for_test"
-os.environ["JWT_SECRET_KEY"] = "test_secret"
-os.environ["SECRET_KEY"] = "test_secret"
-
-try:
-    print("Testing Drummond agent initialization...")
-    from src.agents.drummond import CommunicationAgent
-    
-    # Try to create agent
-    print("Creating CommunicationAgent...")
-    agent = CommunicationAgent()
-    print("✓ Agent created successfully!")
-    
-    # Check if it has the necessary methods
-    print(f"Has process method: {hasattr(agent, 'process')}")
-    print(f"Has shutdown method: {hasattr(agent, 'shutdown')}")
-    
-except Exception as e:
-    print(f"✗ Error creating agent: {e}")
-    import traceback
-    traceback.print_exc()

test_drummond_live.py

@@ -1,46 +0,0 @@
-#!/usr/bin/env python3
-"""Test Drummond agent on live HuggingFace deployment"""
-import requests
-import json
-
-# Test the chat endpoint with a greeting
-url = "https://neural-thinker-cidadao-ai-backend.hf.space/api/v1/chat/message"
-headers = {"Content-Type": "application/json"}
-
-# Test 1: Simple greeting (should route to Drummond)
-print("Test 1: Testing greeting message...")
-data = {"message": "Olá, pode me ajudar?"}
-try:
-    response = requests.post(url, json=data, headers=headers)
-    print(f"Status: {response.status_code}")
-    print(f"Response: {json.dumps(response.json(), indent=2, ensure_ascii=False)}")
-except Exception as e:
-    print(f"Error: {e}")
-    if hasattr(response, 'text'):
-        print(f"Raw response: {response.text}")
-
-print("\n" + "="*50 + "\n")
-
-# Test 2: Literary analysis request
-print("Test 2: Testing literary analysis...")
-data = {"message": "Analise o poema 'No meio do caminho tinha uma pedra' de Drummond"}
-try:
-    response = requests.post(url, json=data, headers=headers)
-    print(f"Status: {response.status_code}")
-    print(f"Response: {json.dumps(response.json(), indent=2, ensure_ascii=False)}")
-except Exception as e:
-    print(f"Error: {e}")
-    if hasattr(response, 'text'):
-        print(f"Raw response: {response.text}")
-
-print("\n" + "="*50 + "\n")
-
-# Test 3: Check health endpoint
-print("Test 3: Checking health endpoint...")
-health_url = "https://neural-thinker-cidadao-ai-backend.hf.space/health"
-try:
-    response = requests.get(health_url)
-    print(f"Status: {response.status_code}")
-    print(f"Response: {json.dumps(response.json(), indent=2)}")
-except Exception as e:
-    print(f"Error: {e}")

test_drummond_minimal.py

@@ -1,60 +0,0 @@
-#!/usr/bin/env python3
-"""
-Minimal test to verify CommunicationAgent can be imported and instantiated.
-This simulates what happens on HuggingFace Spaces.
-"""
-
-import sys
-import os
-
-# Add src to path like HuggingFace does
-sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
-
-def test_minimal_import():
-    print("=== MINIMAL DRUMMOND TEST ===")
-    
-    # Step 1: Try importing just the class
-    try:
-        print("1. Importing CommunicationAgent class...")
-        from src.agents.drummond import CommunicationAgent
-        print("   ✓ Import successful")
-    except Exception as e:
-        print(f"   ✗ Import failed: {e}")
-        import traceback
-        traceback.print_exc()
-        return False
-    
-    # Step 2: Check if it's a proper class
-    print("\n2. Checking class structure...")
-    print(f"   - Type: {type(CommunicationAgent)}")
-    print(f"   - Base classes: {CommunicationAgent.__bases__}")
-    print(f"   - Module: {CommunicationAgent.__module__}")
-    
-    # Check abstract methods
-    abstract_methods = getattr(CommunicationAgent, '__abstractmethods__', None)
-    if abstract_methods:
-        print(f"   - Abstract methods remaining: {abstract_methods}")
-    else:
-        print("   - No abstract methods remaining")
-    
-    # Step 3: Try instantiation without any dependencies
-    print("\n3. Testing instantiation...")
-    try:
-        # Mock the logger to avoid dependency issues
-        import logging
-        logging.basicConfig(level=logging.INFO)
-        
-        # Try to create instance
-        agent = CommunicationAgent()
-        print("   ✓ Instantiation successful")
-        return True
-    except Exception as e:
-        print(f"   ✗ Instantiation failed: {e}")
-        import traceback
-        traceback.print_exc()
-        return False
-
-if __name__ == "__main__":
-    success = test_minimal_import()
-    print(f"\n=== TEST {'PASSED' if success else 'FAILED'} ===")
-    sys.exit(0 if success else 1)

test_hf_chat.py

@@ -1,152 +0,0 @@
-#!/usr/bin/env python3
-"""
-Test script for HuggingFace Spaces chat endpoints
-Tests both main and simple chat endpoints with Maritaca AI
-"""
-
-import requests
-import json
-from datetime import datetime
-
-# HuggingFace Spaces URL
-BASE_URL = "https://neural-thinker-cidadao-ai-backend.hf.space"
-
-def test_health():
-    """Test if API is running"""
-    print("\n1️⃣ Testing API Health...")
-    try:
-        response = requests.get(f"{BASE_URL}/")
-        print(f"✅ API Status: {response.status_code}")
-        print(f"Response: {response.json()}")
-        return True
-    except Exception as e:
-        print(f"❌ Health check failed: {e}")
-        return False
-
-def test_docs():
-    """Test if API docs are accessible"""
-    print("\n2️⃣ Testing API Documentation...")
-    try:
-        response = requests.get(f"{BASE_URL}/docs")
-        print(f"✅ Docs Status: {response.status_code}")
-        return True
-    except Exception as e:
-        print(f"❌ Docs check failed: {e}")
-        return False
-
-def test_simple_chat():
-    """Test simple chat endpoint with Maritaca AI"""
-    print("\n3️⃣ Testing Simple Chat Endpoint (Maritaca AI direct)...")
-    
-    test_messages = [
-        "Olá, como você pode me ajudar?",
-        "Quais são os gastos públicos mais recentes?",
-        "Me explique sobre transparência governamental"
-    ]
-    
-    for message in test_messages:
-        print(f"\n📤 Sending: {message}")
-        try:
-            response = requests.post(
-                f"{BASE_URL}/api/v1/chat/simple",
-                json={
-                    "message": message,
-                    "session_id": f"test-session-{datetime.now().timestamp()}"
-                },
-                headers={"Content-Type": "application/json"}
-            )
-            
-            if response.status_code == 200:
-                data = response.json()
-                print(f"✅ Response Status: {response.status_code}")
-                print(f"📥 Assistant: {data['response'][:200]}...")
-                print(f"🤖 Agent Used: {data.get('agent_used', 'Unknown')}")
-            else:
-                print(f"⚠️ Status: {response.status_code}")
-                print(f"Response: {response.text}")
-                
-        except Exception as e:
-            print(f"❌ Error: {e}")
-
-def test_main_chat():
-    """Test main chat endpoint with full agent system"""
-    print("\n4️⃣ Testing Main Chat Endpoint (Full Agent System)...")
-    
-    test_messages = [
-        {"message": "Oi, tudo bem?", "expected_agent": "Drummond"},
-        {"message": "Investigue contratos suspeitos em São Paulo", "expected_agent": "Abaporu/Zumbi"},
-        {"message": "Análise de gastos com educação", "expected_agent": "Abaporu"}
-    ]
-    
-    for test in test_messages:
-        print(f"\n📤 Sending: {test['message']}")
-        print(f"🎯 Expected Agent: {test['expected_agent']}")
-        
-        try:
-            response = requests.post(
-                f"{BASE_URL}/api/v1/chat/message",
-                json={
-                    "message": test["message"],
-                    "session_id": f"test-session-{datetime.now().timestamp()}"
-                },
-                headers={"Content-Type": "application/json"}
-            )
-            
-            if response.status_code == 200:
-                data = response.json()
-                print(f"✅ Response Status: {response.status_code}")
-                print(f"📥 Response: {data['response'][:200]}...")
-                print(f"🤖 Agent: {data.get('agent_name', 'Unknown')}")
-                print(f"💬 Type: {data.get('response_type', 'Unknown')}")
-            else:
-                print(f"⚠️ Status: {response.status_code}")
-                print(f"Response: {response.text}")
-                
-        except Exception as e:
-            print(f"❌ Error: {e}")
-
-def test_chat_suggestions():
-    """Test chat suggestions endpoint"""
-    print("\n5️⃣ Testing Chat Suggestions...")
-    try:
-        response = requests.get(
-            f"{BASE_URL}/api/v1/chat/suggestions",
-            params={"limit": 5}
-        )
-        
-        if response.status_code == 200:
-            suggestions = response.json()
-            print(f"✅ Found {len(suggestions)} suggestions:")
-            for idx, suggestion in enumerate(suggestions[:3], 1):
-                print(f"  {idx}. {suggestion['text']}")
-        else:
-            print(f"⚠️ Status: {response.status_code}")
-            
-    except Exception as e:
-        print(f"❌ Error: {e}")
-
-def main():
-    """Run all tests"""
-    print("🚀 Testing Cidadão.AI Backend on HuggingFace Spaces")
-    print("=" * 60)
-    print(f"🌐 Base URL: {BASE_URL}")
-    print(f"🕐 Test Time: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
-    print("=" * 60)
-    
-    # Run tests
-    if test_health():
-        test_docs()
-        test_simple_chat()
-        test_main_chat()
-        test_chat_suggestions()
-    
-    print("\n" + "=" * 60)
-    print("✅ Tests completed!")
-    print("\n💡 Integration Tips for Frontend:")
-    print("1. Use /api/v1/chat/simple for reliable Maritaca AI responses")
-    print("2. Use /api/v1/chat/message for full agent capabilities")
-    print("3. Handle both 200 (success) and 500 (fallback) responses")
-    print("4. Check the 'agent_used' field to know which agent responded")
-
-if __name__ == "__main__":
-    main()

test_hf_spaces.py

@@ -1,74 +0,0 @@
-#!/usr/bin/env python3
-"""
-🔍 Teste de HuggingFace Spaces
-Verifica se os Spaces estão rodando e quais endpoints respondem
-"""
-
-import asyncio
-import httpx
-
-async def test_hf_spaces():
-    """🔍 Testa diferentes endpoints dos HF Spaces"""
-    print("🔍 VERIFICANDO HUGGINGFACE SPACES")
-    print("=" * 50)
-    
-    # URLs para testar
-    backend_urls = [
-        "https://neural-thinker-cidadao-ai-backend.hf.space",
-        "https://neural-thinker-cidadao-ai-backend.hf.space/",
-        "https://neural-thinker-cidadao-ai-backend.hf.space/health",
-        "https://neural-thinker-cidadao-ai-backend.hf.space/docs",
-        "https://huggingface.co/spaces/neural-thinker/cidadao.ai-backend"
-    ]
-    
-    models_urls = [
-        "https://neural-thinker-cidadao-ai-models.hf.space",
-        "https://neural-thinker-cidadao-ai-models.hf.space/",
-        "https://neural-thinker-cidadao-ai-models.hf.space/health",
-        "https://huggingface.co/spaces/neural-thinker/cidadao.ai-models"
-    ]
-    
-    async with httpx.AsyncClient(timeout=10.0) as client:
-        
-        print("🏛️ TESTANDO BACKEND SPACES:")
-        for url in backend_urls:
-            try:
-                response = await client.get(url)
-                status = "✅" if response.status_code == 200 else f"❌ {response.status_code}"
-                print(f"   {status} {url}")
-                
-                if response.status_code == 200 and 'application/json' in response.headers.get('content-type', ''):
-                    try:
-                        data = response.json()
-                        if 'status' in data:
-                            print(f"       📊 Status: {data.get('status')}")
-                        if 'agents' in data:
-                            print(f"       🤖 Agentes: {list(data.get('agents', {}).keys())}")
-                    except:
-                        print(f"       📝 HTML response (não JSON)")
-                        
-            except Exception as e:
-                print(f"   ❌ {url} - Erro: {str(e)[:50]}...")
-        
-        print("\n🤖 TESTANDO MODELS SPACES:")
-        for url in models_urls:
-            try:
-                response = await client.get(url)
-                status = "✅" if response.status_code == 200 else f"❌ {response.status_code}"
-                print(f"   {status} {url}")
-                
-                if response.status_code == 200 and 'application/json' in response.headers.get('content-type', ''):
-                    try:
-                        data = response.json()
-                        if 'api' in data:
-                            print(f"       📊 API: {data.get('api')}")
-                        if 'version' in data:
-                            print(f"       🔢 Version: {data.get('version')}")
-                    except:
-                        print(f"       📝 HTML response (não JSON)")
-                        
-            except Exception as e:
-                print(f"   ❌ {url} - Erro: {str(e)[:50]}...")
-
-if __name__ == "__main__":
-    asyncio.run(test_hf_spaces())

test_maritaca_integration.py

@@ -1,118 +0,0 @@
-#!/usr/bin/env python3
-"""
-Script para testar a integração Maritaca AI no Cidadão.AI
-"""
-
-import requests
-import json
-from datetime import datetime
-
-# URL do backend no HuggingFace Spaces
-BASE_URL = "https://neural-thinker-cidadao-ai-backend.hf.space"
-
-def test_health():
-    """Testa se a API está online"""
-    try:
-        response = requests.get(f"{BASE_URL}/health")
-        print(f"✅ Health Check: {response.status_code}")
-        if response.status_code == 200:
-            print(f"   Response: {response.json()}")
-        return response.status_code == 200
-    except Exception as e:
-        print(f"❌ Health Check Error: {e}")
-        return False
-
-def test_chat_endpoint():
-    """Testa o endpoint de chat com a Maritaca AI"""
-    endpoint = f"{BASE_URL}/api/v1/chat/message"
-    
-    # Mensagens de teste
-    test_messages = [
-        {
-            "message": "Olá, tudo bem?",
-            "expected_agent": "drummond"
-        },
-        {
-            "message": "Quero investigar contratos de saúde em São Paulo",
-            "expected_agent": "abaporu"
-        },
-        {
-            "message": "Me explique como funciona o portal da transparência",
-            "expected_agent": "drummond"
-        }
-    ]
-    
-    headers = {
-        "Content-Type": "application/json",
-        "Accept": "application/json"
-    }
-    
-    for test in test_messages:
-        print(f"\n📤 Testando: '{test['message']}'")
-        print(f"   Agente esperado: {test['expected_agent']}")
-        
-        payload = {
-            "message": test["message"],
-            "session_id": f"test-{datetime.now().timestamp()}"
-        }
-        
-        try:
-            response = requests.post(
-                endpoint,
-                json=payload,
-                headers=headers,
-                timeout=30
-            )
-            
-            print(f"   Status: {response.status_code}")
-            
-            if response.status_code == 200:
-                data = response.json()
-                print(f"   ✅ Resposta recebida!")
-                print(f"   Agente: {data.get('agent_name', 'N/A')}")
-                print(f"   Mensagem: {data.get('message', 'N/A')[:100]}...")
-                print(f"   Confiança: {data.get('confidence', 'N/A')}")
-                
-                # Verifica se está usando Maritaca
-                if "drummond" in data.get('agent_id', '').lower():
-                    print(f"   🤖 Drummond ativado (deve estar usando Maritaca AI)")
-                
-            elif response.status_code == 422:
-                print(f"   ❌ Erro de validação: {response.json()}")
-            else:
-                print(f"   ❌ Erro: {response.text[:200]}")
-                
-        except requests.exceptions.Timeout:
-            print(f"   ⏱️ Timeout - a requisição demorou mais de 30 segundos")
-        except Exception as e:
-            print(f"   ❌ Erro na requisição: {e}")
-
-def test_api_docs():
-    """Verifica se a documentação da API está acessível"""
-    try:
-        response = requests.get(f"{BASE_URL}/docs")
-        print(f"\n📚 API Docs: {response.status_code}")
-        if response.status_code == 200:
-            print(f"   ✅ Documentação disponível em: {BASE_URL}/docs")
-        return response.status_code == 200
-    except Exception as e:
-        print(f"❌ API Docs Error: {e}")
-        return False
-
-if __name__ == "__main__":
-    print("🧪 Testando integração Maritaca AI no Cidadão.AI")
-    print(f"🌐 Backend URL: {BASE_URL}")
-    print("="*50)
-    
-    # Testa health check
-    if test_health():
-        # Testa documentação
-        test_api_docs()
-        
-        # Testa endpoint de chat
-        test_chat_endpoint()
-    else:
-        print("\n❌ API não está respondendo. Verifique se o HuggingFace Spaces está online.")
-    
-    print("\n"+"="*50)
-    print("✅ Testes concluídos!")

test_models_communication.py

@@ -1,235 +0,0 @@
-#!/usr/bin/env python3
-"""
-🧪 Teste de Comunicação Backend ↔ Models
-Verifica se os repositórios estão conversando via API
-"""
-
-import asyncio
-import sys
-import os
-import httpx
-import json
-from datetime import datetime
-
-# Add src to path
-sys.path.insert(0, os.path.join(os.path.dirname(__file__), 'src'))
-
-from src.tools.models_client import ModelsClient
-from src.core.config import Settings
-
-# Test configuration
-MODELS_API_URL = "https://neural-thinker-cidadao-ai-models.hf.space"
-BACKEND_API_URL = "https://neural-thinker-cidadao-ai-backend.hf.space"
-
-async def test_models_api_direct():
-    """🔍 TESTE 1: Acesso direto à API de Modelos"""
-    print("=" * 60)
-    print("🔍 TESTE 1: MODELS API - ACESSO DIRETO")
-    print("=" * 60)
-    
-    try:
-        async with httpx.AsyncClient(timeout=30.0) as client:
-            # Test root endpoint
-            print(f"📡 Testando: {MODELS_API_URL}")
-            response = await client.get(f"{MODELS_API_URL}/")
-            
-            if response.status_code == 200:
-                data = response.json()
-                print("✅ Models API está ONLINE!")
-                print(f"   📊 API: {data.get('api', 'N/A')}")
-                print(f"   🔢 Versão: {data.get('version', 'N/A')}")
-                print(f"   📋 Status: {data.get('status', 'N/A')}")
-                print(f"   🔗 Endpoints: {list(data.get('endpoints', {}).keys())}")
-                return True
-            else:
-                print(f"❌ Models API retornou status: {response.status_code}")
-                return False
-                
-    except Exception as e:
-        print(f"❌ Erro ao conectar Models API: {str(e)}")
-        return False
-
-async def test_models_health():
-    """🏥 TESTE 2: Health check da API de Modelos"""
-    print("\n" + "=" * 60)
-    print("🏥 TESTE 2: MODELS API - HEALTH CHECK")
-    print("=" * 60)
-    
-    try:
-        async with httpx.AsyncClient(timeout=30.0) as client:
-            response = await client.get(f"{MODELS_API_URL}/health")
-            
-            if response.status_code == 200:
-                data = response.json()
-                print("✅ Health check OK!")
-                print(f"   📊 Status: {data.get('status', 'N/A')}")
-                print(f"   🤖 Modelos carregados: {data.get('models_loaded', 'N/A')}")
-                return True
-            else:
-                print(f"❌ Health check falhou: {response.status_code}")
-                return False
-                
-    except Exception as e:
-        print(f"❌ Erro no health check: {str(e)}")
-        return False
-
-async def test_backend_to_models():
-    """🔄 TESTE 3: Backend chamando Models via Client"""
-    print("\n" + "=" * 60)  
-    print("🔄 TESTE 3: BACKEND → MODELS VIA CLIENT")
-    print("=" * 60)
-    
-    try:
-        # Initialize client with explicit URL
-        async with ModelsClient(base_url=MODELS_API_URL) as client:
-            
-            # Test anomaly detection
-            print("🧠 Testando detecção de anomalias...")
-            
-            # Sample data for testing
-            test_data = {
-                "transaction_amount": 150000.00,
-                "vendor_name": "Tech Solutions LTDA",
-                "contract_type": "informática",
-                "transaction_date": "2024-08-18"
-            }
-            
-            result = await client.detect_anomaly(test_data)
-            
-            if result:
-                print("✅ Comunicação Backend → Models OK!")
-                print(f"   🎯 Resultado: {result}")
-                return True
-            else:
-                print("❌ Nenhum resultado retornado")
-                return False
-                
-    except Exception as e:
-        print(f"❌ Erro na comunicação: {str(e)}")
-        return False
-
-async def test_models_specific_endpoints():
-    """🎯 TESTE 4: Endpoints específicos de modelos"""
-    print("\n" + "=" * 60)
-    print("🎯 TESTE 4: ENDPOINTS ESPECÍFICOS DE MODELOS")  
-    print("=" * 60)
-    
-    endpoints_to_test = [
-        "/models/anomaly/detect",
-        "/models/pattern/analyze", 
-        "/models/spectral/analyze"
-    ]
-    
-    results = {}
-    
-    async with httpx.AsyncClient(timeout=30.0) as client:
-        for endpoint in endpoints_to_test:
-            try:
-                url = f"{MODELS_API_URL}{endpoint}"
-                print(f"📡 Testando: {endpoint}")
-                
-                # Sample request data
-                test_payload = {
-                    "data": [1, 2, 3, 4, 5],
-                    "params": {"threshold": 0.8}
-                }
-                
-                response = await client.post(url, json=test_payload)
-                
-                if response.status_code == 200:
-                    print(f"   ✅ {endpoint} - OK")
-                    results[endpoint] = "OK"
-                elif response.status_code == 422:
-                    print(f"   ⚠️ {endpoint} - Schema validation (normal)")
-                    results[endpoint] = "Schema OK"
-                else:
-                    print(f"   ❌ {endpoint} - Status: {response.status_code}")
-                    results[endpoint] = f"Error: {response.status_code}"
-                    
-            except Exception as e:
-                print(f"   ❌ {endpoint} - Erro: {str(e)}")
-                results[endpoint] = f"Exception: {str(e)}"
-    
-    return results
-
-async def test_backend_api_integration():
-    """🏛️ TESTE 5: Backend API usando Models internamente"""
-    print("\n" + "=" * 60)
-    print("🏛️ TESTE 5: BACKEND API - INTEGRAÇÃO COM MODELS")
-    print("=" * 60)
-    
-    try:
-        async with httpx.AsyncClient(timeout=30.0) as client:
-            # Test investigation endpoint (should use models internally)
-            print("🔍 Testando investigação (usa models internamente)...")
-            
-            payload = {
-                "query": "Analisar contratos de informática com valores suspeitos",
-                "data_source": "contracts",
-                "max_results": 10
-            }
-            
-            response = await client.post(
-                f"{BACKEND_API_URL}/api/agents/zumbi/investigate",
-                json=payload
-            )
-            
-            if response.status_code == 200:
-                data = response.json()
-                print("✅ Backend API funcionando!")
-                print(f"   🔍 Status: {data.get('status', 'N/A')}")
-                print(f"   📊 Anomalias: {data.get('anomalies_found', 'N/A')}")
-                print(f"   ⏱️ Tempo: {data.get('processing_time_ms', 'N/A')}ms")
-                return True
-            else:
-                print(f"❌ Backend API erro: {response.status_code}")
-                return False
-                
-    except Exception as e:
-        print(f"❌ Erro no Backend API: {str(e)}")
-        return False
-
-async def run_communication_tests():
-    """🚀 Executar todos os testes de comunicação"""
-    print("🧪 TESTE DE COMUNICAÇÃO CIDADÃO.AI BACKEND ↔ MODELS")
-    print("🕐 Iniciado em:", datetime.now().strftime("%Y-%m-%d %H:%M:%S"))
-    print()
-    
-    results = {
-        "models_api_direct": await test_models_api_direct(),
-        "models_health": await test_models_health(), 
-        "backend_to_models": await test_backend_to_models(),
-        "models_endpoints": await test_models_specific_endpoints(),
-        "backend_integration": await test_backend_api_integration()
-    }
-    
-    # Summary
-    print("\n" + "=" * 60)
-    print("📊 RESUMO DOS TESTES")
-    print("=" * 60)
-    
-    total_tests = len(results)
-    passed_tests = sum(1 for v in results.values() if v is True or (isinstance(v, dict) and any("OK" in str(val) for val in v.values())))
-    
-    for test_name, result in results.items():
-        status = "✅ PASSOU" if result is True else "📊 DETALHES" if isinstance(result, dict) else "❌ FALHOU"
-        print(f"   {test_name}: {status}")
-        
-        if isinstance(result, dict):
-            for endpoint, endpoint_result in result.items():
-                emoji = "✅" if "OK" in str(endpoint_result) else "❌"
-                print(f"     {emoji} {endpoint}: {endpoint_result}")
-    
-    print(f"\n🎯 RESULTADO GERAL: {passed_tests}/{total_tests} testes funcionais")
-    
-    if passed_tests == total_tests:
-        print("🎉 COMUNICAÇÃO BACKEND ↔ MODELS TOTALMENTE FUNCIONAL!")
-    elif passed_tests > 0:
-        print("⚠️ COMUNICAÇÃO PARCIALMENTE FUNCIONAL - Verificar issues")
-    else:
-        print("❌ COMUNICAÇÃO NÃO FUNCIONAL - Verificar deployment")
-    
-    return results
-
-if __name__ == "__main__":
-    asyncio.run(run_communication_tests())

test_models_endpoints.py

@@ -1,142 +0,0 @@
-#!/usr/bin/env python3
-"""
-🧪 Teste dos Endpoints da Models API
-Verifica quando os endpoints ML estão disponíveis
-"""
-
-import asyncio
-import httpx
-import json
-from datetime import datetime
-
-# Models API URL
-MODELS_URL = "https://neural-thinker-cidadao-ai-models.hf.space"
-
-async def test_endpoints():
-    """🔍 Testa todos os endpoints da Models API"""
-    print("🧪 TESTE DOS ENDPOINTS DA MODELS API")
-    print("=" * 50)
-    print(f"🔗 Base URL: {MODELS_URL}")
-    print(f"🕐 Teste iniciado: {datetime.now().strftime('%H:%M:%S')}")
-    print()
-    
-    async with httpx.AsyncClient(timeout=30.0) as client:
-        
-        # 1. Health Check
-        print("1️⃣ HEALTH CHECK")
-        try:
-            response = await client.get(f"{MODELS_URL}/health")
-            data = response.json()
-            print(f"   Status: {data.get('status')}")
-            print(f"   Models loaded: {data.get('models_loaded')}")
-            print(f"   Message: {data.get('message')}")
-            
-            if data.get('models_loaded') == True:
-                print("   ✅ Models API está COMPLETA!")
-            else:
-                print("   ⚠️ Models API em modo fallback")
-        except Exception as e:
-            print(f"   ❌ Erro: {str(e)}")
-        
-        # 2. Documentação
-        print("\n2️⃣ DOCUMENTAÇÃO")
-        print(f"   📚 Swagger UI: {MODELS_URL}/docs")
-        print(f"   📋 OpenAPI JSON: {MODELS_URL}/openapi.json")
-        
-        # 3. Endpoints ML
-        print("\n3️⃣ ENDPOINTS DE ML")
-        
-        # Anomaly Detection
-        print("\n   🔍 DETECÇÃO DE ANOMALIAS")
-        print(f"   POST {MODELS_URL}/v1/detect-anomalies")
-        try:
-            test_data = {
-                "contracts": [
-                    {
-                        "id": "TEST-001",
-                        "vendor": "Empresa Teste LTDA",
-                        "amount": 50000.00,
-                        "date": "2025-08-18",
-                        "category": "Serviços de TI"
-                    }
-                ],
-                "threshold": 0.7
-            }
-            
-            response = await client.post(
-                f"{MODELS_URL}/v1/detect-anomalies",
-                json=test_data
-            )
-            
-            if response.status_code == 200:
-                result = response.json()
-                print(f"   ✅ Endpoint funcional!")
-                print(f"   📊 Anomalias encontradas: {result.get('anomalies_found', 0)}")
-            elif response.status_code == 404:
-                print(f"   ❌ Endpoint não encontrado (Models em fallback)")
-            else:
-                print(f"   ⚠️ Status: {response.status_code}")
-                
-        except Exception as e:
-            print(f"   ❌ Erro: {str(e)[:50]}...")
-        
-        # Pattern Analysis
-        print("\n   📊 ANÁLISE DE PADRÕES")
-        print(f"   POST {MODELS_URL}/v1/analyze-patterns")
-        try:
-            test_data = {
-                "data": {
-                    "time_series": [100, 120, 90, 150, 200, 180],
-                    "categories": ["A", "B", "A", "C", "B", "A"]
-                },
-                "analysis_type": "temporal"
-            }
-            
-            response = await client.post(
-                f"{MODELS_URL}/v1/analyze-patterns",
-                json=test_data
-            )
-            
-            if response.status_code == 200:
-                result = response.json()
-                print(f"   ✅ Endpoint funcional!")
-                print(f"   📈 Padrões encontrados: {result.get('pattern_count', 0)}")
-            elif response.status_code == 404:
-                print(f"   ❌ Endpoint não encontrado (Models em fallback)")
-            else:
-                print(f"   ⚠️ Status: {response.status_code}")
-                
-        except Exception as e:
-            print(f"   ❌ Erro: {str(e)[:50]}...")
-        
-        # Spectral Analysis
-        print("\n   🌊 ANÁLISE ESPECTRAL")
-        print(f"   POST {MODELS_URL}/v1/analyze-spectral")
-        try:
-            test_data = {
-                "time_series": [1, 2, 3, 2, 1, 2, 3, 2, 1],
-                "sampling_rate": 1.0
-            }
-            
-            response = await client.post(
-                f"{MODELS_URL}/v1/analyze-spectral",
-                json=test_data
-            )
-            
-            if response.status_code == 200:
-                result = response.json()
-                print(f"   ✅ Endpoint funcional!")
-                print(f"   🎵 Frequência dominante: {result.get('dominant_frequency', 'N/A')}")
-            elif response.status_code == 404:
-                print(f"   ❌ Endpoint não encontrado (Models em fallback)")
-            else:
-                print(f"   ⚠️ Status: {response.status_code}")
-                
-        except Exception as e:
-            print(f"   ❌ Erro: {str(e)[:50]}...")
-    
-    print("\n" + "=" * 50)
-    print("🏁 Teste concluído!")
-
-if __name__ == "__main__":
-    asyncio.run(test_endpoints())

test_models_only.py

@@ -1,125 +0,0 @@
-#!/usr/bin/env python3
-"""
-🧪 Teste Simples - Apenas Models API
-Testa apenas a API de modelos sem dependências do backend
-"""
-
-import asyncio
-import httpx
-import json
-from datetime import datetime
-
-# Models API URL (confirmed working)
-MODELS_URL = "https://neural-thinker-cidadao-ai-models.hf.space"
-
-async def test_models_api():
-    """🤖 Teste completo da Models API"""
-    print("🤖 TESTE DA CIDADÃO.AI MODELS API")
-    print("=" * 50)
-    print(f"🔗 URL: {MODELS_URL}")
-    print(f"🕐 Iniciado em: {datetime.now().strftime('%H:%M:%S')}")
-    print()
-    
-    async with httpx.AsyncClient(timeout=30.0) as client:
-        
-        # 1. Root endpoint
-        print("1️⃣ TESTANDO ROOT ENDPOINT")
-        try:
-            response = await client.get(f"{MODELS_URL}/")
-            if response.status_code == 200:
-                data = response.json()
-                print("   ✅ Root endpoint OK")
-                print(f"   📊 API: {data.get('api', 'N/A')}")
-                print(f"   🔢 Version: {data.get('version', 'N/A')}")
-                print(f"   📋 Status: {data.get('status', 'N/A')}")
-            else:
-                print(f"   ❌ Root: {response.status_code}")
-        except Exception as e:
-            print(f"   ❌ Root error: {str(e)}")
-        
-        # 2. Health check
-        print("\n2️⃣ TESTANDO HEALTH CHECK")
-        try:
-            response = await client.get(f"{MODELS_URL}/health")
-            if response.status_code == 200:
-                data = response.json()
-                print("   ✅ Health check OK")
-                print(f"   📊 Status: {data.get('status', 'N/A')}")
-                print(f"   🤖 Models loaded: {data.get('models_loaded', 'N/A')}")
-                print(f"   💬 Message: {data.get('message', 'N/A')}")
-            else:
-                print(f"   ❌ Health: {response.status_code}")
-        except Exception as e:
-            print(f"   ❌ Health error: {str(e)}")
-        
-        # 3. Test docs endpoint
-        print("\n3️⃣ TESTANDO DOCUMENTAÇÃO")
-        try:
-            response = await client.get(f"{MODELS_URL}/docs")
-            if response.status_code == 200:
-                print("   ✅ Docs available")
-                print(f"   📝 Content-Type: {response.headers.get('content-type', 'N/A')}")
-            else:
-                print(f"   ❌ Docs: {response.status_code}")
-        except Exception as e:
-            print(f"   ❌ Docs error: {str(e)}")
-        
-        # 4. Test spaces-info
-        print("\n4️⃣ TESTANDO SPACES INFO")
-        try:
-            response = await client.get(f"{MODELS_URL}/spaces-info")
-            if response.status_code == 200:
-                data = response.json()
-                print("   ✅ Spaces info OK")
-                print(f"   🏠 Space ID: {data.get('space_id', 'N/A')}")
-                print(f"   👤 Author: {data.get('space_author', 'N/A')}")
-                print(f"   📦 Platform: {data.get('platform', 'N/A')}")
-                print(f"   🤖 Models available: {data.get('models_available', 'N/A')}")
-            else:
-                print(f"   ❌ Spaces info: {response.status_code}")
-        except Exception as e:
-            print(f"   ❌ Spaces info error: {str(e)}")
-        
-        # 5. Test model endpoints (if available)
-        print("\n5️⃣ TESTANDO ENDPOINTS DE MODELO")
-        
-        model_endpoints = [
-            "/v1/detect-anomalies",
-            "/v1/analyze-patterns",
-            "/v1/analyze-spectral"
-        ]
-        
-        for endpoint in model_endpoints:
-            try:
-                # Test with minimal payload
-                test_payload = {
-                    "contracts": [{"value": 1000, "vendor": "test"}],
-                    "threshold": 0.7
-                } if "anomalies" in endpoint else {
-                    "data": [1, 2, 3, 4, 5],
-                    "params": {"test": True}
-                }
-                
-                response = await client.post(f"{MODELS_URL}{endpoint}", json=test_payload)
-                
-                if response.status_code == 200:
-                    print(f"   ✅ {endpoint} - Functional")
-                elif response.status_code == 422:
-                    print(f"   📋 {endpoint} - Schema validation (endpoint exists)")
-                elif response.status_code == 404:
-                    print(f"   ❌ {endpoint} - Not found")
-                else:
-                    print(f"   ⚠️ {endpoint} - Status: {response.status_code}")
-                    
-            except Exception as e:
-                print(f"   ❌ {endpoint} - Error: {str(e)[:50]}...")
-    
-    print("\n" + "=" * 50)
-    print("🎯 RESUMO")
-    print("✅ Models API está ONLINE e acessível")
-    print("🔗 URL funcional:", MODELS_URL)
-    print("📚 Documentação:", f"{MODELS_URL}/docs")
-    print("🏥 Health check:", f"{MODELS_URL}/health")
-
-if __name__ == "__main__":
-    asyncio.run(test_models_api())

test_quick_connectivity.py

@@ -1,62 +0,0 @@
-#!/usr/bin/env python3
-"""
-⚡ Teste Rápido de Conectividade
-Verifica rapidamente se os serviços estão online
-"""
-
-import asyncio
-import httpx
-
-# URLs dos serviços
-BACKEND_URL = "https://neural-thinker-cidadao-ai-backend.hf.space"
-MODELS_URL = "https://neural-thinker-cidadao-ai-models.hf.space"
-
-async def quick_test():
-    """🚀 Teste rápido de conectividade"""
-    print("⚡ TESTE RÁPIDO DE CONECTIVIDADE")
-    print("=" * 50)
-    
-    async with httpx.AsyncClient(timeout=15.0) as client:
-        
-        # Test Backend
-        print(f"🔍 Testando Backend: {BACKEND_URL}")
-        try:
-            response = await client.get(f"{BACKEND_URL}")
-            if response.status_code == 200:
-                data = response.json()
-                print(f"   ✅ Backend ONLINE - {data.get('status', 'N/A')}")
-                print(f"   🤖 Agentes: {list(data.get('agents', {}).keys())}")
-            else:
-                print(f"   ❌ Backend retornou: {response.status_code}")
-        except Exception as e:
-            print(f"   ❌ Backend OFFLINE: {str(e)}")
-        
-        # Test Models
-        print(f"🤖 Testando Models: {MODELS_URL}")
-        try:
-            response = await client.get(f"{MODELS_URL}/")
-            if response.status_code == 200:
-                data = response.json()
-                print(f"   ✅ Models ONLINE - {data.get('api', 'N/A')}")
-            else:
-                print(f"   ❌ Models retornou: {response.status_code}")
-        except Exception as e:
-            print(f"   ❌ Models OFFLINE: {str(e)}")
-        
-        # Test Backend → Models integration (via backend status)
-        print(f"🔄 Testando Integração via Backend Status:")
-        try:
-            response = await client.get(f"{BACKEND_URL}/api/status")
-            if response.status_code == 200:
-                data = response.json()
-                cache_info = data.get('performance', {}).get('cache', {})
-                print(f"   ✅ Backend Status OK")
-                print(f"   📊 Cache: {cache_info.get('total_entries', 0)} entries")
-                print(f"   🎯 API Version: {data.get('version', 'N/A')}")
-            else:
-                print(f"   ❌ Backend Status: {response.status_code}")
-        except Exception as e:
-            print(f"   ❌ Backend Status Error: {str(e)}")
-
-if __name__ == "__main__":
-    asyncio.run(quick_test())

test_stable_endpoint.py

@@ -1,99 +0,0 @@
-#!/usr/bin/env python3
-"""
-Test the new stable chat endpoint locally
-"""
-
-import asyncio
-import httpx
-from datetime import datetime
-
-async def test_stable_endpoint():
-    """Test the stable chat endpoint"""
-    
-    # Test messages covering all scenarios
-    test_cases = [
-        # Greetings
-        {"message": "Olá, tudo bem?", "expected_intent": "greeting"},
-        {"message": "Boa tarde!", "expected_intent": "greeting"},
-        
-        # Investigations
-        {"message": "Quero investigar contratos do Ministério da Saúde", "expected_intent": "investigation"},
-        {"message": "Buscar licitações suspeitas em São Paulo", "expected_intent": "investigation"},
-        
-        # Analysis
-        {"message": "Analise os gastos com educação em 2024", "expected_intent": "analysis"},
-        {"message": "Faça uma análise dos fornecedores do governo", "expected_intent": "analysis"},
-        
-        # Help
-        {"message": "Como você pode me ajudar?", "expected_intent": "help"},
-        {"message": "O que você faz?", "expected_intent": "help"},
-        
-        # Complex questions
-        {"message": "Existe algum padrão suspeito nos contratos de TI dos últimos 6 meses?", "expected_intent": "investigation/analysis"},
-        {"message": "Quais foram os maiores gastos do governo federal este ano?", "expected_intent": "analysis"},
-    ]
-    
-    print("🧪 Testing Stable Chat Endpoint")
-    print("=" * 60)
-    
-    # Test locally first
-    base_url = "http://localhost:8000"
-    
-    async with httpx.AsyncClient(timeout=10.0) as client:
-        # Check if server is running
-        try:
-            health = await client.get(f"{base_url}/health")
-            print(f"✅ Local server is running: {health.status_code}")
-        except:
-            print("❌ Local server not running. Please start with: make run-dev")
-            return
-        
-        print("\n📊 Testing various message types:")
-        print("-" * 60)
-        
-        success_count = 0
-        total_tests = len(test_cases)
-        
-        for i, test in enumerate(test_cases, 1):
-            print(f"\n Test {i}/{total_tests}")
-            print(f"📤 Message: {test['message']}")
-            print(f"🎯 Expected: {test['expected_intent']}")
-            
-            try:
-                start_time = datetime.now()
-                response = await client.post(
-                    f"{base_url}/api/v1/chat/stable",
-                    json={
-                        "message": test["message"],
-                        "session_id": f"test-{i}"
-                    }
-                )
-                duration = (datetime.now() - start_time).total_seconds() * 1000
-                
-                if response.status_code == 200:
-                    data = response.json()
-                    print(f"✅ Success in {duration:.0f}ms")
-                    print(f"🤖 Agent: {data['agent_name']}")
-                    print(f"💬 Response: {data['message'][:100]}...")
-                    print(f"📊 Confidence: {data['confidence']:.2f}")
-                    print(f"🔧 Backend: {data['metadata'].get('agent_used', 'unknown')}")
-                    success_count += 1
-                else:
-                    print(f"❌ Failed: {response.status_code}")
-                    print(f"Error: {response.text}")
-                    
-            except Exception as e:
-                print(f"❌ Exception: {str(e)}")
-        
-        print("\n" + "=" * 60)
-        print(f"📈 Results: {success_count}/{total_tests} successful ({success_count/total_tests*100:.0f}%)")
-        
-        if success_count == total_tests:
-            print("🎉 Perfect! 100% success rate!")
-        elif success_count >= total_tests * 0.9:
-            print("✅ Excellent! Above 90% success rate")
-        else:
-            print("⚠️  Needs improvement - below 90% success rate")
-
-if __name__ == "__main__":
-    asyncio.run(test_stable_endpoint())