74ce6b13862c para sistemas de producción: contratos y verificaciones

Esta guía reconstruye el proceso desde las materias primas hasta un sistema funcional para: . El enfoque está en pasos operativos claros, verificaciones explícitas y código que se puede incorporar a un repositorio sin tener que adivinar su propósito.

Ejecutar Qwen3.8-Flash-Next localmente: Una guía completa para crear un agente de programación local

En la fase de ejecución de Qwen3 8-Flash-Next localmente, se deben definir las entradas, el responsable de cada paso y los criterios de finalización antes de modificar el código. Los operadores deben poder volver a ejecutar el paso a partir de un punto de control conocido sin tener que adivinar el estado oculto. Es preferible utilizar unidades pequeñas y verificables en lugar de scripts extensos. Cuando un paso falla, el error debe indicar una única responsabilidad y no un proceso complicado. Se debe incluir la aprobación humana en aquellas tareas que implican gastos o modificaciones en datos de producción. La conexión de componentes en tiempo de compilación no equivale a una solución completa desde el punto de vista empresarial.

Qwen3.8-Flash-Next
        ↓
UD-Q4_K_XL GGUF
        ↓
llama.cpp
        ↓
OpenAI-compatible API
        ↓
OpenCode
        ↓
Local Coding Agent

¿Qué es Qwen3.8-Flash-Next?

Para la fase What Is Qwen3 8-Flash-Next, defina las entradas, el responsable de la etapa y los criterios de finalización antes de modificar el código. Los operadores deben poder volver a ejecutar la etapa a partir de un punto de control conocido sin tener que adivinar el estado oculto. Trate esta fase como un contrato entre las entradas y los resultados validados. Asigne nombres a los artefactos, defina verificaciones de éxito y rechace las completaciones parciales silenciosas. Coloque el estado junto al componente que es responsable de la mutación. Al llevar todo a un almacenamiento global, resulta más difícil detectar errores de sincronización.

Requisitos de hardware

En la fase de Requisitos de Hardware, defina las entradas, el responsable del paso y los criterios de finalización antes de modificar el código. Los operadores deben poder volver a ejecutar el paso a partir de un punto de control conocido, sin tener que adivinar el estado oculto. Registre los tiempos de ejecución y el costo de tokens o consultas junto con los resultados funcionales. La visibilidad temprana del costo evita facturas inesperadas cuando el proceso pasa de entornos de demostración a entornos compartidos. Añada una prueba de humo que ejecute la ruta crítica en CI utilizando fixtures, y no APIs pagadas en tiempo real, siempre que lo permitan los presupuestos.

Paso 1: Verifique su GPU NVIDIA

En el Paso 1, “Verifique su etapa”, defina las entradas, el responsable del paso y los criterios de finalización antes de modificar el código. Los operadores deben poder volver a ejecutar el paso a partir de un punto de control conocido sin tener que adivinar el estado oculto. Guarde la configuración fuera del código de la aplicación. Los archivos de entorno, los almacenes de datos secretos y las banderas de funcionalidad deben encontrarse en un lugar donde los operadores puedan auditarlos sin necesidad de leer todo el sistema. Añada una prueba de smoke que ejecute la ruta crítica en CI utilizando fixtures, y no APIs pagadas en tiempo real, siempre que lo permitan los presupuestos.

nvidia-smi

Paso 2: Instale las dependencias de compilación

En la etapa de Instalación, Paso 2, defina las entradas, el responsable del paso y los criterios de finalización antes de modificar el código. Los operadores deben poder volver a ejecutar el paso a partir de un punto de control conocido sin tener que adivinar el estado oculto. Documente tanto la ruta óptima como la ruta de recuperación. Las reintentos, los controles humanos y el manejo de mensajes no entregados forman parte del producto, no son mejoras posteriores. Añada una prueba de smoke que ejerza la ruta crítica en CI utilizando fixtures, y no APIs pagadas en tiempo real, siempre que lo permitan los presupuestos. En la etapa de Instalación, Paso 2, defina las entradas, el responsable del paso y los criterios de finalización antes de modificar el código. Los operadores deben poder volver a ejecutar el paso a partir de un punto de control conocido sin tener que adivinar el estado oculto. Trate esta etapa como un contrato entre las entradas y los resultados validados. Asigne nombres a los artefactos, defina comprobaciones de éxito y rechace las completaciones parciales silenciosas.

sudo apt update

sudo apt install -y \
  git \
  cmake \
  build-essential \
  curl \
  libcurl4-openssl-dev \
  python3-pip

Paso 3: Construir llama.cpp

Al trabajar en la fase de construcción de llama del Paso 3, anote primero el contrato: entradas requeridas, señal de éxito y qué ocurre en caso de fallo parcial. Esa lista de verificación mantiene honestas las futuras modificaciones del código. Registre los tiempos y el costo en tokens o consultas junto con los resultados funcionales. Tener visibilidad del costo desde el principio evita facturas inesperadas cuando se pasa de entornos de demostración a entornos compartidos. Escriba un breve manual de operaciones: cómo rotar claves, cómo vaciar la cola y cómo revertir la última ingestión.

cd /workspace

git clone \
  --branch qwen4exp/qwen3.8-flash-next \
  https://github.com/unslothai/llama.cpp.git

cd llama.cpp

cmake -B build \
  -DGGML_CUDA=ON \
  -DCMAKE_BUILD_TYPE=Release

cmake --build build \
  --config Release \
  -j"$(nproc)"

./build/bin/llama-server --version

Paso 4: Descargar el modelo GGUF

Al trabajar en la Etapa 4: Descargar la fase, anote primero el contrato: los datos requeridos, la señal de éxito y qué ocurre en caso de fallo parcial. Esa lista de verificación ayuda a mantener honestas las futuras modificaciones del código. Guarde la configuración fuera del código de la aplicación. Los archivos de entorno, los almacenes de datos secretos y las banderas de funcionalidad deben encontrarse en un lugar donde los operadores puedan auditarlos sin tener que leer todo el sistema. Almacene en caché las instrucciones del sistema estables y los esquemas de las herramientas. Reenviar un preámbulo idéntico es una causa común de consumo excesivo de recursos.

pip install -U huggingface_hub

export HF_HUB_DISABLE_XET=1

unset HF_XET_HIGH_PERFORMANCE
unset HF_XET_NUM_CONCURRENT_RANGE_GETS
unset HF_HUB_ENABLE_HF_TRANSFER

cd /workspace
mkdir -p Qwen3.8-Flash-Next-GGUF

for i in 1 2 3 4; do
  shard=$(printf "%05d" "$i")

  hf download unsloth/Qwen3.8-Flash-Next-GGUF \
    "UD-Q4_K_XL/Qwen3.8-Flash-Next-UD-Q4_K_XL-${shard}-of-00004.gguf" \
    --local-dir Qwen3.8-Flash-Next-GGUF &
donewait

Etapa 5: Iniciar el servidor local del modelo

Al trabajar en la etapa 5 “Iniciar”, anote primero el contrato: los datos de entrada requeridos, la señal de éxito y qué ocurre en caso de fallo parcial. Esa lista de verificación garantiza que los cambios posteriores en el código sean transparentes. Documente tanto la ruta de éxito como la ruta de recuperación. Las reintentos, los controles humanos y el manejo de mensajes no entregados forman parte del producto, no son mejoras realizadas posteriormente. Almacene en caché las instrucciones del sistema estables y los esquemas de las herramientas. Reenviar un preámbulo idéntico es una causa común de problemas. Al trabajar en la etapa 5 “Iniciar”, anote primero el contrato: los datos de entrada requeridos, la señal de éxito y qué ocurre en caso de fallo parcial. Esa lista de verificación garantiza que los cambios posteriores en el código sean transparentes. Trate esta etapa como un contrato entre las entradas y las salidas validadas. Asigne nombres a los artefactos, defina las comprobaciones de éxito y rechace las completaciones parciales silenciosas.

cd /workspace/llama.cpp

./build/bin/llama-server \
  -m /workspace/Qwen3.8-Flash-Next-GGUF/UD-Q4_K_XL/Qwen3.8-Flash-Next-UD-Q4_K_XL-00001-of-00004.gguf \
  --alias qwen3.8-flash-next \
  --host 0.0.0.0 \
  --port 8080 \
  --ctx-size 131072 \
  --parallel 1 \
  --flash-attn on \
  --fit on \
  --fit-target 4096 \
  --jinja \
  --batch-size 1024 \
  --ubatch-size 512 \
  --temp 1.0 \
  --top-p 0.95 \
  --top-k 20 \
  --min-p 0.0

Paso 6: Probar la API

La etapa 6, “Probar”, funciona mejor cuando se trata como una superficie medible. Capture un registro exitoso, un caso de fallo y la nota de reversión antes de ampliar el alcance. Registre los tiempos y el costo en tokens o consultas junto con los resultados funcionales. Tener visibilidad del costo desde el principio evita facturas inesperadas cuando el proceso pasa de la demostración a entornos compartidos. Fije las versiones de dependencias y registre el resumen de la imagen que ejecutó la demostración. La reproducibilidad es mejor que el conocimiento basado en experiencias individuales.

curl http://127.0.0.1:8080/v1/models

qwen3.8-flash-next

curl http://127.0.0.1:8080/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "qwen3.8-flash-next",
    "messages": [
      {
        "role": "user",
        "content": "Write a Python function that checks whether a number is prime."
      }
    ]
  }'

Etapa 7: Utilizar la WebUI de llama.cpp

El paso 7, “Utilizar la etapa”, funciona mejor cuando se trata como una superficie medible. Capture un registro exitoso, un caso de fallo y la nota de reversión antes de ampliar el alcance. Mantenga la configuración fuera del código de la aplicación. Los archivos de entorno, los almacenes de secretos y las banderas de funcionalidad deben estar en un lugar donde los operadores puedan auditarlos sin tener que leer todo el sistema. Fije las versiones de las dependencias y registre el resumen del imagen que ejecutó la demostración. La reproducibilidad es mejor que el conocimiento tribal.

http://localhost:8080

Paso 8: Instalar OpenCode

La etapa 8 de instalación de OpenCode funciona mejor cuando se trata como una superficie medible. Capture un registro ideal, un caso de fallo y la nota de reversión antes de ampliar el alcance. Documente tanto el camino óptimo como el de recuperación. Las reintentos, los controles humanos y el manejo de mensajes no entregados forman parte del producto, no son ajustes realizados posteriormente. Fije las versiones de las dependencias y registre el resumen de la imagen que ejecutó la demostración. La reproducibilidad es mejor que el conocimiento basado en experiencias individuales. La etapa 8 de instalación de OpenCode funciona mejor cuando se trata como una superficie medible. Capture un registro ideal, un caso de fallo y la nota de reversión antes de ampliar el alcance. Trate esta etapa como un contrato entre las entradas y las salidas validadas. Asigne nombres a los artefactos, defina verificaciones de éxito y rechace las completaciones parciales silenciosas.

curl -fsSL https://opencode.ai/install | bash

opencode --version

Paso 9: Conectar OpenCode a llama.cpp

En la fase de Conectar OpenCode del Paso 9, defina las entradas, el responsable del paso y los criterios de finalización antes de modificar el código. Los operadores deben poder volver a ejecutar el paso a partir de un punto de control conocido sin tener que adivinar el estado oculto. Registre los tiempos de ejecución y el costo en tokens o consultas junto con los resultados funcionales. La visibilidad temprana de los costos evita facturas inesperadas cuando el proceso pasa de entornos de demostración a entornos compartidos. Añada una prueba de humo que ejerza la ruta crítica en CI utilizando fixtures, y no APIs pagadas en tiempo real, siempre que lo permitan los presupuestos.

mkdir -p ~/.config/opencode

printf '%s\n' '{"$schema":"https://opencode.ai/config.json","model":"llama.cpp/qwen3.8-flash-next","provider":{"llama.cpp":{"npm":"@ai-sdk/openai-compatible","name":"Qwen3.8 Flash Next Local","options":{"baseURL":"http://127.0.0.1:8080/v1"},"models":{"qwen3.8-flash-next":{"name":"Qwen3.8 Flash Next","limit":{"context":65536,"output":32768}}}}}}' > ~/.config/opencode/opencode.json

http://127.0.0.1:8080/v1

Paso 10: Inicie su agente de programación local

En la etapa 10, “Iniciar”, defina las entradas, el responsable de la tarea y los criterios de finalización antes de modificar el código. Los operadores deben poder volver a ejecutar la tarea desde un punto de control conocido sin tener que adivinar el estado oculto. Mantenga la configuración fuera del código de la aplicación. Los archivos de entorno, los almacenes de datos secretos y las banderas de funcionalidad deben estar en un lugar donde los operadores puedan auditarlos sin necesidad de leer todo el sistema. Coloque la aprobación humana en las acciones que generan gastos o modifican datos de producción. La conexión establecida en tiempo de compilación no equivale a la completitud del proceso empresarial.

cd /workspace/my-project

opencode

Your Project
     ↓
OpenCode
     ↓
llama.cpp API
     ↓
Qwen3.8-Flash-Next
     ↓
Local AI Coding Agent

Build a modern system analytics and task-management dashboard.
Monitor CPU, RAM, VRAM, GPU usage, temperatures, disk usage,
running processes, and temporary files.

Rendimiento

En la fase de rendimiento, defina las entradas, el responsable del paso y los criterios de finalización antes de modificar el código. Los operadores deben poder volver a ejecutar el paso a partir de un punto de control conocido sin tener que adivinar el estado oculto. Documente tanto la ruta óptima como la ruta de recuperación. Las reintentos, los controles humanos y el manejo de mensajes no entregados forman parte del producto, no son mejoras posteriores. Añada una prueba de humo que ejerza la ruta crítica en CI utilizando fixtures, y no APIs pagadas en tiempo real, siempre que lo permitan los presupuestos. En la fase de rendimiento, defina las entradas, el responsable del paso y los criterios de finalización antes de modificar el código. Los operadores deben poder volver a ejecutar el paso a partir de un punto de control conocido sin tener que adivinar el estado oculto. Trate esta fase como un contrato entre las entradas y los resultados validados. Asigne nombres a los artefactos, defina comprobaciones de éxito y rechace las completaciones parciales silenciosas.

Lo que aprendió

Al trabajar en la etapa de “Lo que has aprendido”, anota primero el contrato: los datos de entrada requeridos, la señal de éxito y qué ocurre en caso de fallo parcial. Esa lista de verificación mantiene honestas las futuras modificaciones del código. Registra los tiempos y el costo de tokens o consultas junto a los resultados funcionales. Tener visibilidad del costo desde el principio evita facturas inesperadas cuando el proceso pasa de la fase de demostración a entornos compartidos. Escribe un breve manual de operaciones: cómo rotar las claves, cómo vaciar la cola y cómo revertir la última inserción.

Arquitectura final

Al trabajar en la fase de Arquitectura Final, primero escribe el contrato: las entradas requeridas, la señal de éxito y qué ocurre en caso de fallo parcial. Esa lista de verificación mantiene honestas las futuras modificaciones del código. Mantén la configuración fuera del código de la aplicación. Los archivos de entorno, los almacenes de datos secretos y las banderas de funcionalidad deben estar en un lugar donde los operadores puedan auditarlos sin tener que leer todo el sistema. Escribe un breve manual de operaciones: cómo rotar las claves, cómo vaciar la cola y cómo revertir la última operación de ingestión.

┌──────────────────────────┐
│ Qwen3.8-Flash-Next       │
│ 125B MoE / ~6B active   │
└────────────┬─────────────┘
             │
             ▼
┌──────────────────────────┐
│ UD-Q4_K_XL GGUF          │
│ ~111GB                   │
└────────────┬─────────────┘
             │
             ▼
┌──────────────────────────┐
│ llama.cpp                │
│ CUDA + 131K Context      │
└────────────┬─────────────┘
             │
             ▼
┌──────────────────────────┐
│ OpenAI-Compatible API    │
│ localhost:8080/v1        │
└────────────┬─────────────┘
             │
             ▼
┌──────────────────────────┐
│ OpenCode                 │
│ Agentic Coding           │
└────────────┬─────────────┘
             │
             ▼
┌──────────────────────────┐
│ Fully Local AI Developer │
│ Environment              │
└──────────────────────────┘

Conclusión

Al trabajar en la etapa de conclusión, primero escribe el contrato: los datos necesarios, la señal de éxito y qué ocurre en caso de fallo parcial. Esa lista de verificación mantiene honestas las futuras modificaciones del código. Documenta junto con ello el camino óptimo y el camino de recuperación. Las reintentos, los controles humanos y el manejo de mensajes no entregados forman parte del producto, no de mejoras posteriores. Escribe un breve manual de operaciones: cómo rotar claves, cómo vaciar la cola y cómo revertir la última inserción.

Lista de verificación operativa