Flujo de API LLM en Python: Configuración paso a paso
Apunta el SDK de OpenAI a una nueva URL base, usa el ID del modelo uncensored y añade reintentos, ejecuciones paralelas y llamadas a funciones una capa a la vez.
Actualizado

Puntos clave
- Instala openai, establece base_url en https://api.veo3apis.com/v1 y usa el modelo uncensored.
- Maneja el 429 esperando Retry-After; las peticiones fallidas no se cobran.
- Ajusta el tamaño del grupo de hilos según tu clave: 8 trabajadores para una clave completa, 2 para la clave de prueba.
- Lee X-Balance-USD de los encabezados de respuesta para rastrear el gasto por ejecución.
La versión corta
Para construir un script de flujo de trabajo de API LLM en Python, instala el SDK oficial de OpenAI, establece la URL base en https://api.veo3apis.com/v1, usa tu clave como clave de API y llama al modelo uncensored. Nada más cambia. El servicio es compatible con OpenAI, así que cada patrón que ya conozcas del SDK funciona: llamadas de chat simples, streaming, modo JSON y llamadas a herramientas.
Este artículo construye un pequeño flujo de trabajo en capas. Empiezas con una llamada única, luego añades configuración desde variables de entorno, un envoltorio de reintento, un ejecutor paralelo, una llamada a función y seguimiento del saldo. Cada capa es corta y puedes detenerte en cualquiera que cubra tus necesidades.
El modelo es un modelo de pesos abiertos ejecutado por un proveedor independiente. No es la API oficial de ningún gran proveedor ni es un enrutador, por lo que solo hay un ID de modelo que recordar. Solo maneja texto. No hay generación de imágenes, audio o video, ni embeddings ni ajuste fino.
Instala el SDK y haz la primera llamada
Necesitas Python 3.9 o superior. Instala el SDK:
pip install openai
Crea una clave desde la página de clave de API después de registrarte con Google o con un correo electrónico y contraseña. La página también tiene un reclamo con un clic de $0,50 de crédito de prueba, válido por 7 días, uno por persona, sin necesidad de tarjeta. Luego ejecuta la llamada más pequeña posible:
from openai import OpenAI
client = OpenAI(
base_url="https://api.veo3apis.com/v1",
api_key="YOUR_API_KEY",
)
resp = client.chat.completions.create(
model="uncensored",
messages=[
{"role": "system", "content": "You are a concise assistant."},
{"role": "user", "content": "List three uses for a hosted text API."},
],
)
print(resp.choices[0].message.content)
print(resp.usage)
Si esto imprime texto y un objeto de uso, la autenticación, el enrutamiento y el ID del modelo son correctos. El SDK envía tu clave como Authorization: Bearer, y la petición va a POST /v1/chat/completions. Puedes verificar qué IDs de modelo ve tu clave con client.models.list(), que llama a GET /v1/models.
Una versión cruda con curl es útil cuando depuras desde un servidor sin Python:
curl https://api.veo3apis.com/v1/chat/completions \
-H "Authorization: Bearer $API_KEY" \
-H "Content-Type: application/json" \
-d '{"model": "uncensored", "messages": [{"role": "user", "content": "Say hello."}]}'
Mantén la configuración en un solo cliente
Codificar una clave en un script es la forma más rápida de filtrarla en un repositorio. Lee ambos valores desde el entorno y crea el cliente en un solo lugar para que cada paso del flujo de trabajo lo comparta.
import os
from openai import OpenAI
client = OpenAI(
base_url=os.environ.get("LLM_BASE_URL", "https://api.veo3apis.com/v1"),
api_key=os.environ["LLM_API_KEY"],
max_retries=0,
timeout=120,
)
MODEL = "uncensored"
def ask(system: str, user: str, **kwargs) -> str:
resp = client.chat.completions.create(
model=MODEL,
messages=[
{"role": "system", "content": system},
{"role": "user", "content": user},
],
**kwargs,
)
return resp.choices[0].message.content
Dos opciones aquí son deliberadas. max_retries=0 desactiva los reintentos integrados del SDK para que la lógica de reintento en la siguiente sección sea la única, lo que facilita razonar sobre el comportamiento. El tiempo de espera de 120 segundos deja espacio para completaciones largas; la ventana de contexto es de 100,000 tokens para prompt más completación, y una respuesta grande tarda tiempo en transmitirse. Los parámetros de muestreo como temperature, top_p, stop, seed y las penalizaciones pasan a través de **kwargs como es habitual.
Reintenta los errores correctos
Cualquier flujo de trabajo real alcanza los límites de peticiones tarde o temprano. Una clave completa permite 300 peticiones por minuto y 8 a la vez. Una clave de prueba permite 60 por minuto y 2 a la vez. Si excedes cualquiera de ellos, la API devuelve HTTP 429. El código de error indica qué límite alcanzaste: rate_limited para peticiones por minuto, concurrency para demasiadas a la vez. Durante una sobrecarga temporal, la API también envía 429 con un encabezado Retry-After: 5.
Los tres casos tienen la misma cura: espera, luego intenta de nuevo. Este envoltorio respeta el encabezado y retrocede cuando está ausente.
from openai import OpenAI
client = OpenAI(
base_url="https://api.veo3apis.com/v1",
api_key="YOUR_API_KEY",
)
import time
from openai import RateLimitError, APIConnectionError, APIStatusError
def call_with_retry(messages, tries=5, **kwargs):
delay = 2
for attempt in range(tries):
try:
return client.chat.completions.create(
model="uncensored", messages=messages, **kwargs
)
except RateLimitError as err:
wait = err.response.headers.get("Retry-After")
time.sleep(int(wait) if wait else delay)
delay = min(delay * 2, 30)
except APIConnectionError:
time.sleep(delay)
delay = min(delay * 2, 30)
except APIStatusError as err:
if err.status_code < 500:
raise
time.sleep(delay)
delay = min(delay * 2, 30)
raise RuntimeError("request failed after retries")
Solo reintenta errores que puedan cambiar. Un 400 significa que tu petición está mal formada, y enviarla de nuevo fallará de la misma manera, por lo que el envoltorio vuelve a lanzar cualquier error de cliente distinto a 429. Las peticiones fallidas o rechazadas no se cobran, por lo que reintentar no cuesta nada extra.
Ejecuta muchas entradas en paralelo
Para un bucle sobre muchas entradas, un grupo de hilos es suficiente. El cliente del SDK es seguro para compartir entre hilos. Ajusta el tamaño del grupo según tu clave: 8 trabajadores para una clave completa, 2 para la clave de prueba.
from openai import OpenAI
client = OpenAI(
base_url="https://api.veo3apis.com/v1",
api_key="YOUR_API_KEY",
)
import time
from concurrent.futures import ThreadPoolExecutor
from openai import RateLimitError
def summarize(text: str) -> str:
for _ in range(5):
try:
resp = client.chat.completions.create(
model="uncensored",
messages=[
{"role": "system", "content": "Summarize the text in two sentences."},
{"role": "user", "content": text},
],
max_tokens=150,
)
return resp.choices[0].message.content.strip()
except RateLimitError as err:
time.sleep(int(err.response.headers.get("Retry-After", "5")))
return ""
documents = ["First long text...", "Second long text...", "Third long text..."]
with ThreadPoolExecutor(max_workers=8) as pool:
summaries = list(pool.map(summarize, documents))
for s in summaries:
print(s)
El tamaño del grupo no es lo mismo que la tasa de peticiones. Ocho trabajadores que terminan una llamada en medio segundo harían 960 peticiones por minuto, muy por encima de 300. Si tus llamadas son rápidas, añade una pequeña pausa o un limitador de cubo de tokens para mantenerte por debajo del límite por minuto. Si tus llamadas son lentas, la concurrencia es el límite que alcanzarás primero. Las peticiones en streaming mantienen su espacio hasta que termina la transmisión.
Salida estructurada y llamadas a herramientas
Dos características convierten una llamada de chat en un paso de flujo de trabajo en el que otro código puede confiar. El modo JSON garantiza una salida analizable. Las llamadas a funciones permiten que el modelo le pida a tu código que haga algo y luego use la respuesta.
Modo JSON
Establece response_format a un objeto JSON y describe las claves en el prompt.
from openai import OpenAI
client = OpenAI(
base_url="https://api.veo3apis.com/v1",
api_key="YOUR_API_KEY",
)
import json
resp = client.chat.completions.create(
model="uncensored",
response_format={"type": "json_object"},
messages=[
{"role": "system", "content": "Reply with JSON: {\"title\": string, \"tags\": [string]}"},
{"role": "user", "content": "A short post about nightly backups."},
],
)
post = json.loads(resp.choices[0].message.content)
print(post["title"], post["tags"])
Llamadas a funciones
Declara herramientas con tools, fuerza opcionalmente una elección con tool_choice, ejecuta la función tú mismo y envía el resultado de vuelta como un mensaje con role: "tool".
from openai import OpenAI
client = OpenAI(
base_url="https://api.veo3apis.com/v1",
api_key="YOUR_API_KEY",
)
import json
tools = [{
"type": "function",
"function": {
"name": "word_count",
"description": "Count the words in a piece of text.",
"parameters": {
"type": "object",
"properties": {"text": {"type": "string"}},
"required": ["text"],
},
},
}]
messages = [{"role": "user", "content": "How many words are in 'the quick brown fox'?"}]
first = client.chat.completions.create(model="uncensored", messages=messages, tools=tools)
msg = first.choices[0].message
if msg.tool_calls:
messages.append(msg)
for call in msg.tool_calls:
args = json.loads(call.function.arguments)
result = {"words": len(args["text"].split())}
messages.append({
"role": "tool",
"tool_call_id": call.id,
"content": json.dumps(result),
})
final = client.chat.completions.create(model="uncensored", messages=messages, tools=tools)
print(final.choices[0].message.content)
else:
print(msg.content)
Verifica siempre que tool_calls esté presente antes de leerlo. El modelo puede responder directamente, y tu código debe manejar ambos resultados.
Encadena pasos en un pipeline
Los flujos de trabajo reales rara vez se detienen en una llamada. Una forma común es borrador, revisión, reescritura: la primera llamada produce algo, la segunda lo critica según una lista de verificación y la tercera aplica la crítica. Cada paso es una petición separada con su propio mensaje del sistema, lo que mantiene las instrucciones cortas y los fallos fáciles de localizar.
from openai import OpenAI
client = OpenAI(
base_url="https://api.veo3apis.com/v1",
api_key="YOUR_API_KEY",
)
def step(system: str, user: str, temperature: float = 0.7) -> str:
resp = client.chat.completions.create(
model="uncensored",
messages=[
{"role": "system", "content": system},
{"role": "user", "content": user},
],
temperature=temperature,
max_tokens=800,
)
return resp.choices[0].message.content.strip()
topic = "a changelog entry for a new export feature"
draft = step("Write the requested text in under 120 words.", topic)
review = step(
"List at most three concrete problems with this text: vague wording, missing detail, wrong tone.",
draft,
temperature=0.2,
)
final = step(
"Rewrite the text so it fixes every listed problem. Reply with the text only.",
"TEXT:\n" + draft + "\n\nPROBLEMS:\n" + review,
)
print(final)
Observa la temperatura más baja en el paso de revisión. La crítica debe ser consistente de una ejecución a otra, mientras que el borrador se beneficia de algo de variedad. Si ejecutas la canalización sobre muchas entradas, coloca toda la función de tres pasos dentro del trabajador del grupo de hilos de la sección anterior, para que cada trabajador gestione un elemento desde el principio hasta el final y se respete el límite de 8 peticiones.
Mantén los resultados intermedios. Cuando el texto final es incorrecto, el borrador y la revisión te dicen en qué paso falló, y puedes corregir un mensaje del sistema en lugar de reescribir todo el pipeline. Escribir cada paso en un archivo JSON-lines con la entrada, las tres salidas y los IDs de petición facilita esto, y te da un punto de reanudación si el proceso se detiene a mitad de camino.
Rastrea el saldo y los IDs de petición
Cada respuesta lleva encabezados que vale la pena registrar: X-Request-Id identifica la llamada si contactas con soporte, X-Balance-USD muestra lo que queda de tu crédito, y los dos encabezados X-RateLimit-Limit reportan los límites de petición y concurrencia para tu clave. El SDK oculta los encabezados por defecto; usa el envoltorio de respuesta cruda para leerlos.
from openai import OpenAI
client = OpenAI(
base_url="https://api.veo3apis.com/v1",
api_key="YOUR_API_KEY",
)
raw = client.chat.completions.with_raw_response.create(
model="uncensored",
messages=[{"role": "user", "content": "Reply with the single word ready."}],
max_tokens=10,
)
print("request id:", raw.headers.get("X-Request-Id"))
print("balance usd:", raw.headers.get("X-Balance-USD"))
print("req limit:", raw.headers.get("X-RateLimit-Limit-Requests"))
print("concurrency limit:", raw.headers.get("X-RateLimit-Limit-Concurrency"))
resp = raw.parse()
print(resp.choices[0].message.content)
Los precios son $0,15 por millón de tokens de entrada y $0,50 por millón de tokens de salida, por lo que una llamada con 1.000 tokens de entrada y 500 de salida cuesta $0,00015 + $0,00025 = $0,0004. Un flujo de trabajo que ejecuta 5.000 de estas llamadas gasta $2,00. Imprime el saldo al inicio y al final de una ejecución, y sabrás cuánto cuesta cada lote sin necesidad de herramientas adicionales. Para tarifas y bonificaciones de recarga, consulta la página de precios; para cada parámetro admitido, lee la documentación de API.
Un hábito más que vale la pena adoptar: mantén los prompts fuera de tus registros a menos que los necesites. Los prompts enviados a esta API no se usan para entrenamiento, pero tus propios archivos de registro son tu responsabilidad.
Solución de problemas de una nueva configuración
La mayoría de los problemas de primera ejecución provienen de una lista corta de causas.
- La llamada se cuelga o da error al conectar. Verifica la URL base. Debe terminar en
/v1, y el SDK añade/chat/completionspor sí mismo. Una ruta duplicada es el error habitual. - Un error de autenticación. La clave falta, está truncada o tiene un espacio o salto de línea extra de un copiar y pegar. Imprime su longitud, no la clave misma, y compárala con lo que muestra la página de claves.
- Modelo no encontrado. El ID del modelo es
uncensored, en minúsculas. Llama al endpoint de modelos para ver exactamente qué puede usar tu clave. - 429 constante en un script pequeño. Es posible que estés en la clave de prueba, que permite 2 solicitudes concurrentes y 60 por minuto. Reduce el grupo a 2 hilos, o recarga para obtener una clave completa.
- Respuestas cortadas. Un
max_tokensbajo termina la respuesta antes. Auméntalo, o elimínalo y deja que el completado use el resto de la ventana. - Petición demasiado grande. El límite del cuerpo es 8 MB, y la ventana de tokens es de 100,000 tokens para prompt y completado juntos. Divide las entradas grandes en piezas y procesalas como llamadas separadas.
Cuando algo parece incorrecto por el lado del servicio, envía el valor de X-Request-Id al contacto en el sitio. Un ID de petición permite al operador encontrar tu llamada exacta, lo cual es mucho más útil que una descripción de lo que viste.
Más guías
Preguntas y respuestas
¿Necesito un SDK especial?
No. El SDK de Python oficial de OpenAI funciona una vez que configuras la URL base y tu clave.
¿Qué ID de modelo uso?
Usa uncensored. Puedes listar los IDs disponibles con GET /v1/models.
¿Cuántas peticiones pueden ejecutarse en paralelo?
Una clave completa permite 8 peticiones simultáneas y 300 por minuto. Una clave de prueba permite 2 y 60.
¿Funciona el streaming en el SDK de Python?
Sí. Pasa stream=True e itera sobre los fragmentos. El uso se informa al final del streaming.
Tu clave está a un formulario de distancia
Crea una cuenta, copia la clave, cambia la URL base. Esa es toda la configuración.