Pasarela de IA LiteLLM

Despliega LiteLLM como proxy de pasarela de IA para más de 100 LLMs en GPUs de Clore.ai

LiteLLM es una puerta de enlace de IA de código abierto que proporciona una API unificada compatible con OpenAI para más de 100 proveedores de modelos de lenguaje, incluidos OpenAI, Anthropic, Azure, Bedrock, HuggingFace y modelos alojados localmente. Despliega esto en CLORE.AI para enrutar, equilibrar la carga y gestionar todas tus llamadas a la API de LLM a través de un único endpoint con seguimiento de costes integrado, limitación de tasa y lógica de fallback.

El verdadero poder de LiteLLM se ve a escala: los equipos que ejecutan pilas mixtas local+nube pueden intercambiar modelos al vuelo sin tocar el código de la aplicación. Reemplaza gpt-4o con mistral-7b-local en la configuración, reinicia — hecho.

Todos los ejemplos se pueden ejecutar en servidores GPU alquilados a través de Marketplace de CLORE.AI.

Requisitos del servidor

Parámetro	Mínimo	Recomendado
RAM	4 GB	8 GB+
VRAM	N/A (solo proxy)	N/A
Disco	10 GB	20 GB+
GPU	No requerido	Opcional (para modelos locales)

LiteLLM en sí es un proxy basado en CPU y no requiere una GPU. Sin embargo, desplegarlo en un servidor GPU de CLORE.AI tiene sentido cuando quieres ejecutar modelos locales (vía Ollama, TGI, vLLM) junto con LiteLLM como una puerta de enlace unificada en la misma máquina.

Despliegue rápido en CLORE.AI

Imagen de Docker: ghcr.io/berriai/litellm:main-latest

Puertos: 22/tcp, 4000/http

Variables de entorno:

Variable	Ejemplo	Descripción
OPENAI_API_KEY	sk-xxx...	Clave API de OpenAI
ANTHROPIC_API_KEY	sk-ant-xxx...	Clave API de Anthropic
AZURE_API_KEY	xxx...	Clave de Azure OpenAI
LITELLM_MASTER_KEY	sk-my-master-key	Clave maestra de autenticación para el proxy
DATABASE_URL	postgresql://...	PostgreSQL para seguimiento de costes
STORE_MODEL_IN_DB	True	Persistir la configuración del modelo en la base de datos

Configuración paso a paso

1. Alquila un servidor en CLORE.AI

LiteLLM funciona muy bien incluso en servidores solo con CPU. Ve a Marketplace de CLORE.AI y filtra por:

• Servidores CPU de precio más bajo para una configuración de solo proxy

• Servidores GPU (RTX 3090+) si también quieres ejecutar modelos locales

2. Conéctate por SSH a tu servidor

ssh -p <PORT> root@<SERVER_IP>

3. Crea un archivo de configuración

LiteLLM usa un archivo de configuración YAML para definir modelos:

mkdir -p /root/litellm
cat > /root/litellm/config.yaml << 'EOF'
model_list:
  # Modelos de OpenAI
  - model_name: gpt-4o
    litellm_params:
      model: openai/gpt-4o
      api_key: "os.environ/OPENAI_API_KEY"

  - model_name: gpt-4o-mini
    litellm_params:
      model: openai/gpt-4o-mini
      api_key: "os.environ/OPENAI_API_KEY"

  # Modelos de Anthropic
  - model_name: claude-3-5-sonnet
    litellm_params:
      model: anthropic/claude-3-5-sonnet-20241022
      api_key: "os.environ/ANTHROPIC_API_KEY"

  # Balanceador de carga: enrutar a múltiples endpoints
  - model_name: mistral-7b-local
    litellm_params:
      model: openai/mistralai/Mistral-7B-Instruct-v0.3
      api_base: "http://localhost:8080/v1"
      api_key: "none"

  # Balanceador de carga: enrutar a múltiples endpoints
  - model_name: fast-model
    litellm_params:
      model: openai/gpt-4o-mini
      api_key: "os.environ/OPENAI_API_KEY"
    model_info:
      mode: chat

litellm_settings:
  drop_params: True
  set_verbose: False
  num_retries: 3
  request_timeout: 60

general_settings:
  master_key: "sk-my-secret-master-key"  # ¡Cámbialo!
  alerting: []
EOF

4. Inicia LiteLLM

Inicio básico:

docker run -d \\
  --name litellm \
  --network host \
  -v /root/litellm/config.yaml:/app/config.yaml \
  -e OPENAI_API_KEY=sk-your-openai-key \
  -e ANTHROPIC_API_KEY=sk-ant-your-anthropic-key \
  -e LITELLM_MASTER_KEY=sk-my-secret-master-key \
  ghcr.io/berriai/litellm:main-latest \
  --config /app/config.yaml \
  --port 4000 \
  --host 0.0.0.0

Con PostgreSQL para seguimiento de costes:

Primero, inicia un contenedor de PostgreSQL:

docker run -d \\
  --name postgres \
  -e POSTGRES_PASSWORD=litellm_pass \
  -e POSTGRES_DB=litellm \
  -p 5432:5432 \
  postgres:15

# Luego inicia LiteLLM con la base de datos
docker run -d \\
  --name litellm \
  -p 4000:4000 \
  -v /root/litellm/config.yaml:/app/config.yaml \
  -e OPENAI_API_KEY=sk-your-openai-key \
  -e ANTHROPIC_API_KEY=sk-ant-your-anthropic-key \
  -e LITELLM_MASTER_KEY=sk-my-secret-master-key \
  -e DATABASE_URL="postgresql://postgres:litellm_pass@localhost:5432/litellm" \
  --network host \
  ghcr.io/berriai/litellm:main-latest \
  --config /app/config.yaml \
  --port 4000 \
  --host 0.0.0.0

Usando Docker Compose (recomendado):

cat > /root/litellm/docker-compose.yml << 'EOF'
version: "3.8"
services:
  litellm:
    image: ghcr.io/berriai/litellm:main-latest
    ports:
      - "4000:4000"
    volumes:
      - ./config.yaml:/app/config.yaml
    environment:
      - OPENAI_API_KEY=${OPENAI_API_KEY}
      - ANTHROPIC_API_KEY=${ANTHROPIC_API_KEY}
      - LITELLM_MASTER_KEY=sk-my-secret-master-key
      - DATABASE_URL=postgresql://postgres:litellm_pass@db:5432/litellm
    command: --config /app/config.yaml --port 4000 --host 0.0.0.0
    depends_on:
      - db

  db:
    image: postgres:15
    environment:
      POSTGRES_PASSWORD: litellm_pass
      POSTGRES_DB: litellm
    volumes:
      - postgres_data:/var/lib/postgresql/data

volumes:
  postgres_data:
EOF

cd /root/litellm && docker compose up -d

5. Verifica el servidor

# Comprobar el estado
curl http://localhost:4000/health

# Lista los modelos disponibles
curl http://localhost:4000/v1/models \
  -H "Authorization: Bearer sk-my-secret-master-key"

6. Accede mediante el proxy HTTP de CLORE.AI

Tu URL http_pub de CLORE.AI para el puerto 4000:

https://<order-id>-4000.clore.ai/v1

Úsalo como tu api_base en cualquier cliente compatible con OpenAI.

---

Ejemplos de uso

Ejemplo 1: llamada directa a la API a través del proxy

curl http://localhost:4000/v1/chat/completions \
  -X POST \
  -H "Content-Type: application/json" \\
  -H "Authorization: Bearer sk-my-secret-master-key" \
  -d '{
    "model": "gpt-4o-mini",
    "messages": [
      {"role": "user", "content": "¿Cuál es la capital de Alemania?"}
    ]
  }'

Ejemplo 2: SDK de Python de OpenAI con el proxy LiteLLM

from openai import OpenAI

# Solo cambia base_url y api_key — todo lo demás es idéntico
client = OpenAI(
    base_url="http://localhost:4000/v1",
    api_key="sk-my-secret-master-key",
)

# Usa cualquier modelo de tu configuración
response = client.chat.completions.create(
    model="gpt-4o-mini",  # o "claude-3-5-sonnet", "mistral-7b-local"
    messages=[{"role": "user", "content": "Resume los beneficios de la computación con GPU."}],
)
print(response.choices[0].message.content)

# Cambia de modelo sin ningún cambio de código
response2 = client.chat.completions.create(
    model="claude-3-5-sonnet",
    messages=[{"role": "user", "content": "La misma pregunta, un modelo diferente."}],
)
print(response2.choices[0].message.content)

Ejemplo 3: SDK de Python de LiteLLM (directo)

import litellm

# Úsalo directamente sin proxy
response = litellm.completion(
    model="gpt-4o-mini",
    messages=[{"role": "user", "content": "¡Hola!"}],
    api_key="your-openai-key",
)

# O enrútalo a través de tu proxy
response = litellm.completion(
    model="openai/gpt-4o-mini",
    messages=[{"role": "user", "content": "¡Hola!"}],
    api_base="http://localhost:4000",
    api_key="sk-my-secret-master-key",
)

Ejemplo 4: Configuración de fallback

Configura fallbacks automáticos entre modelos:

# En config.yaml
model_list:
  - model_name: smart-fallback
    litellm_params:
      model: gpt-4o
      api_key: "os.environ/OPENAI_API_KEY"

router_settings:
  routing_strategy: least-busy
  model_group_alias:
    "gpt-4-fallback":
      - "gpt-4o"
      - "claude-3-5-sonnet"
      - "mistral-7b-local"
  num_retries: 3
  fallbacks:
    - gpt-4o:
        - claude-3-5-sonnet
        - mistral-7b-local

Ejemplo 5: Panel de seguimiento de costes

Después de habilitar PostgreSQL, accede al análisis del gasto:

# Obtener gasto por usuario
curl http://localhost:4000/global/spend/users \
  -H "Authorization: Bearer sk-my-secret-master-key"

# Obtener gasto por modelo
curl http://localhost:4000/global/spend/models \
  -H "Authorization: Bearer sk-my-secret-master-key"

# Generar informe de gasto
curl "http://localhost:4000/global/spend?start_date=2024-01-01&end_date=2024-12-31" \
  -H "Authorization: Bearer sk-my-secret-master-key"

---

Configuración

Claves virtuales (claves API por usuario)

Crea claves separadas con límites de tasa y presupuestos:

# Crear una clave con presupuesto
curl http://localhost:4000/key/generate \
  -X POST \
  -H "Content-Type: application/json" \\
  -H "Authorization: Bearer sk-my-secret-master-key" \
  -d '{
    "models": ["gpt-4o-mini", "claude-3-5-sonnet"],
    "duration": "30d",
    "max_budget": 10.0,
    "metadata": {"user_id": "user_123"}
  }'

Balanceo de carga

model_list:
  # Round-robin entre varias claves API de OpenAI
  - model_name: gpt-4o
    litellm_params:
      model: openai/gpt-4o
      api_key: sk-key-1
  - model_name: gpt-4o
    litellm_params:
      model: openai/gpt-4o
      api_key: sk-key-2

router_settings:
  routing_strategy: least-busy  # o: simple-shuffle, latency-based-routing

Caché

litellm_settings:
  cache: True
  cache_params:
    type: redis
    host: localhost
    port: 6379
    ttl: 3600  # 1 hora

Limitación de tasa

general_settings:
  default_team_settings:
    tpm_limit: 100000   # tokens por minuto
    rpm_limit: 1000     # solicitudes por minuto

---

Consejos de rendimiento

1. Habilita la caché para prompts repetidos

Para aplicaciones RAG o chatbots con preguntas comunes, la caché de Redis reduce los costes entre un 30 y un 70 % y baja la latencia P50 a <5 ms en aciertos de caché:

litellm_settings:
  cache: True
  cache_params:
    type: redis
    host: localhost
    port: 6379

2. Usa solicitudes asíncronas

import asyncio
import litellm

async def batch_complete(prompts):
    tasks = [
        litellm.acompletion(
            model="gpt-4o-mini",
            messages=[{"role": "user", "content": p}],
        )
        for p in prompts
    ]
    return await asyncio.gather(*tasks)

results = asyncio.run(batch_complete(["Hello", "World", "Test"]))

3. Enrutamiento de modelos locales

Envía solicitudes baratas o sencillas a modelos locales en GPUs de Clore.ai, y las complejas a GPT-4:

model_list:
  - model_name: smart-router
    litellm_params:
      model: openai/gpt-4o
      api_key: "os.environ/OPENAI_API_KEY"

Una configuración típica: ejecutar Mistral 7B o Llama 3 8B localmente en una RTX 3090 de Clore.ai ($0.07–0.21/h), gestionar allí el 80% del tráfico y escalar tareas complejas a GPT-4o. Son comunes ahorros de coste de 3–5× frente a solo nube.

4. Establece tiempos de espera y reintentos

litellm_settings:
  request_timeout: 30
  num_retries: 3
  retry_after: 5

---

Recomendaciones de GPU para Clore.ai

LiteLLM en sí no necesita GPU — es un proxy. La elección de la GPU solo importa cuando despliegas inferencia local junto a él.

Modelo local	GPU	Por qué
Mistral 7B / Llama 3 8B (bf16)	RTX 3090 24 GB	Cabe cómodamente, rendimiento de ~200 tok/s
Mixtral 8×7B o Llama 3 70B (AWQ)	RTX 4090 24 GB	Ancho de banda de memoria más rápido que la 3090; cabe 70B AWQ de 4 bits
Llama 3 70B (bf16) o servicio de múltiples modelos	A100 80 GB	Ejecuta varios modelos 7–13B simultáneamente; HBM2e para baja latencia

Pila recomendada para un desarrollador independiente: RTX 3090 + Mistral 7B + puerta de enlace LiteLLM. Coste total en Clore.ai: $0.07–0.21/h. Gestiona ~50 req/min con facilidad, con fallback a GPT-4o para tareas complejas.

Pila de equipo / producción: A100 80GB, ejecuta Llama 3 70B + LiteLLM + PostgreSQL. Atiende a más de 20 usuarios concurrentes, seguimiento completo de costes y gasto en LLM de la nube nulo para la mayoría de las solicitudes.

---

Solución de problemas

Problema: "model not found"

Asegúrate de que el nombre del modelo en tu solicitud coincida exactamente con lo que hay en config.yaml:

curl http://localhost:4000/v1/models -H "Authorization: Bearer sk-my-secret-master-key"

Problema: "authentication failed"

Comprueba tu LITELLM_MASTER_KEY variable de entorno y úsala como token Bearer.

Problema: los cambios de configuración no se reflejan

Reinicia el contenedor después de los cambios de configuración:

docker restart litellm

Problema: alta latencia en la primera solicitud

LiteLLM carga las configuraciones del modelo al iniciarse. Las primeras solicitudes pueden ser más lentas mientras se establecen las conexiones.

Problema: errores de conexión a la base de datos

# Comprueba que PostgreSQL se esté ejecutando
docker logs postgres

# Verifica el formato de la cadena de conexión
DATABASE_URL="postgresql://user:password@host:5432/dbname"

Problema: errores 429 de limitación de tasa de los proveedores

Configura fallbacks:

litellm_settings:
  num_retries: 5
  fallbacks:
    - gpt-4o: [claude-3-5-sonnet]

---

Recomendaciones de GPU para Clore.ai

LiteLLM es una puerta de enlace/proxy de API — no realiza inferencia por sí mismo. La elección de la GPU depende de si estás enrutando a APIs en la nube o a modelos locales.

Configuración	GPU	Precio de Clore.ai	Caso de uso
Solo proxy de API en la nube	Solo CPU	~$0.02/hr	Enruta a OpenAI, Anthropic, Gemini — no se necesita GPU
Backend local de vLLM	RTX 3090 (24GB)	$0.07–0.21/h	Modelos autoalojados 7B–13B con LiteLLM como frontend
Backend local de vLLM	RTX 4090 (24GB)	$0.14–0.42/h	Modelos locales 7B–34B de mayor rendimiento
Backend local de vLLM	A100 40GB	bare metal	Modelos 70B, servicio local para producción

Configuración más común: Ejecuta LiteLLM como un proxy unificado delante de tus instancias vLLM/Ollama alojadas en Clore.ai. Esto te da fallbacks de proveedor, limitación de tasa, seguimiento de costes y enrutamiento compatible con OpenAI — manteniendo toda la inferencia local y barata.

Ejemplo de coste: Ejecuta el proxy LiteLLM en una instancia solo CPU ($0.07–0.21/h) y apúntalo a un servidor vLLM en una RTX 3090 ($0.07–0.21/h). Coste total de $0.07–0.21/h para una API de LLM autoalojada y lista para producción con fallbacks, registro y limitación de tasa.

---

Enlaces

• GitHub

• Documentación

• Docker Hub / GHCR

• Proveedores compatibles

• Marketplace de CLORE.AI