ES ▾
Obtener clave de API

API LLM en Python: chat, streaming y llamadas a funciones

Esta guía de API LLM en Python usa el SDK oficial de OpenAI apuntando a un endpoint compatible con OpenAI. Obtienes una primera llamada, streaming, una llamada a funciones y lógica de reintentos en código que puedes pegar y ejecutar.

Actualizado

Cinta de bloques de código fluyendo desde un portátil hacia burbujas de chat, ilustrando una llamada a la API LLM en Python
01

Puntos clave

  • Instala openai, configura la base URL y la clave, y usa el ID de modelo uncensored.
  • Usa streaming con stream=True y cierra el stream antes para liberar la ranura de concurrencia.
  • Las llamadas a herramientas devuelven argumentos que debes analizar y validar antes de ejecutar cualquier cosa.
  • Maneja 429 con Retry-After y limita las peticiones simultáneas a 8 con una clave completa.

Instala el SDK y haz la primera llamada

Si quieres una configuración de API LLM en Python que funcione en cinco minutos, el SDK de OpenAI es todo lo que necesitas. La API es compatible con OpenAI, así que mantienes el cliente oficial y cambias dos valores: la base URL y la clave. El ID del modelo es uncensored.

Primero obtén una clave. Regístrate en la página de clave de API, reclama el crédito de prueba de un clic y copia la clave. Luego instala el cliente y mantén la clave fuera de tu código fuente.

pip install openai
export LLM_API_KEY="your-key-here"

Ahora el programa más útil mínimo:

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.llmmodelsapi.com/v1",
    api_key=os.environ["LLM_API_KEY"],
)

resp = client.chat.completions.create(
    model="uncensored",
    messages=[
        {"role": "system", "content": "You are a concise technical assistant."},
        {"role": "user", "content": "Explain what a context window is in two sentences."},
    ],
    temperature=0.7,
)

print(resp.choices[0].message.content)
print(resp.usage)

Esa es toda la integración. resp.usage proporciona los recuentos de tokens de prompt y completion, que puedes multiplicar por las tarifas de la página de precios ($0,15 por cada 1M de tokens de entrada, $0,50 por cada 1M de tokens de salida) para ver cuánto cuesta cada llamada. El mismo endpoint también acepta POST /v1/responses si tu código ya usa ese formato, y GET /v1/models lista el ID del modelo.

Cómo se ven la petición y la respuesta

El cliente de OpenAI oculta los detalles HTTP, pero ayuda conocerlos cuando algo sale mal. El SDK envía un POST a /v1/chat/completions con un token bearer. Puedes reproducir la llamada con curl y comparar.

curl https://api.llmmodelsapi.com/v1/chat/completions \
  -H "Authorization: Bearer $LLM_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model": "uncensored", "messages": [{"role": "user", "content": "Say hello"}]}'

Parámetros útiles que se pasan al modelo: temperature, top_p, stop, seed y las penalizaciones de frecuencia y presencia. max_tokens es opcional. Si no lo indicas, la completion puede usar todo lo que quede de la ventana de 100.000 tokens (prompt y completion juntos).

Dos encabezados de respuesta vale la pena registrar en cada llamada: X-Request-Id para preguntas de soporte, y X-Balance-USD para tu crédito restante. Con el SDK de Python los accedes a través de la respuesta cruda:

raw = client.chat.completions.with_raw_response.create(
    model="uncensored",
    messages=[{"role": "user", "content": "Ping"}],
    max_tokens=20,
)
print(raw.headers.get("X-Request-Id"))
print(raw.headers.get("X-Balance-USD"))
completion = raw.parse()
print(completion.choices[0].message.content)

Tokens de streaming a medida que llegan

Para interfaces de chat y cualquier cosa en la que una persona esté esperando, usa streaming para la respuesta. Establece stream=True e itera sobre los fragmentos. La API los envía mediante eventos enviados por el servidor, y el último fragmento lleva el uso cuando lo solicitas.

stream = client.chat.completions.create(
    model="uncensored",
    messages=[{"role": "user", "content": "Write a short product description for a mechanical keyboard."}],
    stream=True,
    stream_options={"include_usage": True},
)

for chunk in stream:
    if chunk.choices and chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)
    if chunk.usage:
        print("\n", chunk.usage)

Dos detalles suelen causar problemas. Primero, algunos fragmentos tienen una lista choices vacía (el fragmento de uso, por ejemplo), así que protege antes de indexar. Segundo, una petición con streaming mantiene su ranura de concurrencia hasta que termina el streaming. Si abres un stream y lo abandonas sin cerrarlo, esa ranura se mantiene ocupada y las llamadas posteriores pueden fallar con un error de concurrency. Usa el stream en un bloque with o llama a stream.close() cuando dejes de leer antes.

Si un stream se corta con un mensaje poco claro, el artículo sobre cómo usar un modelo LLM en este sitio cubre los fundamentos para leer errores y reintentar.

Una llamada a funciones contra el modelo

Las llamadas a funciones permiten que el modelo le pida a tu código que ejecute una función y luego continúe con el resultado. El flujo tiene tres pasos: enviar las definiciones de funciones, ejecutar lo que solicite el modelo y enviar la salida de vuelta con role: "tool".

import json

def get_order_status(order_id: str) -> str:
    # Replace with a real lookup
    return json.dumps({"order_id": order_id, "status": "shipped"})

tools = [{
    "type": "function",
    "function": {
        "name": "get_order_status",
        "description": "Look up the status of an order by its ID",
        "parameters": {
            "type": "object",
            "properties": {"order_id": {"type": "string"}},
            "required": ["order_id"],
        },
    },
}]

messages = [{"role": "user", "content": "Where is order A-1042?"}]
first = client.chat.completions.create(
    model="uncensored", messages=messages, tools=tools, tool_choice="auto"
)

msg = first.choices[0].message
if msg.tool_calls:
    messages.append(msg)
    for call in msg.tool_calls:
        args = json.loads(call.function.arguments)
        messages.append({
            "role": "tool",
            "tool_call_id": call.id,
            "content": get_order_status(**args),
        })
    final = client.chat.completions.create(model="uncensored", messages=messages, tools=tools)
    print(final.choices[0].message.content)
else:
    print(msg.content)

Analiza siempre call.function.arguments como JSON dentro de un bloque try en código real, porque los modelos ocasionalmente producen argumentos que no coinciden con tu esquema. Valida antes de ejecutar cualquier cosa con efectos secundarios. Para bucles de agente más largos, consulta la guía para usar esta API para agentes.

Las llamadas a herramientas también hacen streaming: los argumentos llegan en fragmentos en delta.tool_calls, y los concatenas por índice hasta que termine el streaming.

Modo JSON para salida estructurada

Cuando necesites una salida legible por máquina en lugar de texto, configura response_format a un objeto JSON. Describe la forma que deseas en el prompt, ya que el modo JSON garantiza una sintaxis JSON válida pero no tu esquema en particular.

resp = client.chat.completions.create(
    model="uncensored",
    messages=[
        {"role": "system", "content": "Reply only with JSON: {\"sentiment\": \"positive|negative|neutral\", \"confidence\": 0-1}"},
        {"role": "user", "content": "The setup took ten minutes and everything just worked."},
    ],
    response_format={"type": "json_object"},
    temperature=0,
)
data = json.loads(resp.choices[0].message.content)
print(data["sentiment"])

Usa temperature=0 para extracción y clasificación para que las ejecuciones repetidas den las mismas etiquetas. Añade seed si quieres fijar aún más el muestreo, y sigue validando el resultado analizado contra tu propio esquema.

Límites, reintentos y manejo de errores

Una clave completa permite 8 solicitudes simultáneas y 300 solicitudes por minuto. Una clave de prueba permite 2 simultáneas y 60 por minuto. Superar cualquiera de los límites devuelve HTTP 429. El código de error indica qué límite alcanzaste: rate_limited para solicitudes por minuto y concurrency para demasiadas a la vez. En caso de sobrecarga temporal, también obtienes un 429 con un encabezado Retry-After: 5.

El SDK de OpenAI ya reintenta algunos fallos, pero debes configurar la política tú mismo:

import os
import time
from openai import OpenAI, RateLimitError, APIConnectionError

client = OpenAI(base_url="https://api.llmmodelsapi.com/v1", api_key=os.environ["LLM_API_KEY"], max_retries=0, timeout=120)

def ask(messages, tries=5):
    delay = 2
    for attempt in range(tries):
        try:
            return client.chat.completions.create(model="uncensored", messages=messages)
        except RateLimitError as e:
            wait = float(e.response.headers.get("Retry-After", delay))
            time.sleep(wait)
            delay = min(delay * 2, 30)
        except APIConnectionError:
            time.sleep(delay)
            delay = min(delay * 2, 30)
    raise RuntimeError("gave up after retries")

Si distribuyes el trabajo con hilos o asyncio, limita el grupo a 8 (o 2 con una clave de prueba) con un semáforo. Eso te mantiene por debajo del límite de concurrencia sin depender de reintentos. Las peticiones fallidas o rechazadas no se cobran, por lo que reintentar no cuesta extra por los intentos fallidos.

Consulta tu saldo desde código con GET /v1/balance, o lee X-Balance-USD de cualquier respuesta. La lista completa de parámetros está en la documentación de la API.

Cuánto cuesta ejecutar estos ejemplos

Los ejemplos anteriores son mínimos. Una petición con 300 tokens de prompt y 200 tokens de completion cuesta 300 x $0,15 / 1M más 200 x $0,50 / 1M, lo que es $0,000045 más $0,0001, o $0,000145. Aproximadamente 6.900 de estas peticiones caben en un dólar. El crédito de prueba de $0,50 cubre alrededor de 3.400 de ellas, y es válido durante 7 días sin necesidad de datos de pago.

Tras el período de prueba, recarga cualquier cantidad entera desde $20 hasta $500, con un bono del 5% desde $50, 10% desde $100 y 15% desde $200. El crédito no caduca y no hay suscripción. Los prompts no se usan para entrenamiento.

02

Preguntas y respuestas

¿Puedo usar la biblioteca oficial de OpenAI para Python?

Sí. Configura base_url con la dirección de la API y api_key con tu clave, luego llama a chat.completions.create con model uncensored.

¿La API admite Python asíncrono?

Sí, usa AsyncOpenAI con la misma URL base y clave. Mantén las tareas concurrentes en o por debajo de 8 con una clave completa, o 2 con una clave de prueba.

¿Cómo veo cuántos tokens usó una llamada?

Lee resp.usage en una llamada normal, o pasa stream_options con include_usage en una llamada con streaming. Multiplica por $0,15 por cada 1M de tokens de entrada y $0,50 por cada 1M de tokens de salida.

¿Qué longitud puede tener mi prompt?

La ventana de contexto es de 100.000 tokens, incluyendo prompt y completion combinados. El cuerpo de la petición está limitado a 8 MB.

Tu clave está a un formulario de distancia

Crea una cuenta, copia la clave, cambia la URL base. Esa es toda la configuración.

Obtener clave de API