ES ▾
Obtener clave de API

uncensoredqwen.comGuía

SDK de API Qwen: usa el SDK de Python de OpenAI

No se requiere un SDK de API dedicado para qwen. Esta API utiliza el formato de cableado de OpenAI, por lo que los SDK oficiales de OpenAI funcionan una vez que cambies la URL base y la clave. Esta página muestra la instalación, la primera llamada, streaming, herramientas y manejo de errores.

Actualizado

Adaptador isomórfico que conecta un socket de SDK estándar a un pequeño servidor, mostrando la reutilización del SDK de OpenAI

Por qué el SDK de OpenAI cubre lo que necesitas

Cuando la gente busca un sdk de api qwen, generalmente quiere una biblioteca de clientes que maneje autenticación, reintentos, streaming y respuestas tipadas. Los SDK de OpenAI ya hacen todo eso, y este servicio implementa la misma interfaz HTTP: POST /v1/chat/completions, POST /v1/responses y GET /v1/models. Cualquier cliente que te permita sobrescribir la URL base puede comunicarse con él.

Una aclaración antes de comenzar. Esta no es la API oficial de Alibaba ni de ningún otro proveedor de modelos, y no es un enrutador que reenvía tu solicitud a otro lugar. Es un modelo de pesos abiertos, ejecutado por un proveedor independiente y ajustado para responder sin rechazos de contenido para uso adulto lícito. El único ID de modelo que pasas es uncensored.

Esto hace que la migración sea simple. Si tu proyecto ya llama a un modelo de chat alojado a través del SDK de OpenAI, cambias tres valores: la URL base, la clave de API y el nombre del modelo. Nada más en tu código tiene que moverse.

Instala y haz la primera llamada

Instala el paquete oficial para Python o Node. No hay nada específico del servicio que agregar.

pip install openai
# Node: npm install openai

Crea una clave en la página de clave de API, luego expórtala para que nunca llegue a tu código fuente.

export API_KEY="paste-your-key-here"

Ahora el script de Python más útil. El cliente lee la clave del entorno y envía solicitudes al servicio en lugar de a OpenAI.

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.uncensoredqwen.com/v1",
    api_key=os.environ["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)

Si prefieres HTTP crudo, la misma solicitud en curl se ve así:

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

Respuestas en streaming con el SDK

Establece stream=True e itera sobre los fragmentos. El servicio envía eventos enviados por el servidor e informa el uso de tokens al final del streaming, para que puedas registrar el costo sin una segunda llamada.

import os
from openai import OpenAI

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

stream = client.chat.completions.create(
    model="uncensored",
    messages=[{"role": "user", "content": "Write a short product description for a desk lamp."}],
    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 getattr(chunk, "usage", None):
        print("\nTokens:", chunk.usage.prompt_tokens, chunk.usage.completion_tokens)

Ten en cuenta una cosa: una solicitud en streaming mantiene su ranura de concurrencia hasta que termina el flujo. Si un consumidor es lento o olvidas cerrar el flujo, alcanzarás el límite de concurrencia antes de lo que esperas.

El mismo patrón en Node:

import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.uncensoredqwen.com/v1",
  apiKey: process.env.API_KEY,
});

const stream = await client.chat.completions.create({
  model: "uncensored",
  messages: [{ role: "user", content: "Name three uses of JSON mode." }],
  stream: true,
});

for await (const chunk of stream) {
  process.stdout.write(chunk.choices[0]?.delta?.content ?? "");
}

Llamadas a herramientas y modo JSON

Los parámetros del SDK que ya usas para herramientas pasan directamente: tools, tool_choice, streaming tool_calls, y los resultados enviados de vuelta como mensajes con role: "tool". Un ciclo de ida y vuelta mínimo se ve así:

import os, json
from openai import OpenAI

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

tools = [{
    "type": "function",
    "function": {
        "name": "get_order_status",
        "description": "Look up an order by 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)
call = first.choices[0].message.tool_calls[0]

messages.append(first.choices[0].message)
messages.append({
    "role": "tool",
    "tool_call_id": call.id,
    "content": json.dumps({"status": "shipped"}),
})
final = client.chat.completions.create(model="uncensored", messages=messages, tools=tools)
print(final.choices[0].message.content)

Para salida estructurada, pasa response_format={"type": "json_object"} y también di "responde en JSON" en el prompt. El modo JSON pide al modelo una salida JSON, pero tu código aún debe analizarlo y validar nombres de campos y tipos antes de usarlos.

Los ajustes de muestreo como temperature, top_p, stop, seed y las penalizaciones se pasan directamente, por lo que el ajuste existente se conserva.

Maneja errores 429 y lee los encabezados

El SDK lanza una excepción de límite de peticiones en HTTP 429, y el cuerpo de la respuesta te indica qué límite alcanzaste. Una clave completa permite 8 peticiones simultáneas y 300 peticiones por minuto. Una clave de prueba permite 2 peticiones simultáneas y 60 por minuto.

Código de errorSignificadoQué hacer
rate_limitedDemasiadas peticiones por minutoDistribuye las llamadas o agrega un limitador del lado del cliente
concurrencyDemasiadas peticiones a la vezLimita tu grupo de trabajadores a 8 (2 en una clave de prueba)
429 con Retry-After: 5Sobrecarga temporalEspera 5 segundos y reintenta

Cada respuesta lleva X-Request-Id, X-Balance-USD, X-RateLimit-Limit-Requests y X-RateLimit-Limit-Concurrency. Para leerlos con el SDK de Python, usa el envoltorio de respuesta cruda:

import os
from openai import OpenAI

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

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

Las solicitudes fallidas o rechazadas no se cobran, por lo que un reintento después de un 429 no te cuesta dos veces. El artículo existente sobre errores comunes de API Qwen cubre más de los errores de configuración que la gente encuentra.

Cuánto cuesta una llamada

La tarifa es $0,15 por 1M tokens de entrada y $0,50 por 1M tokens de salida, pagados desde crédito prepago. Toma una solicitud con 2.000 tokens de prompt y 500 tokens de finalización:

  • Entrada: 2.000 x $0,15 / 1.000.000 = $0,0003
  • Salida: 500 x $0,50 / 1.000.000 = $0,00025
  • Total: $0,00055

El crédito de prueba de $0,50 cubre aproximadamente 900 peticiones de ese tamaño ($0,50 / $0,00055 es aproximadamente 909). El crédito de prueba se obtiene con un clic en la página de claves después de iniciar sesión, no requiere tarjeta y dura 7 días; el artículo sobre el nivel gratuito explica cómo funciona. Las recargas pagadas comienzan en $20, y la página de precios enumera los niveles de bonificación y los métodos de pago aceptados.

El contexto es de 100,000 tokens para prompt más finalización juntos, y max_tokens es opcional. Establecerlo sigue siendo una buena práctica cuando quieres un límite superior predecible en el costo.

Migrar un proyecto existente

La mayoría de los lectores llegan con código que ya llama a un modelo de chat. Una lista de verificación breve mantiene el cambio sin incidentes:

  1. Cambia base_url (o baseURL en Node) a https://api.uncensoredqwen.com/v1. Mantén el sufijo /v1 y no agregues /chat/completions tú mismo, porque el SDK adjunta la ruta.
  2. Reemplaza la clave con la de tu cuenta. La autenticación es un encabezado estándar Authorization: Bearer, que el SDK construye para ti.
  3. Reemplaza el nombre del modelo con uncensored. Las solicitudes con un nombre de modelo desconocido fallarán, así que busca en tu base de código nombres codificados.
  4. Elimina cualquier campo de solicitud para funciones que el servicio no ofrece, como entradas de imagen o llamadas de incrustaciones.
  5. Ejecuta una llamada a GET /v1/models como prueba de humo. Si enumera el modelo, tu URL y clave son correctas.

Los frameworks que envuelven el cliente de OpenAI suelen exponer las mismas dos configuraciones bajo nombres como openai_api_base o OPENAI_BASE_URL. Si tu herramienta ofrece una variable de entorno para la URL base, puedes cambiar toda una aplicación sin tocar su código fuente. Prueba primero con una clave de prueba, ya que sus límites más bajos de 2 solicitudes simultáneas y 60 por minuto mostrarán rápidamente si tu aplicación abre más conexiones simultáneas de las que planeaste.

El manejo del contexto merece una segunda mirada también. La ventana aquí es de 100.000 tokens compartidos por prompt y finalización. Si tu configuración anterior recortaba el historial a un tamaño diferente, puedes relajar o ajustar ese recorte para que coincida, pero vigila el costo de reenviar un historial largo en cada turno.

Consejos prácticos para código de producción

  • Mantén la clave fuera del repositorio. Léela desde una variable de entorno o una tienda de secretos, como en los ejemplos anteriores.
  • Establece un tiempo de espera. El SDK acepta un argumento timeout en el cliente. Las generaciones largas con streaming necesitan un tiempo de espera de lectura generoso.
  • Limita tus trabajadores. Un grupo de subprocesos o semáforo dimensionado a tu límite de concurrencia evita la mayoría de los errores 429 antes de que ocurran.
  • Registra el ID de petición. Si contactas a soporte, el valor de X-Request-Id identifica la llamada.
  • Vigila el saldo. Lee X-Balance-USD de las respuestas, o llama a GET /v1/balance, para que un trabajo por lotes se detenga antes de que se agote el crédito.

El modelo es solo de texto. No hay generación de imágenes, audio o video, ni incrustaciones ni ajuste fino, así que no planifiques en torno a esos métodos de SDK. Los detalles completos de los parámetros están en la documentación. Los prompts no se usan para entrenamiento.

Preguntas y respuestas

¿Existe un SDK oficial de API Qwen para este servicio?

No se necesita un SDK separado. Usa los paquetes oficiales de OpenAI para Python o Node y establece URL base en https://api.uncensoredqwen.com/v1 con el modelo uncensored.

¿Qué lenguajes de SDK son compatibles?

Cualquier cliente compatible con OpenAI funciona, incluidos los paquetes oficiales de Python y Node, curl y bibliotecas de la comunidad que te permiten sobrescribir la URL base.

¿Cómo verifico mi saldo desde el código?

Lee la cabecera X-Balance-USD en cualquier respuesta, o llama a GET /v1/balance. El endpoint credit_grants al estilo OpenAI también está disponible.

¿El SDK admite streaming y herramientas?

Sí. Establece stream a true para eventos enviados por el servidor con el uso al final, y usa tools y tool_choice como lo harías con OpenAI.

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