🚀 MCP Server AI - Servidor Unificado de IA Multi-Proveedor
Microservicio empresarial de alta performance para integración con múltiples proveedores de IA
Power your agent
पब्लिशर का इंस्टॉल। PlugMCP एंडपॉइंट नहीं।
Host a copy with our keys and logs.
रजिस्ट्री में अभी कोई पैकेज्ड रिलीज़ नहीं है। रिपॉज़िटरी का README देखें.
रिमोट URL या आपकी मशीन पर कमांड? दोनों इंस्टॉल में क्या अंतर है
PlugMCP पर चलाएँ
A new server you create. It is not this listing's official endpoint. Use the publisher install when you want their URL and their credentials.
लॉन्चपब्लिशर से
MCP Server AI es un microservicio robusto y escalable diseñado para producción que unifica el acceso a múltiples proveedores de IA (AWS Bedrock, Azure OpenAI) a través de una API consistente. Incluye soporte completo para gRPC, HTTP/REST, WebSocket, procesamiento en batch, gestión de sesiones y monitoreo avanzado.
sync.Poolgraph 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://:[email protected]: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
Endpoint: POST /api/v1/generate
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 '.'
Respuesta:
{
"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"
}
Endpoint: POST /api/v1/generate/stream
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"
}'
Respuesta (Server-Sent Events):
data: {"content": "package", "finished": false, "index": 0}
data: {"content": " main\n\nimport", "finished": false, "index": 1}
data: {"content": " (\n\t\"fmt\"\n\t\"log\"", "finished": false, "index": 2}
data: {"content": "", "finished": true, "totalTokens": 1456, "processingTime": "3.2s"}
Endpoint: POST /api/v1/generate/batch
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 '.'
Respuesta:
{
"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
}
Endpoint: POST /api/v1/generate/batch/stream
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"}
]
}'
Listar Modelos Disponibles:
curl http://localhost:8090/api/v1/models | jq '.'
Estado del Sistema:
curl http://localhost:8090/api/v1/status | jq '.'
Estadísticas del Worker Pool:
curl http://localhost:8090/api/v1/pool/stats | jq '.'
Health Check:
curl http://localhost:8090/health | jq '.'
Métricas de Prometheus:
curl http://localhost:8090/metrics
Definición del Servicio:
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);
}
Ejemplos con grpcurl:
# 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
Conexión y Uso:
// 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);
};
Ejemplo con Node.js:
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
: application/json"
-d '{
"prompt": "Test de carga",
"model": "gpt-4o",
"provider": "azure",
"maxTokens": 50
}'
http://localhost:8090/api/v1/generate
hey -n 1000 -c 50 -m POST
-H "Content-Type: application/json"
-d '{
"prompt": "Performance test",
"model": "claude-3-haiku",
"provider": "aws",
"maxTokens": 100
}'
http://localhost:8090/api/v1/generate
hey -n 50 -c 5 -m POST
-H "Content-Type: application/json"
-H "Accept: text/event-stream"
-d '{
"prompt": "Streaming test",
"model": "gpt-4o",
"maxTokens": 200
}'
http://localhost:8090/api/v1/generate/stream
hey -n 20 -c 2 -m POST
-H "Content-Type: application/json"
-d '{
"requests": [
{"prompt": "Test 1", "model": "gpt-4o", "maxTokens": 50},
{"prompt": "Test 2", "model": "claude-3-sonnet", "maxTokens": 50},
{"prompt": "Test 3", "model": "gpt-4.1", "maxTokens": 50}
]
}'
http://localhost:8090/api/v1/generate/batch
### 8️⃣ Scripts de Testing Automatizado
El proyecto incluye scripts de testing completos:
```bash
# Test del Worker Pool y procesamiento en batch
./scripts/test-batch-processing.sh
# Test del sistema de gestión de sesiones
./scripts/test-session-management.sh
# Test de todos los endpoints
./examples/test-all-endpoints.sh
# Benchmarks en tiempo real
go run scripts/realtime-benchmark-server.go
DeepSeek R1 (Razonamiento Avanzado):
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 '.'
Grok-3 (Con Personalidad):
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 '.'
Llama 3.3 70B (Open Source):
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 Optimizado:
# 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
Desarrollo:
# 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
Producción:
# 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
Despliegue Paso a Paso:
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
Comandos Útiles de Kubernetes:
# 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'
Métricas Principales:
mcp_requests_total{method, status, provider, model} - Total de requestsmcp_request_duration_seconds{method, provider, model} - Latencia de requestsmcp_tokens_used_total{provider, model} - Tokens consumidosmcp_cache_hits_total - Hits de cachemcp_cache_misses_total - Misses de cachemcp_errors_total{type, provider} - Total de erroresmcp_worker_pool_active_workers - Workers activosmcp_worker_pool_queue_size - Tamaño de colamcp_worker_pool_processed_total - Jobs procesadosmcp_sessions_active - Sesiones activasmcp_sessions_total - Total de sesionesConsultas Útiles:
# 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
Acceso a Grafana:
# Docker Compose
http://localhost:3000
# Usuario: admin, Password: admin
# Kubernetes con port-forward
kubectl port-forward service/grafana-service 3000:3000 -n mcp-server
Dashboards Incluidos:
Configuración de Logs:
# 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")'
Estructura de Logs:
{
"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
Worker Pool Avanzado:
sync.PoolCache Inteligente:
Optimizaciones de Red:
Optimizaciones de Memoria:
Contenedores Seguros:
Kubernetes Security:
API Security:
Monitoreo de Seguridad:
GitHub Actions Security:
# .github/workflows/security.yml incluye:
- CodeQL Analysis (SAST)
- Dependency Review
- Secret Scanning
- Container Vulnerability Scanning
- Kubernetes Security Scanning
- OWASP ZAP (DAST)
- License Compliance
Herramientas Integradas:
MCP-SERVER-AI/
├── .github/
│ └── workflows/ # CI/CD pipelines
│ ├── ci-cd.yml # Pipeline principal
│ └── security.yml # Pipeline de seguridad
├── cmd/
│ └── server/
│ └── main.go # Entry point principal
├── internal/
│ ├── ai/ # Proveedores de IA
│ │ ├── manager.go # Gestor principal
│ │ ├── aws_provider.go # AWS Bedrock
│ │ ├── azure_provider.go # Azure OpenAI
│ │ └── parallel_processor.go # Procesamiento paralelo
│ ├── cache/
│ │ └── redis.go # Cliente Redis
| | ├── feedback.go # Detecta automáticamente cuando las respuestas cacheadas son problemáticas y las invalida para mejorar la calidad del servicio de forma colaborativa.
│ ├── handlers/
│ │ └── handler.go # HTTP/gRPC/WebSocket handlers
│ ├── pool/
│ │ ├── worker_pool.go # Worker pool implementation
│ │ └── worker_pool_bench_test.go # Benchmarks
│ ├── proto/ # Definiciones gRPC
│ │ ├── ai_service.proto
│ │ ├── ai_service.pb.go
│ │ └── ai_service_grpc.pb.go
│ └── session/
│ └── manager.go # Gestión de sesiones
├── deploy/
│ ├── k8s/ # Manifests Kubernetes
│ │ ├── namespace.yaml
│ │ ├── configmap.yaml
│ │ ├── secret.yaml
│ │ ├── deployment.yaml
│ │ ├── service.yaml
│ │ ├── ingress.yaml
│ │ ├── hpa-pdb.yaml
│ │ ├── rbac.yaml
│ │ ├── postgres.yaml
│ │ ├── redis.yaml
│ │ └── deploy-all.sh # Script de despliegue
├── examples/
│ ├── streaming-SSE-client.html # Cliente SSE
│ ├── websocket-client.html # Cliente WebSocket
│ └── test-all-endpoints.sh # Tests de endpoints
├── scripts/
│ ├── test-batch-processing.sh # Test Worker Pool
│ ├── test-session-management.sh # Test sesiones
│ ├── realtime-benchmark-server.go # Benchmarks
│ ├── run-benchmarks.sh
│ └── start-realtime-benchmarks.sh
├── migrations/ # Migraciones PostgreSQL
│ ├── 0000_keen_devos.sql
│ ├── 0001_sparkling_blue_marvel.sql
│ └── ... (8 migraciones)
├── docker-compose.yml # Desarrollo
├── docker-compose.prod.yml # Producción
├── Dockerfile # Multi-stage build
├── .env.example # Plantilla de configuración
├── DEPLOYMENT.md # Guía de despliegue
└── README.md # Este archivo
Factory Pattern:
// 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)
}
}
Worker Pool Pattern:
// internal/pool/worker_pool.go
type WorkerPool struct {
workers int
jobQueue chan Job
workerPool chan chan Job
quit chan bool
}
Observer Pattern:
// Métricas y logging
type MetricsCollector interface {
RecordRequest(provider, model string, duration time.Duration)
RecordError(provider, errorType string)
RecordTokens(provider, model string, tokens int)
}
1. Implementar la interfaz Provider:
// 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"
}
2. Registrar en el Manager:
// 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
}
3. Actualizar configuración:
# .env
NEW_PROVIDER_API_KEY=tu_api_key
NEW_PROVIDER_ENDPOINT=https://api.newprovider.com
4. Agregar tests:
// internal/ai/new_provider_test.go
func TestNewProvider_Generate(t *testing.T) {
// Tests unitarios
}
Pipeline Principal (.github/workflows/ci-cd.yml):
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
Pipeline de Seguridad (.github/workflows/security.yml):
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: ./
Desarrollo:
developAmbientes:
Este proyecto está licenciado bajo la Licencia MIT. Ver el archivo LICENSE para más detalles.
1. Fork y Clone:
git clone https://github.com/proyectoskevinsvega/mcp-server-ai.git
cd mcp-server-ai
2. Crear Feature Branch:
git checkout -b feature/nueva-funcionalidad
3. Desarrollar y Testear:
# Hacer cambios
go test ./... -v
go fmt ./...
go vet ./...
4. Commit y Push:
git add .
git commit -m "feat: agregar nueva funcionalidad"
git push origin feature/nueva-funcionalidad
5. Crear Pull Request:
Estilo de Código:
gofmt y golintCommits Semánticos:
feat: Nueva funcionalidadfix: Corrección de bugdocs: Documentaciónstyle: Formato de códigorefactor: Refactorizacióntest: Testschore: Tareas de mantenimientoPull Requests:
P: ¿Cómo configuro múltiples proveedores?
R: Configura las variables de entorno para cada proveedor y usa el parámetro provider en las requests.
P: ¿Puedo usar mi propio modelo?
R: Sí, implementa la interfaz Provider y regístralo en el manager.
P: ¿Cómo escalo en producción? R: Usa Kubernetes con HPA configurado o Docker Compose con múltiples réplicas.
P: ¿Soporta modelos locales? R: Actualmente no, pero puedes implementar un proveedor personalizado.
P: ¿Cómo monitoreo el sistema? R: Usa las métricas de Prometheus y dashboards de Grafana incluidos.
v1.1.0:
v1.2.0:
v2.0.0:
🚀 ¿Listo para empezar?
docker-compose up -d
curl http://localhost:8090/health
Hecho con ❤️ para la comunidad de desarrolladores
curl -X POST http://localhost:8090/api/v1/generate/batch
-H "Content-Type: application/json"
-d '{
"requests": [
{
"prompt": "¿capital de venezuela?",
"model": "grok-3",
"provider": "azure",
"system": "Eres un experto en programación. nunca des respuesta que no tengan que ver con programacion"
}
]
}'
curl -X POST http://localhost:8090/api/v1/generate
-H "Content-Type: application/json"
-d '{
"prompt": "¿capital de españa?",
"model": "grok-3",
"provider": "azure",
"systemPrompt": "Eres un experto en programación. nunca des respuesta que no tengan que ver con programacion."
}'
deploy-all.sh/health y /status para monitoringPOST /api/v1/generate - Generación simplePOST /api/v1/generate/stream - Streaming SSEPOST /api/v1/generate/batch - Procesamiento paraleloGET /api/v1/models - Lista de modelos disponiblesGET /api/v1/cache/stats - Estadísticas de cachePOST /api/v1/cache/invalidate - Invalidación manualGET /api/v1/sessions/{sessionId} - Gestión de sesionesGET /health - Health checkGET /status - Estado detalladoGenerate() - Generación simpleGenerateStream() - Streaming bidireccional/ws - Conexión en tiempo realEl sistema ahora proporciona métricas detalladas:
El proyecto MCP-SERVER-AI ha evolucionado de un servidor básico con problemas de compatibilidad a una plataforma empresarial completa que incluye:
El sistema ahora está listo para despliegue en producción y puede manejar cargas empresariales con alta disponibilidad, escalabilidad automática y calidad mejorada continuamente a través del feedback colaborativo de usuarios.
Estado: ✅ COMPLETADO - Todos los objetivos alcanzados exitosamente.
MCP SERVER de AI - conexion mediante HTTP/REST API - gRPC Server - WebSocket - Server-Sent Events (SSE) con proveedores AI de AWS y AZURE
टूल
अभी टूल सूची नहीं है। रिमोट सर्वर को पहले हेल्थ चेक के बाद सूची मिलती है।
FAQ
इस पेज पर Cursor, Claude Desktop, Claude Code या VS Code के लिए stdio कॉन्फ़िग कॉपी करें। यह पब्लिशर का इंस्टॉल इस्तेमाल करता है, PlugMCP प्रॉक्सी नहीं।
इस रिकॉर्ड में कोई ज़रूरी एनवायरनमेंट वेरिएबल दर्ज नहीं है।
MCP Server Ai stdio पर लोकल चलता है।
पिछली जाँच 2026-10-28 को हुई। MCP SERVER de AI - conexion mediante HTTP/REST API - gRPC Server - WebSocket - Server-Sent Events (SSE) con proveedores AI de AWS y AZURE