> ## Documentation Index
> Fetch the complete documentation index at: https://docs.aihubmix.com/llms.txt
> Use this file to discover all available pages before exploring further.
# LiteLLM
## Descripción general de LiteLLM
LiteLLM es un **gateway unificado de IA** de código abierto desarrollado por [BerriAI](https://github.com/BerriAI/litellm). Proporciona una única interfaz estandarizada para llamar a casi todos los principales LLM del mercado. Repositorio: [https://github.com/BerriAI/litellm](https://github.com/BerriAI/litellm)
Cada proveedor de LLM publica su propio SDK y formato de API: OpenAI, Anthropic y Google difieren entre sí. Cambiar de modelo o usar varios modelos a la vez significa mantener bases de código separadas. LiteLLM resuelve esto: **escribe una sola vez, cambia un parámetro y llama a cualquier modelo**.
### Dos modos de uso
| Modo | Descripción | Mejor para |
| :----------------- | :-------------------------------------------------- | :------------------------------------------------------- |
| **SDK de Python** | `pip install litellm`, llamada directa en el código | Proyectos personales, prototipado rápido |
| **Servidor proxy** | Gateway de IA desplegable de forma independiente | Uso compartido en equipos, control de acceso empresarial |
### Capacidades principales
* **Formato unificado de OpenAI**: admite más de 100 proveedores, incluyendo OpenAI, Anthropic, Gemini, Bedrock, Azure y más
* **Gestión de claves virtuales**: administra de forma centralizada las claves API de tu equipo sin exponer las originales
* **Seguimiento de costos**: monitoriza el uso de tokens y el gasto por usuario o proyecto
* **Balanceo de carga**: distribución automática del tráfico entre modelos con soporte de failover
* **Alto rendimiento**: latencia P95 de aproximadamente 8 ms a 1000 RPS
***
## Instalación
### Requisitos
Python 3.8+
**macOS**
Instala mediante [Homebrew](https://brew.sh/):
```bash theme={null}
brew install python
```
Verifica:
```bash theme={null}
python3 --version
```
**Windows**
Descarga el instalador desde [python.org/downloads](https://www.python.org/downloads/). Durante la instalación, marca **"Add Python to PATH"**.
Verifica:
```bash theme={null}
python --version
```
**Linux (Ubuntu/Debian)**
```bash theme={null}
sudo apt update
sudo apt install python3 python3-pip
```
### pip
pip suele venir incluido con Python. Verifica que esté disponible:
```bash theme={null}
pip --version
# or
pip3 --version
```
Si no se encuentra, instálalo manualmente:
```bash theme={null}
# Universal method
python3 -m ensurepip --upgrade
# Ubuntu/Debian
sudo apt install python3-pip
# Upgrade to latest
pip install --upgrade pip
```
### Instalar LiteLLM
Una vez que el entorno esté listo:
```bash theme={null}
python3 -m pip install litellm
```
Verifica la instalación:
```bash theme={null}
python3 -m pip show litellm
```
### Dependencias opcionales
Algunos proveedores requieren paquetes adicionales:
```bash theme={null}
# AWS Bedrock
pip install litellm[bedrock]
# Google Vertex AI
pip install litellm[vertex]
# All dependencies (not recommended for production)
pip install litellm[all]
```
### Instalar el servidor proxy
Para desplegar un gateway independiente:
```bash theme={null}
pip install 'litellm[proxy]'
```
### Docker (opcional)
```bash theme={null}
docker pull ghcr.io/berriai/litellm:main-latest
```
> **Recomendación**: usa `pip install litellm` para desarrollo personal; elige Proxy + Docker para despliegues en equipo.
***
## Configurar la clave API y realizar tu primera llamada
### Obtén tu clave API de AiHubMix
Ve al panel de [aihubmix.com](https://aihubmix.com) y crea una clave API.
### Establece la variable de entorno
```bash theme={null}
export AIHUBMIX_API_KEY="your-aihubmix-key"
```
### Primera llamada
```python theme={null}
import os
from litellm import completion
response = completion(
model="openai/gpt-4o-mini",
api_base="https://aihubmix.com/v1",
api_key=os.environ.get("AIHUBMIX_API_KEY"),
messages=[{"role": "user", "content": "Hello, introduce yourself"}]
)
print(response.choices[0].message.content)
```
***
## Uso básico
### 1. Cambiar de modelo
AiHubMix admite todos los modelos principales. Cambiar solo requiere modificar el parámetro `model`:
```python theme={null}
import os
from litellm import completion
response = completion(
model="openai/claude-sonnet-4-6", # change this
api_base="https://aihubmix.com/v1",
api_key=os.environ.get("AIHUBMIX_API_KEY"),
messages=[{"role": "user", "content": "Hello, introduce yourself"}]
)
print(response.choices[0].message.content)
```
***
### 2. Streaming
Añade `stream=True` para recibir la salida token a token:
```python theme={null}
import os
from litellm import completion
response = completion(
model="openai/claude-sonnet-4-6",
api_base="https://aihubmix.com/v1",
api_key=os.environ.get("AIHUBMIX_API_KEY"),
messages=[{"role": "user", "content": "Explain Python in 100 words"}],
stream=True
)
for chunk in response:
print(chunk.choices[0].delta.content or "", end="", flush=True)
print()
```
***
### 3. Conversación multiturno
Pasa el historial de la conversación en la lista `messages` para que el modelo recuerde el contexto:
```python theme={null}
import os
from litellm import completion
messages = [
{"role": "user", "content": "My name is Alex"},
{"role": "assistant", "content": "Hello, Alex!"},
{"role": "user", "content": "What is my name?"}
]
response = completion(
model="openai/claude-sonnet-4-6",
api_base="https://aihubmix.com/v1",
api_key=os.environ.get("AIHUBMIX_API_KEY"),
messages=messages
)
print(response.choices[0].message.content)
```
***
### 4. Llamadas asíncronas
Envía múltiples solicitudes simultáneamente sin esperar a que finalice cada una:
```python theme={null}
import os
import asyncio
from litellm import acompletion
async def ask(question):
response = await acompletion(
model="openai/claude-sonnet-4-6",
api_base="https://aihubmix.com/v1",
api_key=os.environ.get("AIHUBMIX_API_KEY"),
messages=[{"role": "user", "content": question}]
)
return response.choices[0].message.content
async def main():
questions = [
"What color is an apple?",
"What color is the sky?",
"What color is grass?"
]
results = await asyncio.gather(*[ask(q) for q in questions])
for q, r in zip(questions, results):
print(f"Q: {q}")
print(f"A: {r}")
print()
asyncio.run(main())
```
***
### 5. Timeout y reintentos
Evita que las solicitudes se queden colgadas o fallen por problemas de red:
```python theme={null}
import os
from litellm import completion
response = completion(
model="openai/claude-sonnet-4-6",
api_base="https://aihubmix.com/v1",
api_key=os.environ.get("AIHUBMIX_API_KEY"),
messages=[{"role": "user", "content": "Hello"}],
timeout=10, # raise an error after 10 seconds
num_retries=3 # retry up to 3 times on failure
)
print(response.choices[0].message.content)
```
> `timeout` se expresa en segundos. Establece `num_retries` entre 2 y 3; valores más altos ralentizan las respuestas.
***
### 6. Seguimiento del uso de tokens y de costos
Cada respuesta incluye datos de uso de tokens:
```python theme={null}
import os
from litellm import completion
response = completion(
model="openai/claude-sonnet-4-6",
api_base="https://aihubmix.com/v1",
api_key=os.environ.get("AIHUBMIX_API_KEY"),
messages=[{"role": "user", "content": "Explain Python in 100 words"}]
)
print(response.choices[0].message.content)
print()
print("Token usage:")
print(f" Input: {response.usage.prompt_tokens}")
print(f" Output: {response.usage.completion_tokens}")
print(f" Total: {response.usage.total_tokens}")
```
Haz seguimiento del costo por llamada:
```python theme={null}
import os
from litellm import completion, completion_cost
response = completion(
model="openai/claude-sonnet-4-6",
api_base="https://aihubmix.com/v1",
api_key=os.environ.get("AIHUBMIX_API_KEY"),
messages=[{"role": "user", "content": "Explain Python in 100 words"}]
)
cost = completion_cost(completion_response=response)
print(f"Cost: ${cost:.6f}")
```
***
### 7. Balanceo de carga y failover
Configura varios modelos para distribuir automáticamente el tráfico o conmutar a un respaldo cuando uno falla:
```python theme={null}
import os
from litellm import Router
router = Router(
model_list=[
{
"model_name": "my-model",
"litellm_params": {
"model": "openai/claude-sonnet-4-6",
"api_base": "https://aihubmix.com/v1",
"api_key": os.environ.get("AIHUBMIX_API_KEY"),
}
},
{
"model_name": "my-model",
"litellm_params": {
"model": "openai/gpt-4o",
"api_base": "https://aihubmix.com/v1",
"api_key": os.environ.get("AIHUBMIX_API_KEY"),
}
}
]
)
response = router.completion(
model="my-model",
messages=[{"role": "user", "content": "Hello"}]
)
print(response.choices[0].message.content)
```
> Ambos modelos comparten el mismo `model_name`. LiteLLM realiza round-robin entre ellos y conmuta automáticamente si uno devuelve un error.
***
### 8. Desplegar el servidor proxy
El servidor proxy es un gateway independiente. Los miembros del equipo enrutan todas las solicitudes a través de él sin necesidad de sus propias claves API.
**Instalación**
```bash theme={null}
python3 -m pip install 'litellm[proxy]'
```
**Crea config.yaml**
```yaml theme={null}
model_list:
- model_name: gpt-4o
litellm_params:
model: openai/gpt-4o
api_base: https://aihubmix.com/v1
api_key: os.environ/AIHUBMIX_API_KEY
- model_name: claude-sonnet
litellm_params:
model: openai/claude-sonnet-4-6
api_base: https://aihubmix.com/v1
api_key: os.environ/AIHUBMIX_API_KEY
- model_name: gemini-flash
litellm_params:
model: openai/gemini-2.0-flash
api_base: https://aihubmix.com/v1
api_key: os.environ/AIHUBMIX_API_KEY
```
**Inicia el servidor**
```bash theme={null}
litellm --config config.yaml --port 4000
```
Un inicio correcto muestra:
```text theme={null}
LiteLLM: Proxy running on http://0.0.0.0:4000
```
**Llama al servidor local**
```python theme={null}
import os
from litellm import completion
response = completion(
model="gpt-4o",
api_base="http://localhost:4000",
api_key="any-string",
messages=[{"role": "user", "content": "Hello"}]
)
print(response.choices[0].message.content)
```
> La `api_key` aquí puede ser cualquier cadena. La clave real de AiHubMix la gestiona el Proxy.
***
### 9. Gestión de claves virtuales
Las claves virtuales te permiten asignar claves independientes a distintos miembros del equipo o proyectos, controlando el acceso y el uso sin exponer la clave real de AiHubMix.
**Requisitos previos: inicia una instancia de PostgreSQL**
```bash theme={null}
docker run -d \
--name litellm-db \
-e POSTGRES_USER=litellm \
-e POSTGRES_PASSWORD=litellm \
-e POSTGRES_DB=litellm \
-p 5432:5432 \
postgres
```
**Actualiza config.yaml**
```yaml theme={null}
model_list:
- model_name: gpt-4o
litellm_params:
model: openai/gpt-4o
api_base: https://aihubmix.com/v1
api_key: os.environ/AIHUBMIX_API_KEY
- model_name: claude-sonnet
litellm_params:
model: openai/claude-sonnet-4-6
api_base: https://aihubmix.com/v1
api_key: os.environ/AIHUBMIX_API_KEY
general_settings:
master_key: sk-my-master-key
database_url: postgresql://litellm:litellm@localhost:5432/litellm
```
**Reinicia el servidor**
```bash theme={null}
litellm --config config.yaml --port 4000
```
**Crea una clave virtual**
```bash theme={null}
curl -X POST http://localhost:4000/key/generate \
-H "Authorization: Bearer sk-my-master-key" \
-H "Content-Type: application/json" \
-d '{
"key_alias": "team-a",
"max_budget": 10,
"models": ["gpt-4o", "claude-sonnet"]
}'
```
El campo `key` de la respuesta es la clave virtual, por ejemplo `sk-xxxxxx`.
**Usa la clave virtual**
```python theme={null}
from litellm import completion
response = completion(
model="claude-sonnet",
api_base="http://localhost:4000",
api_key="sk-xxxxxx",
messages=[{"role": "user", "content": "Hello"}]
)
print(response.choices[0].message.content)
```
**Consulta el uso**
```bash theme={null}
curl http://localhost:4000/key/info \
-H "Authorization: Bearer sk-my-master-key" \
-H "Content-Type: application/json" \
-d '{"key": "sk-xxxxxx"}'
```
> Cada clave virtual admite restricciones individuales de modelo, límites de presupuesto y tiempos de expiración: ideal para flujos de trabajo en equipos con varios miembros.
***
## Ejemplo práctico: comparación entre varios modelos
Envía la misma pregunta a varios modelos al mismo tiempo y compara la calidad de la salida, la velocidad y el uso de tokens.
**Establecer la clave API**
```bash theme={null}
export AIHUBMIX_API_KEY="your-key"
```
**Ejecuta la comparación**
```python theme={null}
import os
import time
import asyncio
from litellm import acompletion
MODELS = [
"gpt-5.5",
"claude-opus-4-7",
"deepseek-v4-flash",
"coding-glm-5.1-free",
]
QUESTION = "If you could give a programmer only one piece of advice, what would it be?"
async def ask_model(model, question):
start = time.time()
try:
response = await acompletion(
model=f"openai/{model}",
api_base="https://aihubmix.com/v1",
api_key=os.environ.get("AIHUBMIX_API_KEY"),
messages=[{"role": "user", "content": question}]
)
return {
"model": model,
"answer": response.choices[0].message.content.strip(),
"tokens": response.usage.total_tokens,
"time": round(time.time() - start, 2),
"error": None
}
except Exception as e:
return {
"model": model,
"answer": None,
"tokens": 0,
"time": round(time.time() - start, 2),
"error": str(e)
}
async def main():
print(f"Question: {QUESTION}")
print("=" * 60)
tasks = [ask_model(m, QUESTION) for m in MODELS]
results = await asyncio.gather(*tasks)
for r in results:
print(f"\nModel: {r['model']}")
print(f"Time: {r['time']}s | Tokens: {r['tokens']}")
print("-" * 40)
if r["error"]:
print(f"Error: {r['error']}")
else:
print(r["answer"])
print("\n" + "=" * 60)
print(f"{'Model':<30} {'Time':>8} {'Tokens':>8}")
print("-" * 50)
for r in sorted(results, key=lambda x: x["time"]):
status = f"{r['time']}s" if not r["error"] else "failed"
print(f"{r['model']:<30} {status:>8} {r['tokens']:>8}")
asyncio.run(main())
```
Última actualización: 29 de abril de 2026