ES ▾
Obtener clave de API

Ejemplos de la API GLM: Python, modo JSON y streaming

Estos ejemplos de la API GLM se ejecutan contra un único endpoint compatible con OpenAI, con la URL base https://api.glmapikey.com/v1 y el modelo uncensored. Cada fragmento es breve y autónomo, para que puedas pegarlo, añadir tu clave y ejecutarlo.

Actualizado

Ventana de terminal con streaming de tokens de datos brillantes hacia un servidor en la nube, ilustrando ejemplos de código de API

Puntos clave

  • Cada ejemplo usa la URL base https://api.glmapikey.com/v1, autenticación bearer y el ID del modelo uncensored.
  • El endpoint de completiones de chat admite streaming, modo JSON y llamadas a funciones.
  • Lee X-Balance-USD y el bloque de uso para rastrear el gasto por llamada.
  • Maneja el 429 por código: rate_limited, concurrencia o un Retry-After: 5 por sobrecarga.

Antes de ejecutar cualquier cosa

Solo necesitas una clave. Crea una en la página de clave de API; las cuentas nuevas pueden reclamar $0,50 de crédito de prueba con un solo clic, sin tarjeta. Exporta la clave para que los ejemplos puedan leerla:

export API_KEY="YOUR_KEY"
pip install openai
npm install openai

La API sigue el formato de completiones de chat de OpenAI. Expone POST /v1/chat/completions y GET /v1/models, acepta Authorization: Bearer y ofrece un único modelo con el ID uncensored. Este modelo es de pesos abiertos, ejecutado por un proveedor independiente y ajustado para responder sin rechazos de contenido para uso adulto lícito. No es la API oficial de ningún proveedor de modelos. Solo maneja texto: sin imágenes, audio, embeddings ni ajuste fino.

Los ejemplos a continuación van desde la llamada más simple hasta las llamadas a funciones. Si solo necesitas la comprobación más breve para verificar que tu clave funciona, el primer comando curl es suficiente.

Una primera petición con curl y los parámetros que importan

curl https://api.glmapikey.com/v1/chat/completions \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "uncensored",
    "messages": [
      {"role": "system", "content": "You are a concise assistant."},
      {"role": "user", "content": "What is a mutex, in one sentence?"}
    ],
    "temperature": 0.3,
    "max_tokens": 80
  }'

La respuesta es un objeto JSON con choices[0].message.content que contiene la respuesta y un objeto usage con prompt_tokens y completion_tokens. Los encabezados de respuesta incluyen X-Request-Id, X-Balance-USD y los dos encabezados X-RateLimit-Limit. Añade -i a curl para verlos.

Los campos temperature, top_p, stop, seed y las penalizaciones de presencia y frecuencia se pasan al modelo. max_tokens es opcional. Sin él, la completión puede usar todo lo que quede de la ventana de 100.000 tokens después de tu prompt.

El cuerpo de las completiones de chat tiene muchos campos opcionales, pero cinco hacen la mayor parte del trabajo. Todos se pasan al modelo.

CampoQué haceUso típico
temperatureValores más altos dan una redacción más variada0.2 para extracción, 0.8 para ficción
top_pLimita el muestreo a los tokens más probablesDéjalo en el valor predeterminado a menos que lo ajustes
stopTermina la respuesta cuando aparece una cadenaCortar en un delimitador como una línea en blanco
seedHace que el muestreo sea repetible en la medida de lo posibleComparar dos versiones de prompt
presence_penalty, frequency_penaltyDesalienta la repetición de tokensValores pequeños como 0.3 cuando el texto se repite

Cambia un valor a la vez y mantén el prompt igual, de lo contrario no podrás saber qué cambio ayudó. Para cualquier cosa que procese código, como clasificación o extracción, usa una temperatura baja y una semilla fija para que puedas volver a ejecutar una prueba y ver el mismo resultado. Para escritura creativa, aumenta la temperatura y deja que las penalizaciones manejen la repetición.

El campo max_tokens es opcional aquí. Si lo omites, la respuesta puede usar todo el espacio restante en la ventana de 100.000 tokens, lo cual rara vez es lo que quieres para una respuesta de una línea. Establece este valor cuando sepas la longitud que debe tener la respuesta.

Python: una conversación con memoria

La API es sin estado, así que tú mantienes la conversación y la envías cada vez. Este bucle mantiene una lista de mensajes y añade ambos lados:

from openai import OpenAI

client = OpenAI(
    base_url="https://api.glmapikey.com/v1",
    api_key="YOUR_KEY",
)

messages = [{"role": "system", "content": "You are a helpful assistant."}]

while True:
    user = input("you> ")
    if not user:
        break
    messages.append({"role": "user", "content": user})
    resp = client.chat.completions.create(model="uncensored", messages=messages)
    reply = resp.choices[0].message.content
    messages.append({"role": "assistant", "content": reply})
    print("bot>", reply)

Como cada llamada reenvía la lista completa, los tokens de entrada crecen con la longitud del chat. A $0,15 por 1M de tokens de entrada es barato, pero se acumula en sesiones largas, así que recorta los mensajes antiguos una vez que el hilo supere el tamaño que quieres pagar. La página de precios tiene ejemplos prácticos.

Streaming en Python y Node

Establece stream: true y el servidor envía tokens a medida que se producen, mediante eventos enviados por el servidor. En Python:

stream = client.chat.completions.create(
    model="uncensored",
    messages=[{"role": "user", "content": "Write four lines about the sea."}],
    stream=True,
)

text = ""
for chunk in stream:
    if chunk.choices and chunk.choices[0].delta.content:
        piece = chunk.choices[0].delta.content
        text += piece
        print(piece, end="", flush=True)
    if getattr(chunk, "usage", None):
        print("\ntokens:", chunk.usage.prompt_tokens, chunk.usage.completion_tokens)

El stream termina con información de uso, por eso el bucle lo verifica. Lo mismo en Node:

import OpenAI from "openai";

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

const stream = await client.chat.completions.create({
  model: "uncensored",
  messages: [{ role: "user", content: "Write four lines about the sea." }],
  stream: true,
});

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

Un detalle sobre los límites: una petición en streaming mantiene su ranura de concurrencia hasta que termina el stream. Si inicias un stream y nunca lo lees hasta el final, esa ranura se mantiene ocupada. Siempre consume o cierra el stream.

Modo JSON para salida estructurada

Cuando tu código necesite analizar la respuesta, pide un objeto JSON con response_format. También indica en el prompt qué forma quieres, porque la bandera de formato garantiza una sintaxis JSON válida, no tu esquema particular.

import json

resp = client.chat.completions.create(
    model="uncensored",
    response_format={"type": "json_object"},
    messages=[
        {"role": "system", "content": "Reply only with JSON: {\"title\": string, \"tags\": [string]}."},
        {"role": "user", "content": "Suggest a title and three tags for a post about home espresso."},
    ],
    temperature=0.2,
)

data = json.loads(resp.choices[0].message.content)
print(data["title"], data["tags"])

Verifica que las claves que necesitas existen antes de usarlas y mantén la temperatura baja para tareas de extracción. Si un análisis falla, reintentar una vez con la misma entrada suele funcionar, y las peticiones fallidas no se cobran.

Llamadas a funciones: un viaje de ida y vuelta completo

Las llamadas a funciones permiten que el modelo pida a tu código que ejecute una función. Describes la función en tools, el modelo responde con una entrada tool_calls, la ejecutas y envías el resultado de nuevo como un mensaje role: "tool".

import json

def get_weather(city: str) -> dict:
    return {"city": city, "temp_c": 18, "sky": "cloudy"}

tools = [{
    "type": "function",
    "function": {
        "name": "get_weather",
        "description": "Get current weather for a city",
        "parameters": {
            "type": "object",
            "properties": {"city": {"type": "string"}},
            "required": ["city"],
        },
    },
}]

messages = [{"role": "user", "content": "Is it warm in Lisbon right now?"}]
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": json.dumps(get_weather(**args)),
        })
    final = client.chat.completions.create(
        model="uncensored", messages=messages, tools=tools
    )
    print(final.choices[0].message.content)
else:
    print(msg.content)

La función aquí devuelve datos fijos, así que cámbiala por una búsqueda real. Los argumentos de la herramienta llegan como una cadena JSON, así que siempre analízalos y valida los valores antes de actuar. Con stream: true, los tool_calls llegan en trozos que debes ensamblar antes de analizar. Usa tool_choice para forzar una herramienta específica cuando lo necesites.

Lo que cuestan los ejemplos y errores que desperdician una hora

Ejecutar ejemplos cuesta muy poco, pero ayuda ver la aritmética una vez. A $0,15 por 1M de tokens de entrada y $0,50 por 1M de tokens de salida:

  • El bucle de conversación, con un prompt de 1.200 tokens y una respuesta de 300 tokens: $0,00018 para entrada más $0,00015 para salida son $0,00033. Mil turnos cuestan $0,33.
  • La ida y vuelta de la herramienta hace dos llamadas. Si la primera usa 400 tokens de entrada y 60 de salida, y la segunda 500 de entrada y 150 de salida, los totales son 900 de entrada y 210 de salida: $0,000135 más $0,000105 es $0,00024.
  • El streaming cuesta lo mismo que una llamada normal con los mismos recuentos de tokens. Cambia cuando ves el texto, no lo que cuesta.

El crédito de prueba de $0,50 pagaría por más de 1.500 vueltas del bucle de conversación a ese tamaño ($0,50 / $0,00033), así que puedes experimentar libremente antes de recargar. Las peticiones fallidas y rechazadas no se cobran, lo que significa que un error en tu análisis que te haga volver a ejecutar una llamada no te cuesta por los intentos fallidos.

  • Una URL base incorrecta. Debe terminar en /v1. Añadir /chat/completions tú mismo a una URL base de SDK da un 404 porque el SDK añade la ruta.
  • Un nombre de modelo diferente. Los nombres copiados de otras plataformas no existen aquí. El ID es uncensored.
  • Esperar memoria. La API no recuerda llamadas anteriores. Envía el historial cada vez.
  • Analizar el JSON del modelo sin protección. Envuelve json.loads en un bloque try y ten un plan para una respuesta incorrecta.
  • Dejar streams abiertos. Un stream sin terminar mantiene una ranura de concurrencia ocupada, y una clave de prueba solo tiene dos.
  • Poner la clave en el código del front-end. Mantenla en un servidor.

Si algo sigue pareciendo incorrecto, envía una petición con curl y compárala con lo que produce tu código. La forma con curl elimina el SDK del panorama y hace evidentes las diferencias en el cuerpo.

Leer uso, saldo y errores

Para ver los encabezados desde el SDK de Python, usa el envoltorio de respuesta cruda:

raw = client.chat.completions.with_raw_response.create(
    model="uncensored",
    messages=[{"role": "user", "content": "Say ok."}],
)
print("request id:", raw.headers.get("x-request-id"))
print("balance usd:", raw.headers.get("x-balance-usd"))
print("rpm limit:", raw.headers.get("x-ratelimit-limit-requests"))
completion = raw.parse()
print(completion.usage.total_tokens)

Registra el ID de la petición con cada llamada para poder señalar una petición concreta más tarde. Usa el encabezado de saldo para activar una alerta antes de que se agote el crédito.

Cuando excedes un límite, la API devuelve HTTP 429, y el código de error te dice cuál:

Código o encabezadoQué hacerQué hacer
rate_limitedDemasiadas peticiones por minuto (300 en una clave completa, 60 en prueba)Reduce la velocidad y distribuye las llamadas
concurrencyDemasiadas a la vez (8 en una clave completa, 2 en prueba)Espera a que termine una petición en ejecución
Retry-After: 5Sobrecarga temporalReintenta después de cinco segundos

Las peticiones fallidas o rechazadas no se cobran. El cuerpo de la petición puede tener hasta 8 MB. Para la referencia completa y cómo reutilizar código de cliente existente, consulta la documentación. Para un recorrido sobre cómo obtener una clave, consulta el artículo de clave de API GLM.

Preguntas y respuestas

¿Qué URL base usan los ejemplos?

Cada ejemplo usa https://api.glmapikey.com/v1 con el ID del modelo uncensored y un token bearer. Cualquier SDK de OpenAI funciona una vez que cambias esos valores.

¿La API admite streaming?

Sí. Establece stream a true y lee eventos enviados por el servidor. El uso se informa al final del stream.

¿Cómo obtengo JSON válido?

Pasa response_format con tipo json_object y describe la forma que deseas en el prompt. Analiza el resultado en tu código y verifica las claves que necesitas.

¿Puedo usar llamadas a funciones?

Sí. Pasa tools y tool_choice, ejecuta la función que solicite el modelo y devuelve el resultado como un mensaje con role tool.

¿Dónde puedo ver mi crédito restante?

Cada respuesta incluye un encabezado X-Balance-USD con tu saldo restante, y el bloque de uso proporciona los recuentos de tokens.

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