LiteLLM: Una guía con ejemplos prácticos

Cambiar entre diferentes proveedores de LLM no debería requerir reescribir todo tu código base. Pero eso es precisamente lo que ocurre cuando trabajas con múltiples servicios de IA hoy en día. Cada proveedor tiene su propio SDK, método de autenticación y formato de respuesta. LiteLLM soluciona este problema con una interfaz unificada.

En este tutorial, explicaré las partes principales de LiteLLM y mostraré cómo empezar con llamadas API básicas y avanzar hasta respuestas en streaming, salidas estructuradas y seguimiento de costes.

¿Qué es LiteLLM?

LiteLLM es una biblioteca Python de código abierto que funciona como traductor universal para modelos de IA. En lugar de aprender diferentes API para cada proveedor, utilizas una única interfaz que se conecta a más de 100 servicios LLM.

El marco consta de dos partes principales. El SDK de Python te permite escribir código una sola vez y ejecutarlo con cualquier proveedor. El servidor proxy actúa como puerta de enlace central para equipos y empresas que necesitan gestionar servicios de IA a gran escala.

LiteLLM te ofrece estas ventajas adicionales:

• Seguimiento de costes integrado: Consulta el gasto de todos los proveedores en un solo panel, en lugar de tener que comprobar varios sistemas de facturación.
• Conmutaciones automáticas por error: Cuando un proveedor deja de funcionar o alcanza los límites de velocidad, LiteLLM prueba automáticamente tus opciones de respaldo.
• Opción de autoalojamiento: Ejecuta todo en tus propios servidores si necesitas privacidad de datos o cumplimiento normativo.

Ten en cuenta que OpenRouter ofrece un acceso unificado similar a múltiples LLM, aunque con diferentes precios y conjuntos de características.

El servidor proxy añade límites de gasto por equipo, seguimiento del uso en todos los proyectos y gestión centralizada de claves API. Toda la configuración se realiza a través de sencillos archivos YAML.

LiteLLM funciona bien para diferentes tipos de usuarios:

• Programadores individuales que desean probar varios modelos sin tener que crear cuentas en todas partes
• Equipos pequeños que necesitáis visibilidad de los costes y no queréis depender de un único proveedor
• Las grandes empresas que requieren una gestión centralizada, controles presupuestarios y análisis detallados del uso.

La biblioteca tiene licencia MIT y es totalmente de código abierto. Puedes inspeccionar el código, modificarlo según tus necesidades o contribuir al proyecto.

Ahora que ya sabes lo que LiteLLM puede hacer, aquí tienes cómo configurar tu entorno.

Requisitos previos

Antes de poder empezar a utilizar LiteLLM, es necesario configurar algunas cosas. Probablemente, ya hayas hecho la mayor parte de esto si has trabajado con modelos de IA anteriormente.

Entorno Python

Necesitas Python 3.7 o una versión más reciente. La mayoría de los sistemas actuales lo tienen, pero puedes comprobar tu versión con:

import sys
print(f"Python version: {sys.version_info.major}.{sys.version_info.minor}")

Instalación del paquete

Instala LiteLLM y python-dotenv para gestionar las variables de entorno:

uv add litellm python-dotenv
# or with pip: pip install litellm python-dotenv

Claves API

Necesitarás las claves API de los proveedores que desees utilizar. Para este tutorial, trabajaremos con dos modelos:

• Clave API de OpenAI: Puedes obtener una clave en platform.openai.com (para GPT-5).
• Clave API de Anthropic: Puedes obtener una clave en console.anthropic.com (para Claude Sonnet 4).

Guárdalos en un archivo .env en el directorio de tu proyecto:

OPENAI_API_KEY=your_openai_key_here
ANTHROPIC_API_KEY=your_anthropic_key_here

Comprobación del entorno

Ejecuta este script para comprobar tu configuración:

import os
import sys
from dotenv import load_dotenv

# Load environment variables
load_dotenv()

# Check Python version
print(f"Python version: {sys.version_info.major}.{sys.version_info.minor}")

# Check LiteLLM
try:
   import litellm
   print("✓ LiteLLM installed")
except ImportError:
   print("✗ LiteLLM not installed")

# Check API keys
openai_key = os.getenv("OPENAI_API_KEY")
anthropic_key = os.getenv("ANTHROPIC_API_KEY")

if openai_key:
   print(f"✓ OpenAI API key found")
else:
   print("✗ OpenAI API key not found")

if anthropic_key:
   print(f"✓ Anthropic API key found")
else:
   print("✗ Anthropic API key not found")

Python version: 3.11
✓ LiteLLM installed
✓ OpenAI API key found
✓ Anthropic API key found

Si ves todas las marcas de verificación en verde, ya estás listo para empezar. Si alguna comprobación falla, asegúrate de haber instalado los paquetes y añadido tus claves API al archivo .env.

Realizar tu primera llamada API con LiteLLM

LiteLLM utiliza la misma interfaz que ya conoces de OpenAI, pero funciona con cualquier proveedor.

Configuración básica

Comienza con estas importaciones:

import litellm
from dotenv import load_dotenv

# Load your API keys
load_dotenv()

Una solicitud básica a GPT-5 sigue este patrón: define tus mensajes, llama a litellm.completion() y obtén la respuesta.

messages = [
   {"role": "user", "content": "Write a simple Python function that adds two numbers"}
]

response = litellm.completion(
   model="gpt-5",
   messages=messages
)

print(response.choices[0].message.content)

def add(a, b):
   """Return the sum of a and b."""
   return a + b

Acabas de llamar a GPT-5 a través de LiteLLM. El objeto de respuesta sigue el formato de OpenAI, por lo que si ya has utilizado su API anteriormente, te resultará familiar. Es posible que quieras inspeccionar qué modelo respondió realmente y comprobar el uso de tokens:

print(f"Model used: {response.model}")
print(f"Response ID: {response.id}")
print(f"Total tokens: {response.usage.total_tokens}")

Model used: gpt-5-2025-08-07
Response ID: chatcmpl-CIbZWUDE1amW2vHtHDmieTX6hnZUq
Total tokens: 557

Cambiar de proveedor

El verdadero poder de LiteLLM se hace evidente al cambiar de proveedor. ¿Quieres probar Claude Sonnet 4 en su lugar? Cambia un parámetro:

response = litellm.completion(
   model="anthropic/claude-sonnet-4-20250514",
   messages=messages
)

print(response.choices[0].message.content)

Here's a simple Python function that adds two numbers:

def add_numbers(a, b):
   """
   Adds two numbers and returns the result.
  
   Args:
       a: First number
       b: Second number
  
   Returns:
       The sum of a and b
   """
   return a + b

# Example usage:
result = add_numbers(5, 3)
print(result)  # Output: 8

This function:
- Takes two parameters a and b
- Returns their sum using the + operator
- Works with integers, floats, and even negative numbers
- Includes a docstring to explain what the function does

Misma estructura de código, proveedor diferente. Claude ofrece una respuesta mucho más detallada con documentación y ejemplos, mientras que GPT-5 fue más conciso.

Manejo básico de errores

Añade algún tipo de gestión de errores para cuando las cosas salgan mal:

try:
   response = litellm.completion(
       model="gpt-5",
       messages=messages
   )
   print(response.choices[0].message.content)
except Exception as e:
   print(f"API call failed: {e}")

Este patrón detecta problemas comunes como claves API no válidas, problemas de red o indisponibilidad del modelo.

¿Qué sigue?

Ahora ya conoces el patrón básico para utilizar LiteLLM con cualquier proveedor. La documentación de introducción incluye más detalles sobre los modelos y parámetros compatibles, y la referencia de la función Completion muestra todas las opciones disponibles.

Para crear aplicaciones de producción, también te recomendamos seguir las prácticas recomendadas de diseño de API con el fin de crear sistemas fiables y de alto rendimiento.

Cambio de proveedor y alternativas

El sistema de respaldo de LiteLLM gestiona automáticamente los fallos de los proveedores para que tus usuarios nunca vean mensajes de error. Cuando desarrollas aplicaciones reales, necesitas planes de respaldo que funcionen sin necesidad de añadir código adicional por tu parte.

Configuración básica de respaldo

Para configurar una alternativa, añade una lista fallbacks a tu llamada de finalización:

messages = [
   {"role": "user", "content": "Explain what a Python decorator is in one sentence"}
]

response = litellm.completion(
   model="gpt-5",
   messages=messages,
   fallbacks=["anthropic/claude-sonnet-4-20250514"]
)

print(f"Response: {response.choices[0].message.content}")
print(f"Model used: {response.model}")

Response: A Python decorator is a callable that wraps another function or class to augment its behavior and returns it, applied with the @ syntax so you can add reusable functionality without changing the original code.
Model used: gpt-5-2025-08-07

Si GPT-5 falla, LiteLLM prueba automáticamente Claude Sonnet 4. Los usuarios obtienen una respuesta en cualquier caso.

Creación de cadenas de respaldo

Puedes encadenar varios proveedores para obtener una mayor fiabilidad. Usando los mismos mensajes de antes:

response = litellm.completion(
   model="gpt-5",
   messages=messages,
   fallbacks=["anthropic/claude-sonnet-4-20250514", "gpt-3.5-turbo"]
)

print(f"Model used: {response.model}")

Model used: gpt-5-2025-08-07

LiteLLM prueba los modelos en orden. Si falla el primario, se prueba el primer respaldo. Si eso falla, se intenta el segundo. Múltiples capas de protección.

Añadir reintentos

Combina los planes de contingencia con los reintentos para obtener una fiabilidad aún mayor:

response = litellm.completion(
   model="gpt-5",
   messages=messages,  # Same messages as before
   num_retries=2
)

Vuelve a intentar el mismo modelo dos veces antes de pasar a los planes alternativos. Útil para problemas temporales de red o picos en los límites de velocidad.

Las soluciones alternativas gestionan la mayoría de los fallos automáticamente, pero aún así debes detectar los casos en los que todos los modelos fallan:

try:
   response = litellm.completion(
       model="gpt-5",
       messages=messages,  # Same messages as before
       fallbacks=["anthropic/claude-sonnet-4-20250514"],
       num_retries=2
   )
   return response.choices[0].message.content
except Exception as e:
   # All models failed - handle gracefully
   return "Sorry, I'm having trouble right now. Please try again."

Incluso cuando los proveedores funcionan perfectamente, los usuarios siguen enfrentándose a otro problema: los frustrantes tiempos de espera. Alguien hace clic en «Enviar» en tu aplicación y no ve nada durante varios segundos. Se preguntan si algo se ha roto.

Transmisión para respuestas en tiempo real

La mayoría de las respuestas de la API de IA llegan como un bloque completo, como cuando se descarga un archivo. Los usuarios esperan sin recibir ninguna respuesta hasta que toda la respuesta está lista. El streaming cambia esto al mostrar el texto a medida que se genera, palabra por palabra.

Por qué el streaming cambia la experiencia del usuario

En lugar de esperar a la respuesta completa, la transmisión muestra el texto a medida que la IA lo genera. Observa la diferencia:

import litellm
from dotenv import load_dotenv

load_dotenv()

messages = [{"role": "user", "content": "What is Python in one sentence?"}]

response = litellm.completion(
   model="gpt-5",
   messages=messages,
   stream=True
)

for chunk in response:
   if chunk.choices[0].delta.content:
       print(chunk.choices[0].delta.content, end="", flush=True)

Python is a high-level, interpreted, dynamically typed, general-purpose programming language known for its readability and vast ecosystem, used across web development, data science, automation, scripting, and more.

El texto aparece gradualmente en lugar de todo a la vez (al ejecutar el fragmento anterior en tu equipo). Los usuarios ven el progreso inmediatamente, lo que resulta mucho más satisfactorio que quedarse mirando un indicador de carga.

Cómo funciona realmente el streaming

Esto funciona a nivel de fragmentos. En lugar de una gran respuesta, obtienes muchas piezas pequeñas, llamadas deltas. A veces, los fragmentos están vacíos, por lo que debes manejarlos adecuadamente por motivos de seguridad:

response = litellm.completion(
   model="anthropic/claude-sonnet-4-20250514",
   messages=[{"role": "user", "content": "Define JavaScript in exactly two sentences"}],
   stream=True
)

for chunk in response:
   if hasattr(chunk.choices[0].delta, 'content') and chunk.choices[0].delta.content:
       print(f"'{chunk.choices[0].delta.content}'", end=" ")

'JavaScript is a high' '-level, interpreted programming language primarily used for creating' ' interactive and dynamic content on web pages, running' ' in web browsers to manip' 'ulate HTML elements, handle user events' ', and communicate with servers.' ' Originally designed for client-side web development, JavaScript has evolve' 'd into a versatile language that can also' ' be used for server-side development, mobile applications' ', and desktop software through various runtime' ' environments like Node.js.'

Hacer que el streaming sea reutilizable

Para aplicaciones reales, querrás capturar la respuesta completa sin dejar de mostrar la salida de streaming. Aquí tienes una función para hacerlo:

def stream_and_capture(model, messages):
   """Stream response while capturing the complete text"""
   response = litellm.completion(
       model=model,
       messages=messages,
       stream=True
   )
  
   full_response = ""
   for chunk in response:
       if chunk.choices[0].delta.content:
           content = chunk.choices[0].delta.content
           print(content, end="", flush=True)
           full_response += content
  
   print()  # New line after response
   return full_response

# Test it
messages = [{"role": "user", "content": "Define APIs in 2 sentences max"}]
result = stream_and_capture("gpt-5", messages)

APIs (Application Programming Interfaces) are standardized contracts, often exposed as endpoints, that specify how software components or services can communicate, including the allowed operations, inputs, and outputs. They let developers access functionality or data without knowing the underlying implementation, enabling modular, interoperable systems.

El parámetro end="" evita los saltos de línea entre fragmentos. flush=True fuerza la visualización inmediata en lugar del almacenamiento en búfer.

Transmisión con alternativas

También puedes combinar la transmisión en directo con el sistema de respaldo para obtener una mayor fiabilidad:

response = litellm.completion(
   model="gpt-5",
   messages=[{"role": "user", "content": "Define machine learning in one sentence"}],
   fallbacks=["anthropic/claude-sonnet-4-20250514"],
   stream=True
)

for chunk in response:
   if chunk.choices[0].delta.content:
       print(chunk.choices[0].delta.content, end="", flush=True)

Machine learning is a branch of artificial intelligence where algorithms learn patterns from data to make predictions or decisions without being explicitly programmed.

Retroalimentación inmediata y cambio automático de proveedor si falla el modelo principal.

El streaming ofrece a los usuarios una respuesta inmediata, pero aún así te enfrentas a otro problema a la hora de crear aplicaciones reales. Una vez que llegue ese texto, tu código debe funcionar con él. Puedes extraer datos, almacenar información en bases de datos o pasar valores a otras funciones. Pero analizar las respuestas de texto es complicado y se estropea fácilmente cuando cambia el formato.

Uso de salidas estructuradas

Esto es lo que ocurre realmente: Creas una aplicación que analiza los comentarios de los clientes. Tu IA devuelve un texto como «El sentimiento es positivo, con una confianza del 0,85 y las palabras clave principales son: receptivo, útil, rápido». Escribes patrones regex para extraer la puntuación de confianza y las palabras clave. Todo funciona en las pruebas.

A continuación, la IA cambia ligeramente el formato de su respuesta a «Sentimiento: positivo (confianza: 0,85). Las palabras clave incluyen «receptivo», «servicial» y «rápido». Tu expresión regular no funciona. Tu canal de datos deja de funcionar. Los informes sobre la opinión de los clientes muestran valores vacíos en lugar de puntuaciones. Tu panel de control se bloquea. Pasas horas arreglando código de análisis sintáctico que ayer funcionaba.

Las salidas estructuradas evitan este problema al devolver datos en formatos predecibles desde el principio.

Obtener JSON en lugar de texto

LiteLLM puede devolver JSON en lugar de texto sin formato. Tú le indicas la estructura que deseas a través de tu comando y él te devuelve el resultado con el formato correcto:

import litellm
from dotenv import load_dotenv

load_dotenv()

messages = [{"role": "user", "content": "Describe Python as a programming language. Return as JSON with fields: language, difficulty, description"}]

response = litellm.completion(
   model="gpt-5",
   messages=messages,
   response_format={"type": "json_object"}
)

print(response.choices[0].message.content)

{
 "language": "Python",
 "difficulty": "Beginner-friendly (easy to learn, moderate to master)",
 "description": "Python is a high-level, interpreted, dynamically typed, general-purpose programming language focused on readability and developer productivity. It supports multiple paradigms (object-oriented, functional, procedural), uses indentation for block structure, and includes a large standard library with an extensive third-party ecosystem (PyPI). Common uses include web development, data science, machine learning, automation/scripting, scientific computing, and DevOps. While not the fastest for CPU-bound tasks, it integrates well with C/C++ and accelerators, and runs cross-platform."
}

Este enfoque estructurado elimina los problemas habituales de análisis sintáctico. En lugar de buscar en el texto, obtienes un JSON válido con exactamente los campos que has solicitado. Sin dolores de cabeza por el análisis sintáctico, sin sorpresas con el formato.

Trabajar con datos JSON

Las cadenas JSON sin procesar no son útiles hasta que las conviertes en objetos Python con los que tu aplicación pueda trabajar. Debes convertir esa cadena en objetos Python que puedas utilizar realmente:

import json

messages = [{"role": "user", "content": "Describe JavaScript in 2 sentences. Return as JSON with fields: name, paradigm, use_cases (array of exactly 3 items)"}]

response = litellm.completion(
   model="anthropic/claude-sonnet-4-20250514",
   messages=messages,
   response_format={"type": "json_object"}
)

# Parse the JSON response
data = json.loads(response.choices[0].message.content)
print(f"Language: {data['name']}")
print(f"Paradigm: {data['paradigm']}")
print(f"Use cases: {', '.join(data['use_cases'])}")

Language: JavaScript
Paradigm: multi-paradigm (object-oriented, functional, event-driven)
Use cases: web development and browser scripting, server-side development with Node.js, mobile app development with frameworks like React Native

Ahora que tienes datos estructurados, puedes pasarlos directamente a otras funciones, almacenarlos en bases de datos o mostrarlos en tu interfaz de usuario sin necesidad de manipular el texto. Para los flujos de trabajo de análisis de datos, herramientas como Pandas AI pueden trabajar directamente con esta salida estructurada para generar información.

Añadir seguridad de tipos con Pydantic

El análisis JSON detecta errores de sintaxis, pero los tipos de datos incorrectos o los campos que faltan son problemas diferentes. Los modelos Pydantic resuelven este problema validando la estructura de datos y detectando los problemas antes de que afecten a la aplicación:

from pydantic import BaseModel
import json

class ProgrammingLanguage(BaseModel):
   name: str
   paradigm: str
   use_cases: list[str]

messages = [{"role": "user", "content": "Describe CSS briefly. Return as JSON with fields: name, paradigm, use_cases (array of 3 items)"}]

response = litellm.completion(
   model="gpt-5",
   messages=messages,
   response_format={"type": "json_object"}
)

# Parse and validate with Pydantic
data = json.loads(response.choices[0].message.content)
language = ProgrammingLanguage(**data)

print(f"Validated data: {language.name} - {language.paradigm}")
print(f"Use cases: {language.use_cases}")

Validated data: CSS (Cascading Style Sheets) - Declarative, rule-based stylesheet language for describing the presentation of structured documents.
Use cases: ['Styling layout, colors, and typography of web pages', 'Responsive design across devices and viewports', 'Animations, transitions, and visual effects']

Pydantic valida automáticamente que name y paradigm son cadenas, y que use_cases es una lista de cadenas. Si la IA devuelve tipos incorrectos u olvida un campo obligatorio, obtendrás un error claro en lugar de misteriosos errores más adelante.

Manejo de errores JSON

El análisis JSON puede fallar si la IA devuelve un texto JSON malformado o que no sea JSON. Añadir gestión básica de errores:

import json

messages = [{"role": "user", "content": "Summarize machine learning in 1 sentence. Return as JSON with topic and summary fields"}]

try:
   response = litellm.completion(
       model="anthropic/claude-sonnet-4-20250514",
       messages=messages,
       response_format={"type": "json_object"}
   )
  
   data = json.loads(response.choices[0].message.content)
   print(f"Topic: {data['topic']}")
   print(f"Summary: {data['summary']}")
  
except json.JSONDecodeError:
   print("Invalid JSON returned")
except Exception as e:
   print(f"Request failed: {e}")

Topic: machine learning
Summary: Machine learning is a subset of artificial intelligence that allows computers to learn and make predictions or decisions from data without being explicitly programmed for each specific task.

Las salidas estructuradas sustituyen el análisis sintáctico de texto desordenado por estructuras de datos limpias. Puedes combinar el modo JSON con alternativas, igual que con las completaciones normales.

Las salidas estructuradas te proporcionan datos limpios y predecibles que no alterarán tu lógica de análisis. Pero hay otro problema que surge cuando pasas del prototipo a la producción: las facturas. Cada llamada a la API tiene un coste, y esos costes pueden sorprenderte.

Seguimiento de costes

Esto es lo que sucede: Tu prototipo funciona muy bien en las pruebas con 50 llamadas API al día. Estás gastando unos 2 dólares a la semana. Todo parece estar bien. Lanzas el producto y consigues 500 usuarios. Ahora estás realizando 5000 llamadas API al día. Tu factura mensual pasa de 8 a 800 dólares.

Sin un seguimiento de los costes, no tenías ninguna advertencia. No puedes saber qué funciones son las más caras, qué modelos son más costosos ni cómo presupuestar el crecimiento. Descubres el aumento en la factura semanas más tarde, cuando recibes el extracto de la tarjeta de crédito.

LiteLLM realiza un seguimiento exacto de lo que gastas en todos los proveedores.

Comprender el uso de los tokens

Cada respuesta de la IA incluye información detallada sobre el uso que muestra exactamente lo que se te está cobrando:

import litellm
from dotenv import load_dotenv

load_dotenv()

messages = [{"role": "user", "content": "Explain what a REST API is in two sentences"}]

response = litellm.completion(
   model="gpt-5",
   messages=messages
)

print(f"Response: {response.choices[0].message.content}")
print(f"Prompt tokens: {response.usage.prompt_tokens}")
print(f"Completion tokens: {response.usage.completion_tokens}")
print(f"Total tokens: {response.usage.total_tokens}")

Response: A REST API is a web service that follows the Representational State Transfer architectural style, exposing resources identified by URLs and manipulated with HTTP methods like GET, POST, PUT, and DELETE. It uses stateless client-server communication, cacheability, and uniform representations (often JSON) to support scalable, decoupled interactions.
Prompt tokens: 15
Completion tokens: 201
Total tokens: 216

Los tokens de entrada son tus indicaciones, los tokens de salida son la respuesta de la IA. Los distintos proveedores cobran tarifas diferentes por cada tipo.

Cálculo automático de costes

El recuento bruto de tokens no indica el importe en dólares. LiteLLM calcula el coste real por ti:

# Get the cost for a completed response
cost = litellm.completion_cost(completion_response=response)
print(f"Total cost: ${cost:.4f}")
Total cost: $0.0020

La base de datos de precios de LiteLLM convierte los tokens a dólares según tu modelo.

Cálculos manuales de costes

A veces quieres calcular los costes antes de hacer una llamada o calcular los costes de un mensaje de texto que ya tienes:

# Calculate cost without making an API call
prompt_text = "Explain machine learning"
completion_text = "Machine learning is a method of data analysis that automates analytical model building."

estimated_cost = litellm.completion_cost(
   model="anthropic/claude-sonnet-4-20250514",
   prompt=prompt_text,
   completion=completion_text
)

print(f"Estimated cost: ${estimated_cost:.4f}")

Estimated cost: $0.0002

Esto resulta útil para elaborar presupuestos y comparar modelos.

Seguimiento de múltiples llamadas a la API

Para aplicaciones que realizan muchas llamadas a la API, puedes realizar un seguimiento de los costes acumulados:

total_cost = 0.0

conversation = [
   "What is Python?",
   "How do you install Python packages?",
   "What are virtual environments?"
]

for i, question in enumerate(conversation):
   response = litellm.completion(
       model="gpt-5",
       messages=[{"role": "user", "content": question}]
   )
  
   call_cost = litellm.completion_cost(completion_response=response)
   total_cost += call_cost
  
   print(f"Call {i+1}: ${call_cost:.4f}")

print(f"Total cost: ${total_cost:.4f}")

Call 1: $0.0057
Call 2: $0.0134
Call 3: $0.0102
Total cost: $0.0292

El seguimiento de los costes te ayuda a tomar decisiones informadas sobre qué modelos utilizar y a evitar facturas inesperadas. Averigua exactamente cuánto cuesta cada llamada a la API y compara proveedores.

Conclusión

Ahora dispones de las herramientas necesarias para crear aplicaciones de IA sin depender de un único proveedor. Has aprendido llamadas API básicas, alternativas automáticas, respuestas en streaming, salidas estructuradas y seguimiento de costes.

Esto te da la libertad de elegir los mejores modelos para cada tarea. Cambia fácilmente de proveedor, configura alternativas automáticas y programa los costes. Cuando aparezcan modelos mejores, podrás adoptarlos sin necesidad de reescribir el código.