🚀 Deploy e Apresentacao

# Dockerfile
FROM python:3.11-slim

WORKDIR /app

# Dependencias
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# Codigo
COPY app/ ./app/
COPY config/ ./config/
COPY alembic/ ./alembic/
COPY alembic.ini .

# Expor porta
EXPOSE 8000

# Health check
HEALTHCHECK --interval=30s --timeout=3s \
  CMD curl -f http://localhost:8000/health || exit 1

# Comando
CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000"]

---

# docker-compose.yml
version: '3.8'
services:
  app:
    build: .
    ports:
      - "8000:8000"
    environment:
      - DATABASE_URL=postgresql://user:pass@db:5432/gipm
      - GEMINI_API_KEY=${GEMINI_API_KEY}
    depends_on:
      - db

  db:
    image: postgres:15
    environment:
      - POSTGRES_USER=user
      - POSTGRES_PASSWORD=pass
      - POSTGRES_DB=gipm
    volumes:
      - pgdata:/var/lib/postgresql/data

volumes:
  pgdata:

# config/production.py
from pydantic_settings import BaseSettings

class ProductionSettings(BaseSettings):
    # Database
    DATABASE_URL: str
    DB_POOL_SIZE: int = 20
    DB_MAX_OVERFLOW: int = 10

    # AI Provider
    GEMINI_API_KEY: str
    AI_TIMEOUT_SECONDS: int = 30
    AI_MAX_RETRIES: int = 3

    # Governanca
    MAX_TOKENS_INPUT: int = 4000
    MAX_TOKENS_OUTPUT: int = 2000
    DAILY_COST_LIMIT_USD: float = 50.0

    # Seguranca
    API_KEY_HEADER: str = "X-API-Key"
    RATE_LIMIT_REQUESTS: int = 100
    RATE_LIMIT_WINDOW_SECONDS: int = 60

    # Logging
    LOG_LEVEL: str = "INFO"
    LOG_FORMAT: str = "json"

    class Config:
        env_file = ".env.production"

---

# .env.production.example
DATABASE_URL=postgresql://user:pass@db-host:5432/gipm_prod
GEMINI_API_KEY=your-api-key-here
DAILY_COST_LIMIT_USD=100.0
LOG_LEVEL=WARNING

# app/monitoring.py
import logging
from prometheus_client import Counter, Histogram, Gauge

# Metricas Prometheus
REQUEST_COUNT = Counter(
    'gipm_requests_total',
    'Total de requisicoes',
    ['endpoint', 'status']
)

REQUEST_LATENCY = Histogram(
    'gipm_request_latency_seconds',
    'Latencia das requisicoes',
    ['endpoint']
)

AI_COST = Counter(
    'gipm_ai_cost_usd_total',
    'Custo total com AI em USD',
    ['persona']
)

DAILY_COST = Gauge(
    'gipm_daily_cost_usd',
    'Custo do dia atual em USD'
)

# Middleware de logging estruturado
class GIPMLogger:
    def __init__(self):
        self.logger = logging.getLogger("gipm")

    def log_request(self, request_id: str, data: dict):
        self.logger.info("request_processed", extra={
            "request_id": request_id,
            "persona": data.get("persona"),
            "tokens_input": data.get("tokens_input"),
            "tokens_output": data.get("tokens_output"),
            "cost_usd": data.get("cost_usd"),
            "latency_ms": data.get("latency_ms")
        })

# Endpoint de metricas
@router.get("/metrics")
async def metrics():
    from prometheus_client import generate_latest
    return Response(generate_latest(), media_type="text/plain")

# Roteiro de Apresentacao GIPM (~15 minutos)

## 1. Introducao (2 min)
- Nome do projeto
- Problema que resolve
- Por que GIPM foi escolhido

## 2. Arquitetura (3 min)
- Diagrama das 3 camadas
- Mostrar METHOD_MAPPING.md
- Destacar separacao de responsabilidades

## 3. Pipeline Universal (3 min)
- Demonstrar os 9 passos
- Mostrar codigo do pipeline
- Explicar cada fase (Entrada, Processamento, Saida)

## 4. Governanca Cognitiva (3 min)
- Apresentar personas implementadas
- Mostrar guardrails em acao
- Demonstrar validacoes pre/pos AI

## 5. Demo ao Vivo (3 min)
- Fazer uma requisicao real
- Mostrar resposta estruturada
- Mostrar registro no banco (auditoria)

## 6. Conclusao (1 min)
- Metricas do projeto
- Proximos passos
- Perguntas

# scripts/demo.sh
#!/bin/bash

echo "=== GIPM Demo ==="
echo ""

# 1. Health Check
echo "1. Verificando saude do sistema..."
curl -s http://localhost:8000/health | jq .
echo ""

# 2. Listar Personas
echo "2. Personas disponiveis:"
curl -s http://localhost:8000/api/v1/personas | jq .
echo ""

# 3. Fazer requisicao
echo "3. Processando texto com persona 'summarizer'..."
RESPONSE=$(curl -s -X POST http://localhost:8000/api/v1/process \
  -H "Content-Type: application/json" \
  -d '{
    "input": "A inteligencia artificial esta transformando...",
    "task_type": "resumo"
  }')
echo $RESPONSE | jq .
echo ""

# 4. Extrair request_id
REQUEST_ID=$(echo $RESPONSE | jq -r '.request_id')
echo "Request ID: $REQUEST_ID"
echo ""

# 5. Consultar auditoria
echo "4. Consultando registro de auditoria..."
curl -s "http://localhost:8000/api/v1/audit/$REQUEST_ID" | jq .
echo ""

# 6. Dashboard
echo "5. Metricas do sistema:"
curl -s http://localhost:8000/api/v1/dashboard | jq .
echo ""

echo "=== Demo Completa ==="

# Criterios de Certificacao GIPM Master

## Requisitos Obrigatorios

### Principios (todos devem estar presentes)
✓ API-first implementado
✓ Backend orquestra, AI executa
✓ Duas fases (estrutura + artefato)
✓ Persistencia total
✓ Modularidade e anti-lock-in

### Camadas (todas devem estar documentadas)
✓ Camada Humana definida
✓ Camada Sistema implementada
✓ Camada Cognitiva controlada

### Pipeline Universal
✓ 9 passos implementados
✓ Cada passo rastreavel no codigo
✓ Fluxo auditavel end-to-end

### Documentacao
✓ METHOD_MAPPING.md completo
✓ COGNITIVE_GOVERNANCE.md completo
✓ API documentada (OpenAPI)
✓ RUNBOOK.md operacional
✓ Pelo menos 2 ADRs

### Qualidade
✓ Testes com coverage >= 80%
✓ Code review checklist GIPM
✓ Definition of Done verificado

---

## Resultado

Projeto aprovado = Certificado GIPM Master
"Este projeto segue o Metodo GIPM v1.2"