API de inferencia

GenKaKu expone una API HTTP compatible con OpenAI — construida para agentes. Habla completions de chat, streaming, tool/function calling, y descubrimiento de modelos, así que cualquier framework de agente que hable con OpenAI funciona cambiando dos cosas: el base_url y el api_key. Nada más cambia.

base_url:  https://genkaku.app/api/v1

Por qué ejecutar tu agente en GenKaKu: modelos sin censura (sin rechazos), cómputo descentralizado, gran contexto, y tus prompts nunca se almacenan (procesados en memoria y descartados — solo se guardan conteos de tokens para facturación) y anónimos para el trabajador (el GPU que ejecuta tu trabajo recibe solo el texto del prompt, nunca tu identidad). Consulta Construir agentes para configuraciones de frameworks.

Autenticación

Genera una clave de API en genkaku.app/settings → la pestaña API. Las claves se ven como sk-c0mpute-… y se muestran una vez al crearse. Pásala como token de portador:

Authorization: Bearer sk-c0mpute-...

Las solicitudes se cobran al saldo de créditos de la cuenta que posee la clave. Recarga con USDC desde el panel.

Modelos

Modelo	Descripción
qwen3.8-27b-uncensored	Qwen3.8 27B sin censura con herramientas, visión y gran contexto. El modelo de la red — también alimenta a c0mpute code.
qwen3.8-27b-uncensored-think	El mismo modelo con razonamiento de cadena de pensamiento extendido.
genkaku-pro	Qwen3.5 sin censura. Rápido, se ejecuta en el amplio grupo de trabajadores del navegador. Respondido por un 9B o un 4B dependiendo del trabajador que lo tome.
genkaku-swarm	MiniMax-M2.5 (229B), servido por el enjambre descentralizado de GPUs. La disponibilidad depende de que un anillo de enjambre esté listo.

GET /v1/models los lista con una bandera available en vivo (el 27B requiere que un trabajador GPU nativo esté en línea) y un objeto pricing ({ "type": "per_token", "usd_per_m_input": 0.15, "usd_per_m_output": 0.90 }). Siempre verifica la disponibilidad si dependes del 27B.

Los IDs de modelo más antiguos (supergemma4-26b, code) son alias obsoletos. Aún responden durante la ventana de migración y serán eliminados — dirige las nuevas integraciones a los IDs anteriores.

Precios

La facturación es por token, una tarifa para cada modelo de texto:

	USD / 1M tokens
Entrada	$0.15
Salida	$0.90

Los tokens de pensamiento son tokens de salida y no llevan sobrecargo, así que qwen3.8-27b-uncensored-think cuesta lo mismo por token que el modelo base — simplemente tiende a generar más de ellos.

1 crédito = $0.001, y una solicitud se redondea hacia arriba a créditos enteros con un mínimo de 1, así que un mensaje típico (~1,200 de entrada / ~600 de salida) cuesta aproximadamente 1 crédito. Los créditos se compran con USDC desde el panel a 500 créditos por dólar. Cada respuesta lleva un bloque usage con los conteos por los que realmente se te cobró; las respuestas de streaming lo incluyen en un chunk final cuando envías "stream_options": {"include_usage": true}. Una solicitud que devuelve una llamada a herramienta (un paso de un bucle de agente) cobra por los tokens que generó. Límite de velocidad: 60 solicitudes/minuto por clave.

Dado que el costo final solo se conoce una vez que la respuesta se detiene, una solicitud coloca un hold de corta duración por el máximo que podría costar, y la parte no utilizada se devuelve en el momento en que se liquidá. Un chequeo de saldo debería permitir el hold, no solo el costo típico.

Planes y claves de API

Si la cuenta que posee la clave está en un plan, las solicitudes de API gastan los créditos diarios de ese plan antes de tocar el saldo. Los créditos diarios se restablecen a las 00:00 UTC y no se acumulan.

Los créditos diarios gratuitos son la excepción. Son para personas que usan la aplicación, así que las solicitudes de API nunca los usan y siempre cobran el saldo.

Saldo

GET /v1/balance devuelve el saldo de créditos restante en la cuenta que posee la clave:

curl https://genkaku.app/api/v1/balance \
  -H "Authorization: Bearer $C0MPUTE_API_KEY"

{
  "object": "balance",
  "credits": 12500,
  "usd": 12.50,
  "total_deposited": 20000,
  "total_spent": 7500
}

Úsalo para verificar el crédito restante antes de un lote de solicitudes o para mostrar una advertencia de saldo bajo en tu integración.

Generación de imágenes

POST /v1/images/generations — generación de imágenes compatible con OpenAI, sin censura (Chroma1-HD en GPUs de contribuyentes). 10 créditos ($0.01) por imagen. Las imágenes se devuelven en línea como base64 y nunca se almacenan del lado del servidor.

curl https://genkaku.app/api/v1/images/generations \
  -H "Authorization: Bearer $C0MPUTE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"prompt": "a neon-lit alley in the rain, cinematic", "size": "1024x1024"}'

from openai import OpenAI
client = OpenAI(base_url="https://genkaku.app/api/v1", api_key="sk-c0mpute-...")
img = client.images.generate(prompt="a neon-lit alley in the rain, cinematic", response_format="b64_json")
png_b64 = img.data[0].b64_json

Parámetros: prompt (requerido), size ("WIDTHxHEIGHT", predeterminado 1024x1024), negative_prompt, seed, nsfw (booleano, predeterminado falso — el modo SFW ejecuta un clasificador de salida; la línea absoluta de seguridad se aplica en ambos modos). n debe ser 1 y response_format debe ser b64_json (sin URLs — nada se almacena). Las renderizaciones toman ~30s; los errores usan formas de OpenAI (402 insufficient_credits, 503 cuando no hay GPU de imagen libre).

Completions de chat

POST /v1/chat/completions

curl

curl https://genkaku.app/api/v1/chat/completions \
  -H "Authorization: Bearer $C0MPUTE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "genkaku-pro",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'

Python (OpenAI SDK)

from openai import OpenAI

client = OpenAI(base_url="https://genkaku.app/api/v1", api_key="sk-c0mpute-...")

resp = client.chat.completions.create(
    model="genkaku-pro",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(resp.choices[0].message.content)

Node (OpenAI SDK)

import OpenAI from "openai";

const client = new OpenAI({ baseURL: "https://genkaku.app/api/v1", apiKey: "sk-c0mpute-..." });

const resp = await client.chat.completions.create({
  model: "genkaku-pro",
  messages: [{ role: "user", content: "Hello!" }],
});
console.log(resp.choices[0].message.content);

Streaming

Establece stream: true para recibir Server-Sent Events como objetos chat.completion.chunk, terminados por data: [DONE].

stream = client.chat.completions.create(
    model="genkaku-pro",
    messages=[{"role": "user", "content": "Write a haiku."}],
    stream=True,
)
for chunk in stream:
    print(chunk.choices[0].delta.content or "", end="")

Llamadas a funciones (herramientas)

Pasa tus propias tools. Cuando el modelo decide llamar una, la respuesta viene con finish_reason: "tool_calls" y la(s) llamada(s) bajo message.tool_calls — tú ejecutas la herramienta y envías el resultado de vuelta como un mensaje tool. Esto es lo que permite a los frameworks de agente dirigir sus propias herramientas en GenKaKu.

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

messages = [{"role": "user", "content": "What's the weather in Paris?"}]
r1 = client.chat.completions.create(model="qwen3.8-27b-uncensored", messages=messages, tools=tools)

call = r1.choices[0].message.tool_calls[0]            # get_weather({"city": "Paris"})
messages.append(r1.choices[0].message)
messages.append({"role": "tool", "tool_call_id": call.id, "content": "18C and sunny"})

r2 = client.chat.completions.create(model="qwen3.8-27b-uncensored", messages=messages, tools=tools)
print(r2.choices[0].message.content)                 # "The weather in Paris is 18°C and sunny."

Las llamadas a herramientas y la visión son más confiables en qwen3.8-27b-uncensored. La canalización del navegador puede intentar herramientas pero es menos consistente.

Visión

qwen3.8-27b-uncensored acepta imágenes. Usa el formato de contenido multimodal de OpenAI con una URL data: base64 en línea:

import base64
img = base64.b64encode(open("photo.png", "rb").read()).decode()

resp = client.chat.completions.create(
    model="qwen3.8-27b-uncensored",
    messages=[{"role": "user", "content": [
        {"type": "text", "text": "What's in this image?"},
        {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{img}"}},
    ]}],
)
print(resp.choices[0].message.content)

Pasa imágenes en línea como base64; las URLs de imagen https remotas no se obtienen en esta versión. La visión requiere qwen3.8-27b-uncensored. Solo entrada de imagen — para crear imágenes, usa el endpoint de generación de imágenes.

Construir agentes

GenKaKu está diseñado para ser el cerebro para frameworks de agente. Tu framework sigue haciendo lo que hace — memoria, prompt de sistema / persona, el bucle de herramientas — y GenKaKu es el modelo al que llama. La memoria y la persona no necesitan manejo especial: son solo el array de mensajes y un mensaje de sistema que ya envías. Las herramientas funcionan a través del flujo estándar de function-calling anterior (el modelo devuelve tool_calls, tu framework los ejecuta y envía resultados de vuelta).

Para agentes, usa qwen3.8-27b-uncensored (o qwen3.8-27b-uncensored-think para razonamiento más difícil) — el 27B es mucho más confiable en el uso de herramientas de múltiples pasos que la canalización del navegador.

Cualquier framework compatible con OpenAI

La configuración universal: apunta el proveedor de modelos del framework a GenKaKu.

base_url / baseURL :  https://genkaku.app/api/v1
api_key            :  sk-c0mpute-...
model              :  qwen3.8-27b-uncensored

OpenAI Agents SDK (Python)

from agents import Agent, Runner, OpenAIChatCompletionsModel
from openai import AsyncOpenAI

client = AsyncOpenAI(base_url="https://genkaku.app/api/v1", api_key="sk-c0mpute-...")
agent = Agent(name="Assistant", instructions="You are helpful.",
              model=OpenAIChatCompletionsModel(model="qwen3.8-27b-uncensored", openai_client=client))
print((await Runner.run(agent, "Plan my week.")).final_output)

LangChain / LangGraph (Python)

from langchain_openai import ChatOpenAI

llm = ChatOpenAI(model="qwen3.8-27b-uncensored", base_url="https://genkaku.app/api/v1", api_key="sk-c0mpute-...")

Vercel AI SDK (TypeScript)

import { createOpenAI } from "@ai-sdk/openai";
const c0mpute = createOpenAI({ baseURL: "https://genkaku.app/api/v1", apiKey: "sk-c0mpute-..." });
// usa c0mpute("qwen3.8-27b-uncensored") como modelo en generateText / streamText / tool loops

Hermes

GenKaKu es un endpoint personalizado compatible con OpenAI. Para Hermes, usa qwen3.8-27b-uncensored-think (el 27B con razonamiento extendido). Agrégalo como un proveedor personalizado en ~/.hermes/config.yaml, con la clave de API establecida en el proveedor (Hermes no lee ~/.hermes/.env en tiempo de ejecución, así que la clave debe estar en la configuración o una variable de entorno exportada):

custom_providers:
  - name: c0mpute
    base_url: https://genkaku.app/api/v1
    api_key: sk-c0mpute-...      # tu clave, en línea
    models:
      qwen3.8-27b-uncensored-think: {}

¿Prefieres no codificar la clave? Usa key_env y exporta esa variable en tu shell (Hermes la lee del entorno del proceso, no de .env):

custom_providers:
  - name: c0mpute
    base_url: https://genkaku.app/api/v1
    key_env: OPENAI_API_KEY      # debe ser exportada, ej. en ~/.bashrc
    models:
      qwen3.8-27b-uncensored-think: {}

Luego selecciónala con hermes model (o /model en sesión) y ejecuta, ej. hermes -z "hello" -m qwen3.8-27b-uncensored-think.

Si ves HTTP 401: Invalid API key, Hermes está enviando su marcador de posición no-key-required — no encontró tu clave. Establece api_key en el proveedor como arriba (poner la clave solo en ~/.hermes/.env no funciona).

Errores

Los errores se devuelven en la forma de OpenAI ({ "error": { "message", "type", "code" } }):

Estado	Significado
401	Clave de API faltante o inválida
402	Créditos insuficientes — recarga con USDC
404	Modelo desconocido
429	Límite de velocidad excedido
503	No hay trabajador disponible para el modelo solicitado (el 27B necesita un trabajador nativo en línea)

Límites de velocidad

60 solicitudes/minuto por clave por defecto. ¿Necesitas más? Contacta.

Generación de imágenes

POST /api/images/generate — genera una imagen y la obtienes en línea como una URL de datos base64. Este es un endpoint de GenKaKu, separado de la superficie compatible con OpenAI /v1. La autenticación usa la misma clave de portador sk-c0mpute-… (o una sesión iniciada).

Solicitud

Campo	Tipo	Predeterminado	Notas
prompt	string	—	Requerido.
negative_prompt	string	—	Opcional. Se aplica siempre un negativo base anti-artefactos encima.
width / height	int	1024	512–1536, ajustado a múltiplos de 64.
steps	int	32	10–60.
cfg	number	4.0	Escala de guía; Chroma gusta ~3.5–4.5.
seed	int	aleatorio	Opcional, para salida reproducible.
nsfw	bool	false	Permitir contenido adulto (18+). Con él desactivado, la salida adulta se bloquea.

Respuesta

{
  "image": "data:image/png;base64,...",
  "model": "c0mpute-image",
  "seed": 31337,
  "width": 1024,
  "height": 1024,
  "credits_charged": 10
}

La imagen se devuelve en línea y nunca se almacena del lado del servidor. 10 créditos ($0.01) por imagen, reembolsado automáticamente en caso de fallo.

Errores

• 400 — prompt bloqueado por la política de contenido, o una solicitud SFW produjo salida adulta.
• 402 — créditos insuficientes.
• 503 — no hay trabajadores de imagen en línea ahora (intenta de nuevo en breve).

curl

curl https://genkaku.app/api/images/generate \
  -H "Authorization: Bearer $C0MPUTE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"prompt":"a candid photo of a fox in snow, 35mm film","width":1216,"height":832}'