Cómo implementar un LLM en Python con una API alojada
Para la mayoría de los proyectos, implementar un LLM en Python se reduce a llamar a un modelo alojado por HTTP, no a entrenarlo o servirlo tú mismo. Con una API compatible con OpenAI, se necesitan unas diez líneas, y el mismo código se expande para incluir streaming, salida JSON y llamadas a funciones.
Actualizado

Puntos clave
- Instala el paquete openai, configura una URL base y una clave, y usa el ID de modelo uncensored.
- El streaming, el modo JSON y las llamadas a funciones son compatibles y usan los argumentos estándar del SDK.
- Mantén el historial de chat en una lista y vigila la ventana de 100,000 tokens.
- Maneja el HTTP 429 con un reintento breve; las peticiones fallidas o rechazadas no se cobran.
Empieza con crédito de prueba
Correo y contraseña; la clave aparece al instante en pantalla.
Obtener clave de APIAPI alojada o tu propio modelo
Hay dos formas de integrar un modelo de lenguaje en un programa Python. Puedes ejecutar los pesos tú mismo, lo que implica una GPU, una pila de servicio, opciones de cuantización y mucho tiempo de espera para las descargas. O puedes enviar peticiones a un modelo que ya ejecuta otra persona. La primera ruta tiene sentido para investigación, aislamiento estricto de datos o un volumen constante muy alto. La segunda se adapta a casi todo lo demás: un script, un bot, una función de producto, un prototipo que quieres que funcione para el almuerzo.
Esta guía toma la segunda ruta. El servicio aquí es una API de texto alojada y compatible con OpenAI con un solo modelo de pesos abiertos, ejecutado por un proveedor independiente y ajustado para responder sin rechazos de contenido para uso adulto lícito. No es una API oficial de ningún proveedor de modelos. Como sigue el formato de petición de OpenAI, funciona el paquete estándar openai, y también funciona requests si prefieres no tener dependencias.
Paso 1: instalar y hacer la primera llamada
Instala el SDK y almacena tu clave en una variable de entorno, para que nunca llegue a tu código fuente.
pip install openai
export API_KEY="your-key-here"
Luego crea un cliente con la URL base del servicio. Las únicas cosas que cambias en comparación con cualquier otra configuración estilo OpenAI son la URL, la clave y el nombre del modelo.
import os
from openai import OpenAI
client = OpenAI(
base_url="https://api.fluxapikey.com/v1",
api_key=os.environ["API_KEY"],
)
resp = client.chat.completions.create(
model="uncensored",
messages=[
{"role": "system", "content": "You are a concise assistant."},
{"role": "user", "content": "Explain list comprehensions in two sentences."},
],
)
print(resp.choices[0].message.content)
print(resp.usage)
Ese es un programa completo y funcional. El endpoint detrás de esto es POST /v1/chat/completions, autenticado con Authorization: Bearer <key>, y GET /v1/models lista el ID del modelo. Puedes obtener una clave y un pequeño crédito de prueba en la página de claves.
Paso 2: transmitir la respuesta
Esperar varios segundos por una respuesta completa se siente lento en una terminal o una página web. Configura stream=True e imprime los tokens a medida que llegan mediante eventos enviados por el servidor.
# client from step 1: base_url https://api.fluxapikey.com/v1
stream = client.chat.completions.create(
model="uncensored",
messages=[{"role": "user", "content": "Write a short story opening about a lighthouse keeper."}],
stream=True,
)
for chunk in stream:
if chunk.choices and chunk.choices[0].delta.content:
print(chunk.choices[0].delta.content, end="", flush=True)
print()
Los números de uso llegan al final del stream, por lo que el último fragmento puede no tener elecciones. Por eso el bucle verifica chunk.choices primero. Una cosa a recordar: una petición en streaming mantiene su espacio de concurrencia hasta que termina el stream, así que siempre léelo hasta el final o ciérralo.
Paso 3: mantener una conversación
El modelo no tiene memoria entre llamadas. Un chat es solo una lista de mensajes que crece y que reenvías cada vez. Una pequeña clase es suficiente:
# client from step 1: base_url https://api.fluxapikey.com/v1
class Chat:
def __init__(self, system):
self.messages = [{"role": "system", "content": system}]
def say(self, text):
self.messages.append({"role": "user", "content": text})
r = client.chat.completions.create(model="uncensored", messages=self.messages)
answer = r.choices[0].message.content
self.messages.append({"role": "assistant", "content": answer})
return answer
bot = Chat("You are a patient Python tutor.")
print(bot.say("What is a generator?"))
print(bot.say("Show me one with yield."))
La ventana de contexto es de 100,000 tokens, compartida por el prompt y la completación. Es un espacio amplio, pero un chat largo crece con cada turno, y pagas por todo el historial en cada petición. Cuando se hace grande, elimina los turnos más antiguos o reemplázalos con un resumen breve que le pidas al modelo que escriba.
Paso 4: obtener salida estructurada
Los programas quieren datos, no párrafos. El modo JSON hace que la respuesta sea JSON válido. Indica en el prompt qué claves esperas.
# client from step 1: base_url https://api.fluxapikey.com/v1
import json
r = client.chat.completions.create(
model="uncensored",
response_format={"type": "json_object"},
messages=[
{"role": "system", "content": 'Return JSON like {"title": str, "tags": [str]}.'},
{"role": "user", "content": "Summarise: a tutorial on async IO in Python."},
],
)
data = json.loads(r.choices[0].message.content)
print(data["title"], data["tags"])
JSON válido no garantiza tus claves. Verifícalas en el código y reintenta una vez si falta una.
Paso 5: permitir que el modelo llame a tus funciones
Las llamadas a funciones permiten que el modelo le pida a tu programa que ejecute una función, y luego continúe con el resultado. Describes la herramienta, verificas si la respuesta contiene una llamada, la ejecutas y envías la salida de vuelta con el rol tool.
# client from step 1: base_url https://api.fluxapikey.com/v1
import json
tools = [{
"type": "function",
"function": {
"name": "get_word_count",
"description": "Count the words in a text.",
"parameters": {
"type": "object",
"properties": {"text": {"type": "string"}},
"required": ["text"],
},
},
}]
messages = [{"role": "user", "content": "How many words are in: the quick brown fox?"}]
r = client.chat.completions.create(model="uncensored", messages=messages, tools=tools, tool_choice="auto")
msg = r.choices[0].message
if msg.tool_calls:
messages.append(msg)
for call in msg.tool_calls:
args = json.loads(call.function.arguments)
result = len(args["text"].split())
messages.append({"role": "tool", "tool_call_id": call.id, "content": str(result)})
final = client.chat.completions.create(model="uncensored", messages=messages, tools=tools)
print(final.choices[0].message.content)
Valida siempre los argumentos antes de actuar sobre ellos, porque el modelo puede producir una llamada que no esperabas. Las llamadas a herramientas también se transmiten, como deltas de tool_calls, si lo necesitas. La documentación lista cada campo.
Paso 6: manejar límites y errores
Una clave completa permite 8 peticiones concurrentes y 300 por minuto; una clave de prueba permite 2 y 60. Si superas el límite, la API responde con HTTP 429. El código de error es rate_limited para demasiadas peticiones por minuto y concurrency para demasiadas a la vez. En una sobrecarga temporal también obtienes un 429, con un encabezado Retry-After: 5. Un pequeño envoltorio de reintento cubre los tres casos:
# client from step 1: base_url https://api.fluxapikey.com/v1
import time
from openai import RateLimitError
def ask(messages, tries=4):
for i in range(tries):
try:
return client.chat.completions.create(model="uncensored", messages=messages)
except RateLimitError:
time.sleep(5 * (i + 1))
raise RuntimeError("still limited after retries")
Si ejecutas trabajo en hilos, límitalos a 8 con un ThreadPoolExecutor(max_workers=8) para que raramente alcances el límite de concurrencia. Cada respuesta lleva X-Request-Id, que es lo que debes citar si contactas a soporte, y X-Balance-USD muestra tu crédito restante. El tamaño máximo del cuerpo es de 8 MB.
Configuraciones que cambian la salida
La mayor parte del ajuste día a día ocurre en un puñado de parámetros, todos pasados al modelo.
temperaturecontrola la aleatoriedad. Usa 0.2 o menos para extracción y clasificación, alrededor de 0.7 para chat, y 1.0 o más para lluvia de ideas y ficción.top_precorta la cola poco probable de elecciones de palabras. Cambia top_p o la temperatura, no los dos, no ambos a la vez, para que puedas saber cuál hizo el trabajo.seedhace que las ejecuciones repetidas sean más comparables. Es útil en pruebas donde quieres ver el efecto de un cambio en el prompt y no el ruido.stoptermina la generación en una cadena que elijas, lo cual es útil para cortar un modelo que sigue añadiendo comentarios.max_tokenses opcional. Sin él, la completación puede usar lo que quede de la ventana de 100,000 tokens. Configúralo cuando quieras un límite estricto de longitud y costo.- Las penalizaciones de frecuencia y presencia desalientan la repetición, lo que ayuda con la salida creativa larga que empieza a entrar en bucle.
Anota las configuraciones que usaste junto a cualquier salida que te importe. Meses después, "por qué respondió diferente" casi siempre es un parámetro cambiado o un mensaje de sistema cambiado.
Ejecutar muchas peticiones a la vez
Un bucle que envía una petición a la vez desperdicia la mayor parte de tu cuota. Con una clave completa puedes tener 8 peticiones en vuelo, por lo que un grupo de hilos reduce un lote largo a aproximadamente una octava parte del tiempo de pared.
from concurrent.futures import ThreadPoolExecutor
from openai import OpenAI
client = OpenAI(base_url="https://api.fluxapikey.com/v1", api_key="YOUR_KEY")
def summarise(text):
r = client.chat.completions.create(
model="uncensored",
messages=[{"role": "user", "content": "Summarise in one line: " + text}],
max_tokens=60,
)
return r.choices[0].message.content
texts = ["first document", "second document", "third document"]
with ThreadPoolExecutor(max_workers=8) as pool:
for line in pool.map(summarise, texts):
print(line)
Mantén el recuento de trabajadores en o por debajo de 8, o en 2 en una clave de prueba. Si aún ves respuestas 429 con el código concurrency, reduce el número en uno o dos. El límite de 300 por minuto importa para peticiones rápidas y cortas, por lo que un lote de llamadas pequeñas puede alcanzarlo antes que el límite de concurrencia.
Problemas comunes y soluciones
La mayoría de los errores del primer día provienen de una lista corta de causas.
- 401 o error de autenticación. La clave falta, está mal escrita o se envía al host equivocado. Imprime la URL base que realmente usa tu cliente y asegúrate de que termine en
/v1. - Modelo no encontrado. El ID del modelo debe ser
uncensored. Llama aGET /v1/modelssi quieres confirmar qué lista el servidor. - Respuesta vacía o cortada. Un
max_tokensbajo detiene la respuesta a mitad de frase. Auméntalo o elimínalo. Verificafinish_reasonen la elección:lengthsignifica que se alcanzó el límite. - JSON que no se puede analizar. O bien la respuesta fue truncada, o el prompt nunca describió la forma. Corrige el prompt primero y envuelve el análisis en un bloque try.
- Primer token lento. Un prompt muy largo tarda más en procesarse. Recorta el historial o envía menos contexto.
- Petición demasiado grande. El límite del cuerpo es de 8 MB, y la ventana de tokens es de 100,000. Divide documentos grandes en piezas y resume cada una.
Cuando algo aún parece incorrecto, registra el encabezado X-Request-Id con la entrada fallida. Esto permite a soporte encontrar la petición exacta.
Lo que cuesta
Pagas $0.15 por cada 1M de tokens de entrada y $0.50 por cada 1M de tokens de salida desde tu crédito prepago. Una llamada típica con 2.000 tokens de entrada y 500 de salida cuesta 0,002 x $0,15 = $0,0003 por entrada más 0,0005 x $0,50 = $0,00025 por salida, es decir, $0,00055 en total. Diez mil llamadas de este tipo cuestan $5,50. Las peticiones fallidas o rechazadas no se cobran y el crédito no caduca. Las recargas van desde $20 hasta $500; consulta precios para ver los niveles de bonificación. Los prompts no se usan para entrenamiento.
Los tokens de salida cuestan más que los de entrada, así que el hábito más económico es pedir respuestas cortas: di dos frases, o solo JSON, y establece max_tokens en un límite razonable. Lee resp.usage durante el desarrollo para ver los conteos reales de tokens de tus prompts y multiplica por las tarifas anteriores antes de escalar un trabajo. El encabezado X-Balance-USD muestra lo que queda después de cada llamada.
Más guías
Preguntas y respuestas
¿Necesito una GPU para implementar un LLM en Python?
No con una API alojada. Tu código de Python solo envía peticiones HTTP, así que funciona con cualquier portátil.
¿Puedo usar el paquete oficial de openai?
Sí. Establece base_url a la URL del servicio y api_key a tu clave, y usa el ID de modelo uncensored.
¿Soporta código asíncrono?
El cliente AsyncOpenAI del SDK funciona con la misma base URL y clave. Mantén la concurrencia en o por debajo de 8 peticiones.
¿Cómo puedo probarlo sin pagar?
Regístrate y reclama el crédito de prueba de $0,50 en la página de claves. Es válido durante 7 días y no requiere tarjeta.
Tu clave está a un formulario de distancia
Crea una cuenta, copia la clave, cambia la URL base. Esa es toda la configuración.