proyectoskevinsvega/mcp-server-ai

graph TB
    subgraph "Cliente"
        CLI[CLI/SDK]
        WEB[Web App]
        MOB[Mobile App]
    end

    subgraph "Load Balancer"
        LB[Nginx Ingress]
        LB --> SSL[SSL Termination]
    end

    subgraph "MCP Server AI"
        API[API Gateway]
        HTTP[HTTP Handler]
        GRPC[gRPC Handler]
        WS[WebSocket Handler]

        API --> HTTP
        API --> GRPC
        API --> WS

        HTTP --> WP[Worker Pool]
        GRPC --> WP
        WS --> WP

        WP --> SM[Session Manager]
        WP --> CACHE[Redis Cache]
    end

    subgraph "Proveedores IA"
        AWS[AWS Bedrock]
        AZURE[Azure OpenAI]

        WP --> AWS
        WP --> AZURE
    end

    subgraph "Persistencia"
        REDIS[(Redis Cluster)]
        POSTGRES[(PostgreSQL)]

        CACHE --> REDIS
        SM --> REDIS
        SM --> POSTGRES
    end

    subgraph "Monitoreo"
        PROM[Prometheus]
        GRAF[Grafana]
        JAEGER[Jaeger]

        API --> PROM
        PROM --> GRAF
        API --> JAEGER
    end

    CLI --> LB
    WEB --> LB
    MOB --> LB
    LB --> API

# 1. Clonar el repositorio
git clone https://github.com/proyectoskevinsvega/mcp-server-ai.git
cd mcp-server-ai

# 2. Configurar variables de entorno
cp .env.example .env
# Editar .env con tus credenciales reales

# 3. Instalar dependencias
go mod download

# 4. instalar dependencias
go mod tidy

# 5. Generar código protobuf (opcional, ya incluido)
protoc --go_out=. --go-grpc_out=. internal/proto/ai_service.proto

# 6. Ejecutar en modo desarrollo
go run cmd/server/main.go -debug -http=8090 -ws=8091 -grpc=50051

# 7. Compilar para producciòn producción
go build -o mcp-server-ai cmd/server/main.go

# Ejecutar en modo producción
./mcp-server-ai -http=8090 -ws=8091 -grpc=50051

# Iniciar stack completo (MCP Server + Redis + PostgreSQL + Monitoring)
docker-compose up -d

# Ver logs en tiempo real
docker-compose logs -f mcp-server

# Verificar estado de todos los servicios
docker-compose ps

# Acceder a servicios
# - API: http://localhost:8090
# - WebSocket: ws://localhost:8091
# - gRPC: localhost:50051
# - Grafana: http://localhost:3000 (admin/admin)
# - Prometheus: http://localhost:9090

# Despliegue automatizado con script
cd deploy/k8s
chmod +x deploy-all.sh

# Configurar secrets (IMPORTANTE)
./deploy-all.sh help  # Ver opciones disponibles

# Desplegar stack completo
./deploy-all.sh deploy

# Verificar estado
./deploy-all.sh status

# Ver logs
./deploy-all.sh logs mcp-server

# Ejecutar tests de conectividad
./deploy-all.sh test

# Port-forward para acceso local
./deploy-all.sh forward mcp-server-service 8090 8090

# ===========================================
# Configuración del Servidor
# ===========================================
SERVER_ENV=production                    # development | production
IN_MODE=release                          # debug | release
LOG_LEVEL=info                          # debug | info | warn | error

# Puertos del servidor
HTTP_PORT=8090
WS_PORT=8091
GRPC_PORT=50051
METRICS_PORT=9090

# ===========================================
# Configuración de CORS
# ===========================================
CORS_ALLOW_ALL_ORIGINS=false
CORS_ALLOWED_ORIGINS=https://app.empresa.com,https://admin.empresa.com
CORS_ALLOW_METHODS=GET,POST,PUT,DELETE,OPTIONS,PATCH
CORS_ALLOW_HEADERS=Origin,Content-Type,Accept,Authorization,X-Request-ID,X-User-ID,X-Session-ID
CORS_EXPOSE_HEADERS=Content-Length,Content-Type,X-Request-ID
CORS_ALLOW_CREDENTIALS=true
CORS_MAX_AGE=43200

# ===========================================
# AWS Bedrock Configuration
# ===========================================
AWS_ACCESS_KEY_ID=tu_access_key_aqui
AWS_SECRET_ACCESS_KEY=tu_secret_key_aqui
AWS_REGION=us-west-2
AWS_DEFAULT_MODEL=claude-3-sonnet

# ===========================================
# Azure OpenAI Configuration
# ===========================================
AZURE_API_KEY=tu_azure_api_key_aqui
AZURE_RESOURCE_NAME=tu_resource_name
AZURE_ENDPOINT=https://tu-recurso.openai.azure.com/
AZURE_API_VERSION=2024-10-21
AZURE_DEFAULT_MODEL=gpt-4o

# Configuración de proveedores
DEFAULT_PROVIDER=azure                   # aws | azure
MAX_TOKENS=4096
TEMPERATURE=0.7

# ===========================================
# Redis Cache Configuration
# ===========================================
CACHE_ENABLED=true
CACHE_TTL=3600                          # 1 hora en segundos
USE_REDIS=true
REDIS_HOST=localhost
REDIS_PORT=6379
REDIS_PASSWORD=tu_redis_password
REDIS_DB=0
REDIS_URL=redis://:password@localhost:6379/0

# Para Azure Redis Cache con SSL
# REDIS_URL=rediss://:password@tu-cache.redis.cache.windows.net:6380/0

# ===========================================
# PostgreSQL Configuration
# ===========================================
POSTGRES_HOST=localhost
POSTGRES_PORT=5432
POSTGRES_DB=mcp_server
POSTGRES_USER=mcp_user
POSTGRES_PASSWORD=tu_postgres_password
POSTGRES_URL=postgres://mcp_user:password@localhost:5432/mcp_server?sslmode=require
USE_DATABASE_PERSISTENCE=true

# ===========================================
# Sistema de Sesiones
# ===========================================
ENABLE_SESSION_MANAGEMENT=true
USE_REDIS_CACHE=true
SESSION_MAX_MESSAGES=100
SESSION_CACHE_TTL=86400                 # 24 horas
SESSION_CONTEXT_WINDOW=50

# ===========================================
# Worker Pool Configuration
# ===========================================
ENABLE_PARALLEL_MODE=true
POOL_MIN_WORKERS=32
POOL_MAX_WORKERS=512
POOL_QUEUE_SIZE=100000
POOL_SCALE_INTERVAL=5s
POOL_UTILIZATION_TARGET=0.75
POOL_MAX_CONCURRENT=10000
POOL_BUFFER_SIZE=65536

# ===========================================
# Monitoreo y Métricas
# ===========================================
ENABLE_METRICS=true
ENABLE_TRACING=true
TRACING_ENDPOINT=http://jaeger:14268/api/traces

# ===========================================
# Rate Limiting
# ===========================================
RATE_LIMIT_ENABLED=true
RATE_LIMIT_RPS=1000
RATE_LIMIT_BURST=2000

# ===========================================
# Seguridad
# ===========================================
ENABLE_TLS=false                        # true para producción
TLS_CERT_PATH=/etc/ssl/certs/server.crt
TLS_KEY_PATH=/etc/ssl/private/server.key
TRUSTED_PROXIES=10.0.0.0/8,172.16.0.0/12,192.168.0.0/16

curl -X POST http://localhost:8090/api/v1/generate \
  -H "Content-Type: application/json" \
  -H "X-User-ID: user-123" \
  -H "X-Session-ID: session-456" \
  -d '{
    "prompt": "Explica qué es Go en 1 párrafos",
    "model": "gpt-4o",
    "provider": "azure",
    "system": "Eres un experto en programación que explica conceptos de forma clara y concisa."
  }' | jq '.'

{
  "content": "Go es un lenguaje de programación...",
  "model": "gpt-4o",
  "provider": "azure-openai",
  "tokensUsed": 245,
  "cached": false,
  "processingTime": "1.2s",
  "requestId": "req-789",
  "sessionId": "session-456"
}

curl -X POST http://localhost:8090/api/v1/generate/stream \
  -H "Content-Type: application/json" \
  -H "Accept: text/event-stream" \
  -H "X-User-ID: user-123" \
  -H "X-Session-ID: session-456" \
  -d '{
    "prompt": "que es facebook en 3 palabras",
    "model": "claude-3-sonnet",
    "provider": "aws",
    "system": "Eres un experto en Go que escribe código limpio y bien documentado"
  }'

curl -X POST http://localhost:8090/api/v1/generate/batch \
  -H "Content-Type: application/json" \
  -H "X-User-ID: user-123" \
  -H "X-Session-ID: session-456" \
  -d '{
    "requests": [
      {
        "prompt": "¿Qué es Docker en dos palabras?",
        "model": "gpt-4o",
        "provider": "azure",
        "system": "Eres un experto en DevOps que explica tecnologías de forma clara"
      },
      {
        "prompt": "¿Qué es Kubernetes en dos palabras?",
        "model": "claude-3-sonnet",
        "provider": "aws",
        "system": "Eres un especialista en orquestación de contenedores"
      },
      {
        "prompt": "¿Qué es Go en 2 palabras?",
        "model": "gpt-4.1",
        "provider": "azure",
        "system": "Eres un programador experto en lenguajes de programación"
      },
      {
        "prompt": "¿hola?",
        "model": "DeepSeek-R1",
        "provider": "azure",
        "system": "Eres un especialista en bases de datos y cache"
      },
      {
        "prompt": "¿que tal?",
        "model": "DeepSeek-R1-0528",
        "provider": "azure",
        "system": "Eres un experto en bases de datos relacionales"
      }
    ]
  }' | jq '.'

{
  "responses": [
    {
      "content": "Docker es una plataforma...",
      "model": "gpt-4o",
      "provider": "azure-openai",
      "tokensUsed": 156,
      "index": 0
    },
    {
      "content": "Kubernetes es un sistema...",
      "model": "claude-3-sonnet",
      "provider": "aws-bedrock",
      "tokensUsed": 189,
      "index": 1
    }
  ],
  "count": 5,
  "totalTokens": 892,
  "processingTime": "2.8s",
  "rate": "1.79 req/s",
  "parallelProcessing": true
}

curl -X POST http://localhost:8090/api/v1/generate/batch/stream \
  -H "Content-Type: application/json" \
  -H "Accept: text/event-stream" \
  -d '{
    "requests": [
      {"prompt": "Cuenta del 1 al 5", "model": "gpt-4.1", "system": "Responde de forma concisa"},
      {"prompt": "Lista 3 colores", "model": "gpt-4.1", "system": "Responde de forma concisa"},
      {"prompt": "Nombra 3 lenguajes", "model": "gpt-4.1", "system": "Responde de forma concisa"}
    ]
  }'

curl http://localhost:8090/api/v1/models | jq '.'

curl http://localhost:8090/api/v1/status | jq '.'

curl http://localhost:8090/api/v1/pool/stats | jq '.'

curl http://localhost:8090/health | jq '.'

curl http://localhost:8090/metrics

service AIService {
    // Generar contenido de forma síncrona
    rpc Generate(GenerateRequest) returns (GenerateResponse);

    // Generar contenido con streaming
    rpc GenerateStream(GenerateRequest) returns (stream StreamChunk);

    // Listar modelos disponibles
    rpc ListModels(ListModelsRequest) returns (ListModelsResponse);

    // Obtener estado del sistema
    rpc GetStatus(StatusRequest) returns (StatusResponse);
}

# Instalar grpcurl
go install github.com/fullstorydev/grpcurl/cmd/grpcurl@latest

# Listar servicios disponibles
grpcurl -plaintext localhost:50051 list

# Describir el servicio
grpcurl -plaintext localhost:50051 describe proto.AIService

# Generar contenido
grpcurl -plaintext -d '{
  "prompt": "Hola mundo en Go",
  "model": "gpt-4o",
  "provider": "azure",
  "systemPrompt": "Eres un programador experto en Go"
}' localhost:50051 proto.AIService/Generate

# Streaming
grpcurl -plaintext -d '{
  "prompt": "Escribe un poema sobre la programación",
  "model": "claude-3-sonnet",
  "provider": "aws",
  "maxTokens": 500
}' localhost:50051 proto.AIService/GenerateStream

# Listar modelos
grpcurl -plaintext -d '{}' localhost:50051 proto.AIService/ListModels

# Estado del sistema
grpcurl -plaintext -d '{}' localhost:50051 proto.AIService/GetStatus

// Conectar al WebSocket
const ws = new WebSocket("ws://localhost:8091/ws");

// Manejar conexión
ws.onopen = () => {
  console.log("Conectado al MCP Server AI");

  // Enviar request de generación
  ws.send(
    JSON.stringify({
      prompt: "Explica Docker en términos simples",
      model: "gpt-4o",
      provider: "azure",
      maxTokens: 500,
      temperature: 0.7,
      systemPrompt:
        "Eres un instructor técnico que explica conceptos complejos de forma simple.",
    })
  );
};

// Manejar mensajes (chunks de streaming)
ws.onmessage = (event) => {
  const chunk = JSON.parse(event.data);

  if (chunk.error) {
    console.error("Error:", chunk.error);
    return;
  }

  // Mostrar contenido del chunk
  process.stdout.write(chunk.content || "");

  // Verificar si terminó
  if (chunk.finished) {
    console.log("\n\n--- Generación completada ---");
    console.log(`Tokens usados: ${chunk.totalTokens}`);
    console.log(`Tiempo: ${chunk.processingTime}`);
    console.log(`Modelo: ${chunk.model}`);
    console.log(`Proveedor: ${chunk.provider}`);
  }
};

// Manejar errores
ws.onerror = (error) => {
  console.error("Error de WebSocket:", error);
};

// Manejar cierre
ws.onclose = (event) => {
  console.log("Conexión cerrada:", event.code, event.reason);
};

const WebSocket = require("ws");

const ws = new WebSocket("ws://localhost:8091/ws");

ws.on("open", () => {
  ws.send(
    JSON.stringify({
      prompt: "Crea un API REST en Go con Gin",
      model: "claude-3-sonnet",
      provider: "aws",
      maxTokens: 1500,
    })
  );
});

ws.on("message", (data) => {
  const chunk = JSON.parse(data);
  process.stdout.write(chunk.content || "");

  if (chunk.finished) {
    console.log(`\n\nCompletado en ${chunk.processingTime}`);
    ws.close();
  }
});

curl -X POST http://localhost:8090/api/v1/generate \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "Explica qué es Go en 3 líneas",
    "model": "gpt-4.1",
    "provider": "azure"
  }' | jq '.'

curl -X POST http://localhost:8090/api/v1/generate \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "Escribe un hello world en Go",
    "model": "claude-3-sonnet",
    "provider": "aws",
    "systemPrompt": "Eres un programador senior de Go. Proporciona código limpio y bien comentado.",
    "maxTokens": 1500,
    "temperature": 0.3
  }' | jq '.'

curl -X POST http://localhost:8090/api/v1/generate/stream \
  -H "Content-Type: application/json" \
  -H "Accept: text/event-stream" \
  -d '{
    "prompt": "Crea un servidor HTTP completo en Go con middleware de logging, CORS y manejo de errores",
    "model": "gpt-4.1",
    "provider": "azure",
    "maxTokens": 3000,
    "temperature": 0.4
  }'

curl -X POST http://localhost:8090/api/v1/generate/batch \
  -H "Content-Type: application/json" \
  -d '{
    "requests": [
      {
        "prompt": "¿Qué es Docker y para qué sirve?",
        "model": "gpt-4o",
        "provider": "azure",
        "maxTokens": 300
      },
      {
        "prompt": "¿Qué es Kubernetes y cuáles son sus beneficios?",
        "model": "claude-3-sonnet",
        "provider": "aws",
        "maxTokens": 300
      },
      {
        "prompt": "¿Qué es Go y por qué es popular?",
        "model": "DeepSeek-R1",
        "provider": "azure",
        "maxTokens": 300
      },
      {
        "prompt": "¿Qué es Redis y cuándo usarlo?",
        "model": "gpt-4.1",
        "provider": "azure",
        "maxTokens": 300
      },
      {
        "prompt": "¿Qué es PostgreSQL y sus ventajas?",
        "model": "Llama-3.3-70B-Instruct",
        "provider": "azure",
        "maxTokens": 300
      }
    ]
  }' | jq '.'

# Primera interacción - establecer contexto
curl -X POST http://localhost:8090/api/v1/generate \
  -H "Content-Type: application/json" \
  -H "X-User-ID: developer-123" \
  -H "X-Session-ID: session-golang-tutorial" \
  -d '{
    "prompt": "Hola, soy un desarrollador junior y quiero aprender Go. ¿Por dónde empiezo?",
    "model": "gpt-4o",
    "provider": "azure",
    "maxTokens": 500
  }' | jq '.'

# Segunda interacción - continuar conversación
curl -X POST http://localhost:8090/api/v1/generate \
  -H "Content-Type: application/json" \
  -H "X-User-ID: developer-123" \
  -H "X-Session-ID: session-golang-tutorial" \
  -d '{
    "prompt": "Perfecto, ya instalé Go. ¿Puedes mostrarme cómo crear mi primer programa?",
    "model": "gpt-4o",
    "provider": "azure",
    "maxTokens": 800
  }' | jq '.'

# Tercera interacción - contexto acumulado
curl -X POST http://localhost:8090/api/v1/generate \
  -H "Content-Type: application/json" \
  -H "X-User-ID: developer-123" \
  -H "X-Session-ID: session-golang-tutorial" \
  -d '{
    "prompt": "Excelente. Ahora quiero crear un servidor HTTP. ¿Cómo lo hago?",
    "model": "gpt-4o",
    "provider": "azure",
    "maxTokens": 1000
  }' | jq '.'

# Estado general del sistema
curl http://localhost:8090/api/v1/status | jq '.'

# Estadísticas detalladas del Worker Pool
curl http://localhost:8090/api/v1/pool/stats | jq '.'

# Lista completa de modelos con capacidades
curl http://localhost:8090/api/v1/models | jq '.'

# Health check con detalles
curl http://localhost:8090/health | jq '.'

# Métricas de Prometheus
curl http://localhost:8090/metrics | grep mcp_

# Estadísticas específicas
curl http://localhost:8090/metrics | grep -E "(mcp_requests_total|mcp_tokens_used_total|mcp_cache_hits_total)"

# Instalar herramientas de testing
go install github.com/rakyll/hey@latest

# Test básico - 100 requests, 10 concurrentes
hey -n 100 -c 10 -m POST \
  -H "Content-Type

curl -X POST http://localhost:8090/api/v1/generate \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "Resuelve este problema paso a paso: Si tengo 3 manzanas y compro el doble de las que tengo, luego regalo la mitad, ¿cuántas me quedan?",
    "model": "DeepSeek-R1",
    "provider": "azure",
    "maxTokens": 500,
    "temperature": 0.1
  }' | jq '.'

curl -X POST http://localhost:8090/api/v1/generate \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "Explica qué es la programación funcional, pero hazlo divertido",
    "model": "grok-3",
    "provider": "azure",
    "maxTokens": 800,
    "temperature": 0.8
  }' | jq '.'

curl -X POST http://localhost:8090/api/v1/generate \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "Crea un algoritmo de ordenamiento burbuja en Go con explicación",
    "model": "Llama-3.3-70B-Instruct",
    "provider": "azure",
    "maxTokens": 1200,
    "temperature": 0.2
  }' | jq '.'

# Build con multi-stage para producción
docker build -t mcp-server-ai:latest .

# Build con argumentos específicos
docker build \
  --build-arg BUILD_ENV=production \
  --build-arg VERSION=v1.0.0 \
  -t mcp-server-ai:v1.0.0 .

# Run con configuración completa
docker run -d \
  --name mcp-server \
  -p 8090:8090 \
  -p 8091:8091 \
  -p 50051:50051 \
  -p 9090:9090 \
  --env-file .env \
  --restart unless-stopped \
  --memory="2g" \
  --cpus="1.5" \
  mcp-server-ai:latest

# Ver logs
docker logs -f mcp-server

# Ejecutar comandos dentro del contenedor
docker exec -it mcp-server /bin/sh

# Iniciar stack completo
docker-compose up -d

# Ver logs de todos los servicios
docker-compose logs -f

# Reiniciar solo el servidor principal
docker-compose restart mcp-server

# Escalar el servicio
docker-compose up -d --scale mcp-server=3

# Usar configuración de producción
docker-compose -f docker-compose.yml -f docker-compose.prod.yml up -d

# Verificar estado
docker-compose -f docker-compose.yml -f docker-compose.prod.yml ps

# Ver métricas de recursos
docker stats

cd deploy/k8s

# 1. Crear namespace
kubectl apply -f namespace.yaml

# 2. Configurar RBAC
kubectl apply -f rbac.yaml

# 3. Aplicar ConfigMaps
kubectl apply -f configmap.yaml

# 4. Configurar Secrets (IMPORTANTE: editar antes)
# Editar secret.yaml con valores reales
kubectl apply -f secret.yaml

# 5. Desplegar PostgreSQL
kubectl apply -f postgres.yaml

# 6. Desplegar Redis
kubectl apply -f redis.yaml

# 7. Desplegar aplicación principal
kubectl apply -f deployment.yaml

# 8. Configurar servicios
kubectl apply -f service.yaml

# 9. Configurar Ingress
kubectl apply -f ingress.yaml

# 10. Configurar auto-scaling
kubectl apply -f hpa-pdb.yaml

# Ver estado de todos los recursos
kubectl get all -n mcp-server

# Ver logs en tiempo real
kubectl logs -f deployment/mcp-server-deployment -n mcp-server

# Port-forward para acceso local
kubectl port-forward service/mcp-server-service 8090:8090 -n mcp-server

# Escalar manualmente
kubectl scale deployment mcp-server-deployment --replicas=5 -n mcp-server

# Ver métricas de HPA
kubectl get hpa -n mcp-server -w

# Describir pod para debugging
kubectl describe pod -l app=mcp-server-ai -n mcp-server

# Ejecutar comando en pod
kubectl exec -it deployment/mcp-server-deployment -n mcp-server -- /bin/sh

# Ver eventos del namespace
kubectl get events -n mcp-server --sort-by='.lastTimestamp'

# Rate de requests por segundo
rate(mcp_requests_total[5m])

# Latencia percentil 95
histogram_quantile(0.95, rate(mcp_request_duration_seconds_bucket[5m]))

# Tasa de error
rate(mcp_errors_total[5m]) / rate(mcp_requests_total[5m]) * 100

# Utilización del Worker Pool
mcp_worker_pool_active_workers / mcp_worker_pool_max_workers * 100

# Hit rate del cache
rate(mcp_cache_hits_total[5m]) / (rate(mcp_cache_hits_total[5m]) + rate(mcp_cache_misses_total[5m])) * 100

# Docker Compose
http://localhost:3000
# Usuario: admin, Password: admin

# Kubernetes con port-forward
kubectl port-forward service/grafana-service 3000:3000 -n mcp-server

# Ver logs con filtros
docker-compose logs mcp-server | grep ERROR
docker-compose logs mcp-server | grep "level=warn"

# Kubernetes
kubectl logs deployment/mcp-server-deployment -n mcp-server | jq '.'
kubectl logs deployment/mcp-server-deployment -n mcp-server | grep '"level":"error"'

# Seguir logs en tiempo real con filtros
kubectl logs -f deployment/mcp-server-deployment -n mcp-server | jq 'select(.level=="info")'

{
  "timestamp": "2024-01-15T10:30:45Z",
  "level": "info",
  "message": "Request processed successfully",
  "requestId": "req-123456",
  "userId": "user-789",
  "sessionId": "session-456",
  "provider": "azure-openai",
  "model": "gpt-4o",
  "tokensUsed": 245,
  "processingTime": "1.2s",
  "cached": false,
  "workerPool": {
    "activeWorkers": 45,
    "queueSize": 12
  }
}

# Ejecutar todos los tests
go test ./... -v

# Tests con coverage
go test ./... -v -cover -coverprofile=coverage.out

# Ver coverage en HTML
go tool cover -html=coverage.out -o coverage.html

# Tests específicos
go test ./internal/ai/... -v
go test ./internal/pool/... -v
go test ./internal/handlers/... -v

# Benchmarks del Worker Pool
go test -bench=. -benchmem ./internal/pool/...

# Benchmarks de los handlers
go test -bench=. -benchmem ./internal/handlers/...

# Benchmarks con profiling
go test -bench=. -benchmem -cpuprofile=cpu.prof ./internal/pool/...
go tool pprof cpu.prof

# Tests con servicios reales (requiere .env configurado)
go test -tags=integration ./tests/integration/... -v

# Tests específicos de proveedores
go test -tags=integration ./tests/integration/aws/... -v
go test -tags=integration ./tests/integration/azure/... -v

# Iniciar servidor para tests
go run cmd/server/main.go &
SERVER_PID=$!

# Ejecutar tests E2E
cd tests/e2e
go test -v

# Limpiar
kill $SERVER_PID

# Test completo del Worker Pool
./scripts/test-batch-processing.sh

# Test del sistema de sesiones
./scripts/test-session-management.sh

# Test de todos los endpoints
./examples/test-all-endpoints.sh

# Benchmark en tiempo real con WebSocket
go run scripts/realtime-benchmark-server.go

# .github/workflows/security.yml incluye:
- CodeQL Analysis (SAST)
- Dependency Review
- Secret Scanning
- Container Vulnerability Scanning
- Kubernetes Security Scanning
- OWASP ZAP (DAST)
- License Compliance

// internal/ai/manager.go
func (m *Manager) GetProvider(name string) (Provider, error) {
    switch name {
    case "aws":
        return m.awsProvider, nil
    case "azure":
        return m.azureProvider, nil
    default:
        return nil, fmt.Errorf("unknown provider: %s", name)
    }
}

// internal/pool/worker_pool.go
type WorkerPool struct {
    workers    int
    jobQueue   chan Job
    workerPool chan chan Job
    quit       chan bool
}

// Métricas y logging
type MetricsCollector interface {
    RecordRequest(provider, model string, duration time.Duration)
    RecordError(provider, errorType string)
    RecordTokens(provider, model string, tokens int)
}

// internal/ai/new_provider.go
type NewProvider struct {
    client *http.Client
    config NewProviderConfig
}

func (p *NewProvider) Generate(ctx context.Context, req *GenerateRequest) (*GenerateResponse, error) {
    // Implementación específica
}

func (p *NewProvider) StreamGenerate(ctx context.Context, req *GenerateRequest, stream chan<- *StreamChunk) error {
    // Implementación de streaming
}

func (p *NewProvider) ListModels() []Model {
    // Lista de modelos soportados
}

func (p *NewProvider) GetName() string {
    return "new-provider"
}

// internal/ai/manager.go
func (m *Manager) initNewProvider() error {
    config := NewProviderConfig{
        APIKey:   os.Getenv("NEW_PROVIDER_API_KEY"),
        Endpoint: os.Getenv("NEW_PROVIDER_ENDPOINT"),
    }

    m.newProvider = &NewProvider{
        client: &http.Client{Timeout: 30 * time.Second},
        config: config,
    }

    return nil
}

# .env
NEW_PROVIDER_API_KEY=tu_api_key
NEW_PROVIDER_ENDPOINT=https://api.newprovider.com

// internal/ai/new_provider_test.go
func TestNewProvider_Generate(t *testing.T) {
    // Tests unitarios
}

name: CI/CD Pipeline
on:
  push:
    branches: [main, develop]
  pull_request:
    branches: [main]
  release:
    types: [published]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-go@v4
        with:
          go-version: "1.23"
      - run: go test ./... -v -cover

  security:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: github/codeql-action/init@v2
      - uses: github/codeql-action/analyze@v2

  build:
    needs: [test, security]
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: docker/build-push-action@v4
        with:
          push: true
          tags: |
            ghcr.io/${{ github.repository }}:latest
            ghcr.io/${{ github.repository }}:${{ github.sha }}

  deploy:
    needs: build
    runs-on: ubuntu-latest
    if: github.ref == 'refs/heads/main'
    steps:
      - name: Deploy to Production
        run: |
          # Despliegue automático a producción

name: Security Scan
on:
  schedule:
    - cron: "0 2 * * *" # Diario a las 2 AM
  push:
    branches: [main]

jobs:
  vulnerability-scan:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Run Trivy vulnerability scanner
        uses: aquasecurity/trivy-action@master
        with:
          scan-type: "fs"
          scan-ref: "."

  dependency-review:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/dependency-review-action@v3

  secret-scan:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: trufflesecurity/trufflehog@main
        with:
          path: ./

git clone https://github.com/proyectoskevinsvega/mcp-server-ai.git
cd mcp-server-ai

git checkout -b feature/nueva-funcionalidad

# Hacer cambios
go test ./... -v
go fmt ./...
go vet ./...

git add .
git commit -m "feat: agregar nueva funcionalidad"
git push origin feature/nueva-funcionalidad