AiHubMix Documentation Hub

Descripción general de LiteLLM

LiteLLM es un gateway unificado de IA de código abierto desarrollado por BerriAI. Proporciona una única interfaz estandarizada para llamar a casi todos los principales LLM del mercado. Repositorio: 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:

brew install python

Verifica:

python3 --version

Windows Descarga el instalador desde python.org/downloads. Durante la instalación, marca “Add Python to PATH”. Verifica:

python --version

Linux (Ubuntu/Debian)

sudo apt update
sudo apt install python3 python3-pip

pip

pip suele venir incluido con Python. Verifica que esté disponible:

pip --version
# or
pip3 --version

Si no se encuentra, instálalo manualmente:

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

python3 -m pip install litellm

Verifica la instalación:

python3 -m pip show litellm

Dependencias opcionales

Algunos proveedores requieren paquetes adicionales:

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

pip install 'litellm[proxy]'

Docker (opcional)

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 y crea una clave API.

Establece la variable de entorno

export AIHUBMIX_API_KEY="your-aihubmix-key"

Primera llamada

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:

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:

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:

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:

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:

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:

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:

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:

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

python3 -m pip install 'litellm[proxy]'

Crea config.yaml

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

litellm --config config.yaml --port 4000

Un inicio correcto muestra:

LiteLLM: Proxy running on http://0.0.0.0:4000

Llama al servidor local

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

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

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

litellm --config config.yaml --port 4000

Crea una clave virtual

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

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

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

export AIHUBMIX_API_KEY="your-key"

Ejecuta la comparación

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

Documentation Index

​Descripción general de LiteLLM

​Dos modos de uso

​Capacidades principales

​Instalación

​Requisitos

​pip

​Instalar LiteLLM

​Dependencias opcionales

​Instalar el servidor proxy

​Docker (opcional)

​Configurar la clave API y realizar tu primera llamada

​Obtén tu clave API de AiHubMix

​Establece la variable de entorno

​Primera llamada

​Uso básico

​1. Cambiar de modelo

​2. Streaming

​3. Conversación multiturno

​4. Llamadas asíncronas

​5. Timeout y reintentos

​6. Seguimiento del uso de tokens y de costos

​7. Balanceo de carga y failover

​8. Desplegar el servidor proxy

​9. Gestión de claves virtuales

​Ejemplo práctico: comparación entre varios modelos