> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-es/modelos-de-lenguaje/litellm.md).

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

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

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

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

## 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](https://clore.ai/marketplace) 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

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

### 3. Crea 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"

  # 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:**

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

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

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

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

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

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

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

```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, accede al análisis del gasto:

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

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

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

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

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

### 2. Usa 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 de modelos locales

Envía solicitudes baratas o sencillas a modelos locales en GPUs de Clore.ai, y 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: 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

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

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

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

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

```yaml
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](https://clore.ai/bare-metal) | Modelos 70B, servicio local para producción             |

{% hint style="info" %}
**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.
{% 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)
* [Marketplace de CLORE.AI](https://clore.ai/marketplace)


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## 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, and the optional `goal` query parameter:

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

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.