ES ▾

API de OpenAI en Python: Usa el SDK de OpenAI con nuestro modelo

Cable en forma de serpiente estilizada conectado a un servidor con burbujas de chat, representando a Python llamando a una API

Para código de la API de OpenAI en Python, no necesitas una biblioteca especial. El paquete oficial openai funciona con este servicio una vez que configuras una base URL y una clave diferentes, y el ID del modelo es uncensored. A continuación tienes una guía completa con ejemplos para copiar y pegar.

Actualizado

Puntos clave

  • Instala openai y pasa base_url y api_key al cliente; nada más en tu código cambia.
  • Streaming, modo JSON y llamadas a funciones funcionan todos a través de los mismos métodos del SDK.
  • Captura RateLimitError y reintenta; los límites son 300 peticiones por minuto y 8 concurrentes con una clave completa.
  • El costo es $0.15 por 1M de tokens de entrada y $0.50 por 1M de tokens de salida, cobrado solo por peticiones exitosas.

Instala y haz la primera llamada

Necesitas Python 3.9 o superior y el SDK oficial. Crea primero una clave de API en la página de claves; las cuentas nuevas pueden reclamar $0.50 de crédito de prueba con un solo clic, sin tarjeta.

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

Ahora el script mínimo funcional. El cliente toma la base URL y la clave; la petición usa el ID de modelo uncensored.

import os
from openai import OpenAI

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

resp = client.chat.completions.create(
    model="uncensored",
    messages=[
        {"role": "system", "content": "You are a concise writing assistant."},
        {"role": "user", "content": "Give me three opening lines for a mystery novel."},
    ],
    temperature=0.8,
)

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

Esa es toda la integración. El servicio implementa POST /v1/chat/completions y GET /v1/models, lo que cubre lo que usan la mayoría de scripts. Es solo un modelo de texto, por lo que los endpoints de imagen, audio y embeddings no están disponibles.

Qué es y qué no es

El SDK lo hizo OpenAI, pero el endpoint de aquí no es de OpenAI. Es un modelo de pesos abiertos alojado, ejecutado por un proveedor independiente y ajustado para responder sin rechazos de contenido para uso adulto lícito. No hay redirección a GPT ni a ningún modelo de otro proveedor. Por eso cambias la base URL: estás hablando con un servidor diferente que acepta el mismo formato de petición.

Si estás moviendo un proyecto existente, busca en él OpenAI( y los nombres de modelo codificados. Esos son los únicos dos lugares que necesitan edición. La lista de verificación de producción de la API GPT en este sitio cubre hábitos que aplican a cualquier endpoint de formato OpenAI, como los tiempos de espera y los reintentos.

Transmite la respuesta

Para interfaces de chat quieres los tokens a medida que se producen. Configura stream=True e itera. Pide el uso al final si quieres números de facturación:

stream = client.chat.completions.create(
    model="uncensored",
    messages=[{"role": "user", "content": "Write a four-line poem about a night train."}],
    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("\ntokens:", chunk.usage.prompt_tokens, chunk.usage.completion_tokens)

La comprobación en chunk.choices es importante: el último fragmento puede contener el uso y ninguna entrada en choices. Además, una petición en streaming ocupa una de tus ranuras concurrentes hasta que termina el streaming, así que léela siempre hasta el final o ciérrala.

Modo JSON

Cuando tu código necesita analizar la respuesta, activa el modo JSON y describe las claves en el prompt:

import json

resp = client.chat.completions.create(
    model="uncensored",
    response_format={"type": "json_object"},
    messages=[
        {"role": "user", "content": "Return JSON with keys name (string) and traits (list of 3 strings) for a fictional ship captain."}
    ],
)
character = json.loads(resp.choices[0].message.content)
print(character["name"], character["traits"])

JSON válido es el resultado probable, no una promesa de tu esquema exacto, así que verifica las claves y reintenta una vez en caso de fallo.

Llamadas a funciones

Describe funciones en tools, ejecuta lo que pida el modelo y envía el resultado de vuelta con role: "tool":

import json

tools = [{
    "type": "function",
    "function": {
        "name": "roll_dice",
        "description": "Roll a die with the given number of sides",
        "parameters": {
            "type": "object",
            "properties": {"sides": {"type": "integer"}},
            "required": ["sides"],
        },
    },
}]

messages = [{"role": "user", "content": "Roll a 20-sided die for my character."}]
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 = {"value": 14, "sides": args["sides"]}  # replace with real logic
        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)

Puedes pasar tool_choice para forzar una función. Los argumentos vienen como una cadena JSON, así que ejecútalos siempre con json.loads y valídalos antes de usarlos.

Errores, reintentos y async

El SDK reintenta algunos fallos por sí solo, y puedes configurar el conteo con max_retries. Para límites de velocidad, captura la excepción y espera. La API devuelve HTTP 429 con el código rate_limited cuando superas el límite por minuto, con concurrency cuando hay demasiadas peticiones simultáneas, y con un encabezado Retry-After: 5 en sobrecarga temporal.

import time
from openai import RateLimitError

def ask(prompt, tries=4):
    for attempt in range(tries):
        try:
            r = client.chat.completions.create(
                model="uncensored",
                messages=[{"role": "user", "content": prompt}],
            )
            return r.choices[0].message.content
        except RateLimitError:
            time.sleep(5 * (attempt + 1))
    raise RuntimeError("Still rate limited after retries")

Para lotes, usa el cliente asíncrono y limita la paralelización por debajo de tu límite. Una clave completa permite 8 peticiones concurrentes y 300 por minuto; una clave de prueba permite 2 y 60.

import asyncio, os
from openai import AsyncOpenAI

aclient = AsyncOpenAI(base_url="https://api.aiapisource.com/v1", api_key=os.environ["API_KEY"])
sem = asyncio.Semaphore(6)

async def one(prompt):
    async with sem:
        r = await aclient.chat.completions.create(
            model="uncensored",
            messages=[{"role": "user", "content": prompt}],
        )
        return r.choices[0].message.content

async def main():
    prompts = [f"Write a tagline for product number {i}." for i in range(20)]
    results = await asyncio.gather(*(one(p) for p in prompts))
    print(len(results), "done")

asyncio.run(main())

Usar 6 de las 8 ranuras deja espacio para otro tráfico en la misma clave.

Mantén una conversación

La API es sin estado. No recuerda nada entre llamadas, así que un chat es solo la lista de mensajes que envías cada vez. Añade la respuesta a la lista y envía toda la lista de nuevo:

history = [{"role": "system", "content": "You are a patient writing coach."}]

def chat(user_text):
    history.append({"role": "user", "content": user_text})
    r = client.chat.completions.create(model="uncensored", messages=history)
    reply = r.choices[0].message.content
    history.append({"role": "assistant", "content": reply})
    return reply

print(chat("Give me a prompt for a short story."))
print(chat("Make it darker and set it in a harbour town."))

Cada llamada envía más tokens que la anterior, y los tokens de entrada se facturan en cada llamada. Cuando la lista se alarga, elimina los turnos más antiguos o reemplázalos con un resumen breve. La ventana de contexto es de 100,000 tokens para prompt más completado, que es mucho, pero un historial largo hace que cada petición sea más cara y más lenta para iniciar.

Los parámetros de muestreo se pasan tal cual: temperature, top_p, stop, seed y las penalizaciones de frecuencia y presencia. Configura seed y una temperatura baja cuando quieras ejecuciones de prueba repetibles.

Estima el costo antes de una ejecución grande

La facturación es por token desde crédito prepago: $0.15 por 1M de tokens de entrada y $0.50 por 1M de tokens de salida. Las peticiones fallidas o rechazadas no se cobran, y el crédito no caduca. Toma un lote de 10,000 peticiones con 1,500 tokens de entrada y 400 tokens de salida cada una. La entrada es 15,000,000 de tokens, que son 15 x $0.15 = $2.25. La salida es 4,000,000 de tokens, que son 4 x $0.50 = $2.00. El lote cuesta $4.25.

Los encabezados de respuesta incluyen X-Balance-USD, así que puedes leer tu saldo restante en código a través de client.chat.completions.with_raw_response.create(...). Las recargas son cualquier cantidad entera desde $20 hasta $500, con +5% desde $50, +10% desde $100 y +15% desde $200. La página de precios lista las opciones de pago, y el inicio rápido lista cada parámetro admitido, incluyendo stop, seed y las penalizaciones.

Preguntas y respuestas

¿Puedo usar el paquete oficial de Python de OpenAI con esta API?

Sí. Instala openai, configura base_url con el endpoint del servicio y api_key con tu clave, y llama a chat.completions.create con el modelo uncensored.

¿Necesito una biblioteca diferente para streaming o herramientas?

No. Streaming, modo JSON y llamadas a funciones funcionan a través de los mismos métodos del SDK, con los parámetros habituales.

¿Es este el modelo de OpenAI?

No. Es un modelo de pesos abiertos gestionado por un proveedor independiente. El formato de petición es el mismo, por eso funciona el SDK.

¿Mis prompts entrenan el modelo?

No. Los prompts enviados a través de la API no se utilizan para entrenamiento.

Tu clave está a un formulario de distancia

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

Obtener clave de API