LiteLLM AI Gateway

Despliega LiteLLM como proxy de AI Gateway para más de 100 LLMs en las GPU de Clore.ai

LiteLLM es una pasarela 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. Despliegue en CLORE.AI para enrutar, balancear carga y gestionar todas sus 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 respaldo.

El verdadero poder de LiteLLM aparece a escala: equipos que ejecutan pilas mixtas local+cloud pueden cambiar modelos en caliente sin tocar el código de la aplicación. Reemplace gpt-4o con mistral-7b-local en la configuración, reinicie — listo.

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

Requisitos del servidor

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

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

Despliegue rápido en CLORE.AI

Imagen 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-mi-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 BD

Configuración paso a paso

1. Alquile un Servidor en CLORE.AI

LiteLLM funciona muy bien incluso en servidores solo CPU. Vaya a CLORE.AI Marketplace y filtre por:

• Servidores CPU de menor precio para una configuración de proxy puro

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

2. Conéctate por SSH a tu servidor

ssh -p <PORT> root@<SERVER_IP>

3. Cree 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"

  # Modelo local vía TGI (en el mismo servidor, puerto 8080)
  - 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-mi-secreto-master-key"  # ¡Cámbielo!
  alerting: []
EOF

4. Inicie LiteLLM

Lanzamiento básico:

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

Con PostgreSQL para el seguimiento de costes:

Primero, inicie un contenedor PostgreSQL:

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

# Luego lance LiteLLM con BD
docker run -d \
  --name litellm \
  -p 4000:4000 \
  -v /root/litellm/config.yaml:/app/config.yaml \
  -e OPENAI_API_KEY=sk-su-clave-openai \
  -e ANTHROPIC_API_KEY=sk-ant-su-clave-anthropic \
  -e LITELLM_MASTER_KEY=sk-mi-secreto-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-mi-secreto-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. Verifique el Servidor

# Comprobar estado de salud
curl http://localhost:4000/health

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

6. Acceso vía Proxy HTTP de CLORE.AI

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

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

Use esto como su api_base en cualquier cliente compatible con OpenAI.

---

Ejemplos de uso

Ejemplo 1: Llamada API directa vía Proxy

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

Ejemplo 2: SDK de OpenAI en Python con el Proxy LiteLLM

from openai import OpenAI

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

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

# Cambie de modelo sin modificar el código
response2 = client.chat.completions.create(
    model="claude-3-5-sonnet",
    messages=[{"role": "user", "content": "Misma pregunta, modelo diferente."}],
)
print(response2.choices[0].message.content)

Ejemplo 3: SDK de Python de LiteLLM (Directo)

import litellm

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

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

Ejemplo 4: Configuración de Respaldo (Fallback)

Configure retrocesos 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, acceda a la analítica de gastos:

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

# Obtener gasto por modelo
curl http://localhost:4000/global/spend/models \
  -H "Authorization: Bearer sk-mi-secreto-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-mi-secreto-master-key"

---

Configuración

Claves Virtuales (Claves API por Usuario)

Cree 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-mi-secreto-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 múltiples 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. Habilite Caché para Prompts Repetidos

Para aplicaciones RAG o chatbots con preguntas comunes, el caché de Redis reduce costes entre 30–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. Use 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 a Modelos Locales

Enrute solicitudes baratas/simples a modelos locales en GPUs de Clore.ai, 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: ejecute Mistral 7B o Llama 3 8B localmente en una RTX 3090 de Clore.ai ($0.10–0.15/h), maneje allí el 80% del tráfico y escale tareas complejas a GPT-4o. Los ahorros de coste de 3–5× frente a solo nube son comunes.

4. Establezca Timeouts y Reintentos

litellm_settings:
  request_timeout: 30
  num_retries: 3
  retry_after: 5

---

Recomendaciones de GPU en Clore.ai

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

Modelo Local	GPU	Por qué
Mistral 7B / Llama 3 8B (bf16)	RTX 3090 24 GB	Cabe cómodamente, ~200 tok/s de rendimiento
Mixtral 8×7B o Llama 3 70B (AWQ)	RTX 4090 24 GB	Mayor ancho de banda de memoria que la 3090; cabe 70B AWQ 4-bit
Llama 3 70B (bf16) o servicio multi-modelo	A100 80 GB	Ejecute múltiples modelos de 7–13B simultáneamente; HBM2e para baja latencia

Pila recomendada para un desarrollador en solitario: RTX 3090 + Mistral 7B + pasarela LiteLLM. Coste total en Clore.ai: ~0.12 $/h. Maneja ~50 req/min fácilmente, con fallback a GPT-4o para tareas complejas.

Pila para equipo/producción: A100 80GB, ejecute Llama 3 70B + LiteLLM + PostgreSQL. Sirve a 20+ usuarios concurrentes, seguimiento de costes completo, gasto en LLMs en la nube nulo para la mayoría de solicitudes.

---

Solución de problemas

Problema: "modelo no encontrado"

Asegúrese de que el nombre del modelo en su solicitud coincida exactamente con lo que está en config.yaml:

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

Problema: "autenticación fallida"

Verifique su LITELLM_MASTER_KEY variable de entorno y úsela como el token Bearer.

Problema: Los cambios de configuración no se reflejan

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

docker restart litellm

Problema: Alta latencia en la primera solicitud

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

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

# Verifique que PostgreSQL está en ejecución
docker logs postgres

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

Problema: Errores 429 de límite de tasa desde los proveedores

Configure respaldos:

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

---

Recomendaciones de GPU en Clore.ai

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

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

Configuración más común: Ejecute LiteLLM como un proxy unificado frente a sus instancias vLLM/Ollama alojadas en Clore.ai. Esto le ofrece respaldos de proveedores, limitación de tasa, seguimiento de costes y enrutamiento compatible con OpenAI — manteniendo toda la inferencia local y barata.

Ejemplo de coste: Ejecute el proxy LiteLLM en una instancia solo CPU (0.02 $/h) y apúntelo a un servidor vLLM en RTX 3090 (0.12 $/h). Coste total ~0.14 $/h para una API LLM autoalojada y lista para producción con respaldos, registro y limitación de tasa.

---

Enlaces

• GitHub

• Documentación

• Docker Hub / GHCR

• Proveedores compatibles

• CLORE.AI Marketplace