Cómo usar Qwythos-9B: guía de despliegue con vLLM, SGLang y Transformers

Qwythos-9B-Claude-Mythos-5-1M es un modelo de razonamiento de 9B publicado por Empero AI en Hugging Face.

Página del modelo: empero-ai/Qwythos-9B-Claude-Mythos-5-1M

Sus puntos más llamativos son claros:

Basado en Qwen3.5-9B;
Escala de 9B parámetros;
Licencia Apache-2.0;
Contexto por defecto de 1,048,576 tokens;
Soporte para function calling estilo Qwen3.5;
Orientado a razonamiento con textos largos, uso de herramientas y flujos agentic;
La model card incluye ejemplos para vLLM, SGLang y Transformers.

Si buscas un modelo open-weight relativamente pequeño, con contexto largo y capacidad de conectar herramientas, Qwythos-9B merece una mirada.

Para quién es

Qwythos-9B no es exactamente un modelo de chat común.

Encaja mejor con:

Análisis de documentos largos;
Lectura de codebases con muchos archivos;
Tareas largas de agentes;
Preguntas y respuestas con llamadas a herramientas;
Tareas que necesitan un ejecutor Python o búsqueda para verificar;
Investigación, razonamiento, matemáticas, código y documentación técnica;
Pruebas locales o privadas de contexto de 1M.

No encaja tan bien si:

Solo quieres chat ligero;
No tienes recursos GPU;
No quieres procesar bloques <think>;
Buscas una experiencia de chat de consumo lista para usar;
No tienes controles de seguridad a nivel de aplicación.

La model card lo describe explícitamente como un reasoning model. Sus respuestas incluyen primero un bloque <think> y después la respuesta final. Si lo conectas a un producto de cara al usuario, tendrás que procesar u ocultar esa parte.

Información básica del modelo

Según la model card de Hugging Face, la información básica es:

Elemento	Información
Nombre	`empero-ai/Qwythos-9B-Claude-Mythos-5-1M`
Publicador	Empero AI
Base	`Qwen/Qwen3.5-9B`
Tamaño	9B
Formato	Safetensors
Licencia	Apache-2.0
Contexto	1,048,576 tokens
Características	reasoning, function calling, long-context, agentic

No es un simple envoltorio de prompt. Es un full-parameter fine-tune. La model card indica que los datos de entrenamiento incluyen más de 500M tokens de Claude Mythos / Claude Fable traces, además de datos chain-of-thought generados por la herramienta interna rethink de Empero AI.

El punto no es solo si puede chatear. Lo interesante es si puede razonar dentro de contextos complejos, llamar herramientas y corregir sus respuestas.

Qué significa 1M context

La capacidad más visible de la model card es el uso de YaRN rope scaling para extender el contexto a:

1

1,048,576 tokens

Es decir, alrededor de 1M tokens.

La configuración incluye parámetros como:

1
2
3
4
5
6
7
8
9


"rope_parameters": {
  "rope_type": "yarn",
  "factor": 4.0,
  "original_max_position_embeddings": 262144,
  "mrope_interleaved": true,
  "mrope_section": [11, 11, 10],
  "rope_theta": 10000000
},
"max_position_embeddings": 1048576

Esto resulta atractivo para:

Meter una codebase grande directamente en el contexto;
Procesar 10 a 20 papers con notas;
Mantener salidas de herramientas en tareas largas de agentes;
Analizar documentos cruzados;
Razonar sobre tracebacks, logs o respuestas de API extensas.

Pero conviene ser realista: 1M context no significa que cualquier GPU de consumo pueda ejecutar cómodamente la ventana completa.

La model card también indica que la ventana completa de 1M encaja mejor con tensor parallel en múltiples GPU o aggressive KV-cache offload. En una sola GPU potente, 256k a 512k puede ser más realista, según backend, cuantización, KV cache y VRAM.

Despliegue con vLLM

Si ya usas APIs compatibles con OpenAI, vLLM es una de las rutas más directas.

Instalación:

1

pip install vllm

Arrancar el modelo:

1

vllm serve "empero-ai/Qwythos-9B-Claude-Mythos-5-1M"

Para especificar un contexto cercano a 1M, sigue el ejemplo de la model card:

1

vllm serve empero-ai/Qwythos-9B-Claude-Mythos-5-1M --max-model-len 1010000

Llamar a la API:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


curl -X POST "http://localhost:8000/v1/chat/completions" \
  -H "Content-Type: application/json" \
  --data '{
    "model": "empero-ai/Qwythos-9B-Claude-Mythos-5-1M",
    "messages": [
      {
        "role": "user",
        "content": "What is the capital of France?"
      }
    ]
  }'

Si el arranque falla por falta de VRAM, no empieces con 1M. Prueba primero valores menores de --max-model-len, como 32k, 64k o 128k, y sube gradualmente.

Despliegue con SGLang

SGLang también aparece en la model card.

Instalación:

1

pip install sglang

Arranque:

1
2
3
4


python3 -m sglang.launch_server \
  --model-path "empero-ai/Qwythos-9B-Claude-Mythos-5-1M" \
  --host 0.0.0.0 \
  --port 30000

Para probar contexto largo:

1
2
3


SGLANG_ALLOW_OVERWRITE_LONGER_CONTEXT_LEN=1 python -m sglang.launch_server \
  --model-path empero-ai/Qwythos-9B-Claude-Mythos-5-1M \
  --context-length 1010000

Llamada:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


curl -X POST "http://localhost:30000/v1/chat/completions" \
  -H "Content-Type: application/json" \
  --data '{
    "model": "empero-ai/Qwythos-9B-Claude-Mythos-5-1M",
    "messages": [
      {
        "role": "user",
        "content": "What is the capital of France?"
      }
    ]
  }'

La model card también da un ejemplo con Docker:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


docker run --gpus all \
  --shm-size 32g \
  -p 30000:30000 \
  -v ~/.cache/huggingface:/root/.cache/huggingface \
  --env "HF_TOKEN=<secret>" \
  --ipc=host \
  lmsysorg/sglang:latest \
  python3 -m sglang.launch_server \
    --model-path "empero-ai/Qwythos-9B-Claude-Mythos-5-1M" \
    --host 0.0.0.0 \
    --port 30000

Antes de desplegar, configura HF_TOKEN si necesitas acceder a recursos gated o cachés privadas.

Carga con Transformers

El ejemplo text-only de la model card usa AutoModelForImageTextToText y AutoTokenizer.

La estructura general es:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30


import torch
from transformers import AutoModelForImageTextToText, AutoTokenizer

model_id = "empero-ai/Qwythos-9B-Claude-Mythos-5-1M"
tok = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForImageTextToText.from_pretrained(
    model_id, dtype="bfloat16", device_map="auto"
)

messages = [
    {
        "role": "user",
        "content": "Explain how tool calling helps a reasoning model verify exact facts."
    }
]

text = tok.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
inputs = tok(text, return_tensors="pt").to(model.device)

out = model.generate(
    **inputs,
    max_new_tokens=16384,
    do_sample=True,
    temperature=0.6,
    top_p=0.95,
    top_k=20,
    repetition_penalty=1.05,
)

print(tok.decode(out[0][inputs["input_ids"].shape[1]:], skip_special_tokens=True))

Hay dos puntos importantes:

La respuesta incluye <think>...</think>;
Conviene dar suficiente max_new_tokens; la model card recomienda 16384.

Para salidas de producto, normalmente conviene filtrar la parte <think> y mostrar solo la respuesta final.

Parámetros de muestreo recomendados

La model card recomienda:

1
2
3
4
5
6
7
8


gen_kwargs = dict(
    do_sample=True,
    temperature=0.6,
    top_p=0.95,
    top_k=20,
    repetition_penalty=1.05,
    max_new_tokens=16384,
)

No empieces con greedy decoding ni con temperatura demasiado baja.

La model card menciona que, con greedy o temperaturas muy bajas (T <= 0.3), este tipo de reasoning model puede entrar en bucles de repetición. Usar los parámetros recomendados suele ser más estable.

Cómo entender tool calling

Qwythos-9B soporta function calling estilo Qwen3.5.

La model card explica que puedes pasar tools=[...] al chat template, y el modelo puede emitir un bloque <tool_call> compatible con Qwen3.5.

Una definición simplificada de herramientas se ve así:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31


TOOLS = [
    {
        "type": "function",
        "function": {
            "name": "python_executor",
            "description": "Execute Python code and return stdout.",
            "parameters": {
                "type": "object",
                "properties": {
                    "code": {"type": "string"}
                },
                "required": ["code"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "web_search",
            "description": "Search the web for current facts and citations.",
            "parameters": {
                "type": "object",
                "properties": {
                    "query": {"type": "string"},
                    "max_results": {"type": "integer"}
                },
                "required": ["query"]
            }
        }
    }
]

El modelo genera algo similar a un bloque <tool_call>. Tu aplicación debe parsearlo, ejecutar la herramienta y devolver el resultado al modelo.

Es decir, Qwythos-9B no navega por internet por sí solo.

Tú debes proporcionar el entorno de ejecución de herramientas.

Expectativas realistas de hardware

9B parámetros puede sonar moderado, pero 1M context añade presión en otra dimensión.

Al desplegar, conviene mirar por separado:

VRAM para pesos del modelo;
KV cache;
Longitud de contexto;
batch size;
concurrencia;
uso o no de cuantización;
KV cache offload;
backend: vLLM, SGLang o Transformers.

Si solo quieres probar el modelo, empieza con contextos pequeños:

1

32k -> 64k -> 128k -> 256k

Sube solo después de confirmar estabilidad.

No interpretes 1M context como algo que debas usar siempre. Es más práctico aumentarlo solo en análisis de codebases, resúmenes de múltiples papers o trazas largas de agentes.

Límites y seguridad

Hay varias limitaciones importantes en la model card:

Es un reasoning model y emite <think>;
Temperatura baja o greedy decoding pueden causar bucles de repetición;
Identificadores concretos, CVE, etiquetas de fármacos, números exactos y datos similares requieren verificación con herramientas o recuperación;
El modelo es uncensored y puede no rechazar fácilmente peticiones técnicas complejas;
La capacidad visual se hereda de la base, pero este fine-tune es text-only y el comportamiento visual no fue el foco de entrenamiento ni evaluación.

Si lo usas en una aplicación de cara al usuario, añade:

Filtrado de salida;
Política de seguridad;
Lista blanca de llamadas a herramientas;
Rate limiting;
Logs y auditoría;
Revisión humana para dominios de alto riesgo;
Verificación mediante recuperación o herramientas.

En ciberseguridad, medicina, farmacología, finanzas y derecho, no trates la respuesta del modelo como verdad final. Puede ayudar a razonar, pero la decisión final debe volver a fuentes fiables, resultados de herramientas o revisión humana.

Cómo probarlo

Para la primera prueba, no empieces con contexto ultralargo.

Prueba este orden:

Ejecuta una Q&A corta con Transformers o vLLM;
Usa los parámetros de muestreo recomendados;
Observa el formato de <think> y respuesta final;
Prueba un resumen de documento algo más largo;
Conecta un Python executor;
Luego prueba web_search o RAG;
Aumenta el contexto solo cuando lo básico sea estable.

Puedes empezar con prompts como:

1

請閱讀下面這段程式碼，找出可能的邊界條件問題，並給出最小修復建議。

1

請先列出你需要驗證的關鍵事實，再說明哪些可以用工具確認，哪些需要人工複核。

Este tipo de preguntas muestra mejor el valor de un reasoning model con tool-use.

Resumen en una frase

Qwythos-9B-Claude-Mythos-5-1M es un modelo de razonamiento de 9B orientado a ingeniería e investigación.

Su atractivo no es solo el tamaño, sino esta combinación:

1

Qwen3.5-9B base + 1M context + function calling + reasoning training + Apache-2.0

Si quieres probar análisis de codebases con contexto largo, investigación multidocumento o flujos de agentes con verificación mediante herramientas, merece la pena probarlo. Pero no te dejes llevar por el 1M context: empieza pequeño, estabiliza el despliegue y escala según VRAM, KV cache y capacidad del backend.