MelviChat MCP Server

# Control de Costos Gemini en Multi-Tenant

## 1. Control Centralizado de Límites

### Backend con Rate Limiting por Tenant
```python
# backend/api/tenant_ai.py
from slowapi import Limiter
from slowapi.util import get_remote_address

# Límites por plan
PLAN_LIMITS = {
    "basic": 1000,      # 1000 queries/mes
    "professional": 5000, # 5000 queries/mes  
    "enterprise": 20000  # 20000 queries/mes
}

@app.post("/ai/tenant-query")
@limiter.limit("100/minute")  # Global rate limit
async def tenant_query(
    request: QueryRequest,
    tenant_id: str = Header(...),
    db: Session = Depends(get_db)
):
    # 1. Verificar límite del tenant
    tenant = db.query(Company).filter(Company.id == tenant_id).first()
    monthly_usage = get_monthly_usage(tenant_id)
    
    if monthly_usage >= PLAN_LIMITS[tenant.plan_type]:
        raise HTTPException(429, "Límite mensual excedido")
    
    # 2. Registrar uso antes de llamar a Gemini
    log_usage(tenant_id, request.prompt)
    
    # 3. Llamar a Gemini (una sola vez)
    result = call_gemini_api(request.prompt)
    
    return {"data": result, "usage": monthly_usage + 1}
```

## 2. Optimización de Cache por Tenant

```python
# Cache inteligente para reducir llamadas a Gemini
from functools import lru_cache
import hashlib

@lru_cache(maxsize=1000)
def cached_gemini_response(prompt_hash: str, tenant_id: str):
    """Cache responses por tenant para evitar llamadas duplicadas"""
    pass

async def tenant_query_with_cache(prompt: str, tenant_id: str):
    prompt_hash = hashlib.md5(prompt.encode()).hexdigest()
    
    # Revisar cache específico del tenant
    cached = cached_gemini_response(prompt_hash, tenant_id)
    if cached:
        return cached
    
    # Si no está en cache, llamar a Gemini
    result = await call_gemini_api(prompt)
    cached_gemini_response(prompt_hash, tenant_id) = result
    return result
```

## 3. Monitoreo y Alertas

```python
# Dashboard de consumo por tenant
@app.get("/admin/usage-stats")
async def usage_stats():
    return {
        "total_monthly_usage": get_total_usage(),
        "by_tenant": {
            "tenant_A": {"usage": 850, "limit": 1000, "percentage": 85},
            "tenant_B": {"usage": 450, "limit": 500, "percentage": 90},
            "tenant_C": {"usage": 1500, "limit": 2000, "percentage": 75}
        },
        "gemini_cost_estimate": calculate_gemini_cost()
    }
```

## 4. Estrategias de Optimización

### A. Batch Processing
```python
# Agrupar múltiples queries similares
async def batch_tenant_queries(queries: List[str], tenant_id: str):
    """Procesar múltiples queries en una sola llamada a Gemini"""
    combined_prompt = f"""
    Analiza estas preguntas sobre la misma base de datos:
    {chr(10).join(queries)}
    
    Responde cada pregunta por separado.
    """
    return await call_gemini_api(combined_prompt)
```

### B. Smart Caching
```python
# Cache por tipo de pregunta comunes
COMMON_QUERIES = {
    "count_users": "SELECT COUNT(*) FROM users",
    "recent_sales": "SELECT * FROM sales ORDER BY date DESC LIMIT 10",
    "top_products": "SELECT product, COUNT(*) as sales FROM orders GROUP BY product ORDER BY sales DESC"
}

async def smart_cached_query(prompt: str, tenant_id: str):
    # Detectar si es una query común
    for query_type, sql in COMMON_QUERIES.items():
        if query_type in prompt.lower():
            return execute_direct_sql(sql, tenant_id)
    
    # Si no es común, usar Gemini
    return await call_gemini_api(prompt)
```

## 5. Comparación de Costos

### Modelo Individual (Problema):
- ❌ Sin control centralizado
- ❌ Cada tenant puede usar ilimitadamente
- ❌ Difícil de monitorear
- ❌ Sin optimización global

### Modelo Multi-Tenant (Solución):
- ✅ Control centralizado de límites
- ✅ Cache compartido optimizado
- ✅ Monitoreo en tiempo real
- ✅ Batch processing para reducir llamadas
- ✅ Alertas automáticas

## 6. Ejemplo Práctico de Ahorro

```
Escenario: 10 empresas, 1000 queries cada una

Modelo Individual:
- 10,000 llamadas a Gemini = $100 USD

Modelo Multi-Tenant con Cache:
- 3,000 llamadas únicas + 7,000 cache hits = $30 USD
- Ahorro: 70%
```

## Conclusión

✅ **El consumo es el mismo o MENOR** con multi-tenant
✅ **Tienes CONTROL TOTAL** del uso por tenant  
✅ **Puedes OPTIMIZAR** con cache y batching
✅ **Puedes FACTURAR** basado en uso real
✅ **Puedes LIMITAR** abusos fácilmente

**Multi-tenant te da MÁS control sobre costos, no menos.**