# LiteLLM AI Gateway

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.

{% hint style="success" %}
Todos los ejemplos se pueden ejecutar en servidores GPU alquilados a través de [CLORE.AI Marketplace](https://clore.ai/marketplace).
{% endhint %}

## 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) |

{% hint style="info" %}
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.
{% endhint %}

## 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](https://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

```bash
ssh -p <PORT> root@<SERVER_IP>
```

### 3. Cree un Archivo de Configuración

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

```bash
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:**

```bash
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:

```bash
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):**

```bash
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

```bash
# 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

```bash
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

```python
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)

```python
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:

```yaml
# 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:

```bash
# 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:

```bash
# 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

```yaml
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é

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

### Limitación de Tasa

```yaml
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é:

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

### 2. Use Solicitudes Asíncronas

```python
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:

```yaml
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

```yaml
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`:

```bash
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:

```bash
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

```bash
# 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:

```yaml
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                |

{% hint style="info" %}
**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.
{% endhint %}

***

## Enlaces

* [GitHub](https://github.com/BerriAI/litellm)
* [Documentación](https://docs.litellm.ai)
* [Docker Hub / GHCR](https://github.com/BerriAI/litellm/pkgs/container/litellm)
* [Proveedores compatibles](https://docs.litellm.ai/docs/providers)
* [CLORE.AI Marketplace](https://clore.ai/marketplace)


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-es/modelos-de-lenguaje/litellm.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.