Cómo Usar la API de Qwen3.5 Gratis con NVIDIA

TL;DR

Qwen3.5 es el innovador modelo de lenguaje visual de 397 mil millones de parámetros de Alibaba con arquitectura Mixture of Experts (MoE). Puedes acceder a él de forma gratuita a través de los puntos finales acelerados por GPU de NVIDIA, registrándote en el Programa para Desarrolladores de NVIDIA. Esta guía te explica cómo obtener tu clave API, realizar tus primeras llamadas e integrar las capacidades multimodales de Qwen3.5 en tus aplicaciones.

Introducción

Qwen3.5 de Alibaba representa un avance significativo en la IA multimodal. Este modelo de 397 mil millones de parámetros combina la arquitectura Mixture of Experts (MoE) con Gated Delta Networks, lo que proporciona potentes capacidades de razonamiento mientras mantiene los parámetros activos en solo 17 mil millones. El resultado es un modelo que puede comprender imágenes, navegar por interfaces de usuario y manejar tareas multimodales complejas, todo accesible a través de una API gratuita.

¿Lo mejor? Puedes empezar a usar Qwen3.5 gratis ahora mismo a través de la plataforma para desarrolladores de NVIDIA. Ya sea que estés construyendo agentes de IA, desarrollando aplicaciones de razonamiento visual o explorando la IA multimodal, esta guía te acompañará en cada paso.

¿Qué es Qwen3.5 VLM?

Qwen3.5 es el primer modelo nativo de lenguaje visual de Alibaba de la serie Qwen3.5, diseñado específicamente para construir agentes autónomos. A diferencia de los VLM anteriores que se adaptaron de modelos solo de texto, Qwen3.5 se construyó desde cero para el razonamiento multimodal y la navegación de la interfaz de usuario.

Especificaciones Clave

Lo que hace especial a Qwen3.5

La arquitectura Mixture of Experts (MoE) significa que solo un subconjunto de los parámetros del modelo está activo para cualquier entrada dada. Esto hace que el modelo sea computacionalmente eficiente mientras mantiene la capacidad de razonamiento complejo en todos los 397B parámetros.

Las Capacidades Nativas de Agente Multimodal distinguen a Qwen3.5 de otros VLM:

• Comprende y navega por interfaces de usuario
• Realiza razonamiento visual en interfaces móviles y web
• Maneja tareas de codificación complejas
• Potencia aplicaciones de chat con comprensión multimodal

Casos de Uso Ideales

• Codificación y Desarrollo Web: Escribe y depura código con contexto visual
• Razonamiento Visual: Analiza capturas de pantalla, fotos y elementos de la interfaz de usuario
• Aplicaciones de Chat: Construye IA conversacional con comprensión multimodal
• Búsqueda Compleja: Busca simultáneamente en imágenes y texto
• Automatización de UI: Navega e interactúa con interfaces de forma autónoma

Programa para Desarrolladores de NVIDIA: Obtén tu clave API gratuita

NVIDIA proporciona acceso gratuito a Qwen3.5 a través de sus puntos finales acelerados por GPU. Así es como puedes empezar:

Paso 1: Únete al Programa para Desarrolladores de NVIDIA

1. Visita build.nvidia.com
2. Haz clic en Iniciar Sesión o Crear Cuenta
3. Regístrate en el Programa para Desarrolladores de NVIDIA (gratuito)
4. Verifica tu dirección de correo electrónico

Paso 2: Obtén tu clave API

1. Después de iniciar sesión, navega a la configuración de tu cuenta
2. Busca API Keys o NVIDIA API Key
3. Copia tu clave API (comienza con nvapi-)
4. Guárdala de forma segura (la necesitarás para la autenticación)

Importante

Paso 3: Prueba tu acceso

Puedes probar Qwen3.5 directamente en tu navegador en build.nvidia.com/qwen/qwen3.5-397b-a17b. Esto te permite experimentar con indicaciones y evaluar el modelo con tus propios datos antes de escribir cualquier código.

Tu primera llamada a la API de Qwen3.5

Ahora, realicemos tu primera llamada a la API de Qwen3.5. La API es compatible con el formato de OpenAI, lo que facilita su integración en aplicaciones existentes.

Llamada Básica a la API

import requests

# Configuración
invoke_url = "https://integrate.api.nvidia.com/v1/chat/completions"
api_key = "TU_CLAVE_API_DE_NVIDIA"  # Reemplaza con tu clave API

headers = {
    "Authorization": f"Bearer {api_key}",
    "Accept": "application/json",
}

# Payload - solicitud simple solo de texto
payload = {
    "messages": [
        {
            "role": "user",
            "content": "¿Cuáles son las características clave de Qwen3.5 VLM?"
        }
    ],
    "model": "qwen/qwen3.5-397b-a17b",
    "max_tokens": 1024,
    "temperature": 0.7,
}

# Realizar la solicitud
session = requests.Session()
response = session.post(invoke_url, headers=headers, json=payload)
response.raise_for_status()

# Imprimir la respuesta
result = response.json()
print(result['choices'][0]['message']['content'])

Realizar Solicitudes Multimodales (Con Imágenes)

Para usar las capacidades de visión de Qwen3.5, incluye datos de imagen en tu solicitud:

import requests
import base64

# Función para codificar una imagen a base64
def encode_image(image_path):
    with open(image_path, "rb") as image_file:
        return base64.b64encode(image_file.read()).decode('utf-8')

# Codifica tu imagen
image_base64 = encode_image("screenshot.png")

invoke_url = "https://integrate.api.nvidia.com/v1/chat/completions"
api_key = "TU_CLAVE_API_DE_NVIDIA"

headers = {
    "Authorization": f"Bearer {api_key}",
    "Accept": "application/json",
}

# Solicitud multimodal con imagen
payload = {
    "messages": [
        {
            "role": "user",
            "content": [
                {
                    "type": "image_url",
                    "image_url": {"url": f"data:image/png;base64,{image_base64}"}
                },
                {
                    "type": "text",
                    "text": "¿Qué ves en esta imagen? Describe los elementos de la interfaz de usuario."
                }
            ]
        }
    ],
    "model": "qwen/qwen3.5-397b-a17b",
    "max_tokens": 1024,
}

response = requests.post(invoke_url, headers=headers, json=payload)
result = response.json()
print(result['choices'][0]['message']['content'])

Ejemplos de Código en Python y JavaScript

Python: Ejemplo Completo de Integración

import os
import requests
from requests.exceptions import RequestException

class QwenClient:
    """Cliente Python para la API de Qwen3.5"""

    def __init__(self, api_key=None):
        self.api_key = api_key or os.getenv("NVIDIA_API_KEY")
        self.endpoint = "https://integrate.api.nvidia.com/v1/chat/completions"
        self.model = "qwen/qwen3.5-397b-a17b"

    def chat(self, message, system_prompt=None, **kwargs):
        """Envía un mensaje de chat a Qwen3.5"""
        headers = {
            "Authorization": f"Bearer {self.api_key}",
            "Content-Type": "application/json"
        }

        messages = []
        if system_prompt:
            messages.append({"role": "system", "content": system_prompt})
        messages.append({"role": "user", "content": message})

        payload = {
            "messages": messages,
            "model": self.model,
            "max_tokens": kwargs.get("max_tokens", 2048),
            "temperature": kwargs.get("temperature", 0.7),
            "top_p": kwargs.get("top_p", 0.9),
        }

        # Habilitar el modo de pensamiento si se solicita
        if kwargs.get("thinking", False):
            payload["chat_template_kwargs"] = {"thinking": True}

        try:
            response = requests.post(
                self.endpoint,
                headers=headers,
                json=payload,
                timeout=kwargs.get("timeout", 60)
            )
            response.raise_for_status()
            return response.json()
        except RequestException as e:
            return {"error": str(e)}

    def chat_with_image(self, message, image_path, **kwargs):
        """Envía un mensaje de chat con imagen a Qwen3.5"""
        import base64

        with open(image_path, "rb") as f:
            image_base64 = base64.b64encode(f.read()).decode("utf-8")

        headers = {
            "Authorization": f"Bearer {self.api_key}",
            "Content-Type": "application/json"
        }

        payload = {
            "messages": [{
                "role": "user",
                "content": [
                    {"type": "image_url", "image_url": {"url": f"data:image/png;base64,{image_base64}"}},
                    {"type": "text", "text": message}
                ]
            }],
            "model": self.model,
            "max_tokens": kwargs.get("max_tokens", 2048),
            "temperature": kwargs.get("temperature", 0.7),
        }

        response = requests.post(self.endpoint, headers=headers, json=payload)
        response.raise_for_status()
        return response.json()


# Ejemplo de uso
client = QwenClient(api_key="TU_CLAVE_API_DE_NVIDIA")

# Chat solo de texto
result = client.chat("Explica la arquitectura Mixture of Experts en términos sencillos")
print(result['choices'][0]['message']['content'])

# Chat multimodal
result = client.chat_with_image(
    "¿Qué elementos de la interfaz de usuario hay en esta captura de pantalla?",
    "screenshot.png"
)
print(result['choices'][0]['message']['content'])

JavaScript/Node.js: Ejemplo Completo de Integración

const axios = require('axios');

class QwenClient {
  constructor(apiKey) {
    this.apiKey = apiKey;
    this.endpoint = 'https://integrate.api.nvidia.com/v1/chat/completions';
    this.model = 'qwen/qwen3.5-397b-a17b';
  }

  async chat(message, options = {}) {
    const { systemPrompt, temperature = 0.7, maxTokens = 2048, thinking = false } = options;

    const messages = [];
    if (systemPrompt) {
      messages.push({ role: 'system', content: systemPrompt });
    }
    messages.push({ role: 'user', content: message });

    const payload = {
      messages,
      model: this.model,
      temperature,
      max_tokens: maxTokens,
      ...(thinking && { chat_template_kwargs: { thinking: true } })
    };

    try {
      const response = await axios.post(this.endpoint, payload, {
        headers: {
          'Authorization': `Bearer ${this.apiKey}`,
          'Content-Type': 'application/json'
        },
        timeout: 60000
      });

      return response.data;
    } catch (error) {
      console.error('API Error:', error.response?.data || error.message);
      throw error;
    }
  }

  async chatWithImage(message, imageBase64, options = {}) {
    const { temperature = 0.7, maxTokens = 2048 } = options;

    const payload = {
      messages: [{
        role: 'user',
        content: [
          { type: 'image_url', image_url: { url: `data:image/png;base64,${imageBase64}` } },
          { type: 'text', text: message }
        ]
      }],
      model: this.model,
      temperature,
      max_tokens: maxTokens
    };

    const response = await axios.post(this.endpoint, payload, {
      headers: {
        'Authorization': `Bearer ${this.apiKey}`,
        'Content-Type': 'application/json'
      }
    });

    return response.data;
  }
}

// Uso
const client = new QwenClient(process.env.NVIDIA_API_KEY);

// Chat de texto
const result = await client.chat('¿Cuál es la ventaja de la arquitectura MoE?');
console.log(result.choices[0].message.content);

// Con el modo de pensamiento habilitado
const deepResult = await client.chat('Explica cómo funciona el razonamiento en los LLM', {
  thinking: true
});
console.log(deepResult.choices[0].message.content);

Características Avanzadas: Modo de Pensamiento y Llamada a Herramientas

Modo de Pensamiento

Qwen3.5 admite un modo avanzado de "pensamiento" que permite al modelo mostrar su proceso de razonamiento. Esto es particularmente útil para tareas complejas de resolución de problemas.

payload = {
    "messages": [{"role": "user", "content": "Resuelve esto paso a paso: Si un tren viaja 120km en 2 horas, ¿cuál es su velocidad?"}],
    "model": "qwen/qwen3.5-397b-a17b",
    "chat_template_kwargs": {"thinking": True},
    "max_tokens": 4096,
}

response = session.post(invoke_url, headers=headers, json=payload)
result = response.json()
print(result['choices'][0]['message']['content'])

Llamada a Herramientas

Qwen3.5 admite la llamada a funciones a través de herramientas compatibles con OpenAI. Esto te permite crear aplicaciones de agente que pueden ejecutar acciones reales.

import json

# Define las herramientas que el modelo puede usar
tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Obtener el clima actual para una ubicación",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {"type": "string", "description": "Nombre de la ciudad"}
                },
                "required": ["location"]
            }
        }
    }
]

payload = {
    "messages": [
        {"role": "user", "content": "¿Cómo está el tiempo en Tokio?"}
    ],
    "model": "qwen/qwen3.5-397b-a17b",
    "tools": tools,
    "tool_choice": "auto"
}

response = session.post(invoke_url, headers=headers, json=payload)
result = response.json()

# Comprobar si el modelo quiere llamar a una herramienta
if 'tool_calls' in result['choices'][0]['message']:
    tool_call = result['choices'][0]['message']['tool_calls'][0]
    print(f"El modelo quiere llamar: {tool_call['function']['name']}")
    print(f"Argumentos: {tool_call['function']['arguments']}")

Comprendiendo los Límites de Tasa y Precios

Nivel Gratuito Actual (Programa para Desarrolladores de NVIDIA)

Lo que esto significa para ti

• No se requiere tarjeta de crédito: Solo regístrate en el Programa para Desarrolladores de NVIDIA de forma gratuita
• Acelerado por GPU: Las solicitudes se ejecutan en GPUs NVIDIA Blackwell
• Listo para producción: Los mismos puntos finales se utilizan para cargas de trabajo de producción

Escalando a Producción

Cuando estés listo para ir más allá del nivel gratuito:

1. NVIDIA NIM: Despliega modelos en contenedores en cualquier lugar (nube, local, híbrido)
2. NeMo: Personaliza el modelo para tu dominio específico
3. Soporte empresarial: Contacta a NVIDIA para infraestructura dedicada

Despliegue en Producción con NVIDIA NIM

NVIDIA NIM (NVIDIA Inference Microservices) facilita llevar Qwen3.5 del desarrollo a la producción.

¿Qué es NIM?

NIM proporciona contenedores preconstruidos y optimizados para la inferencia de IA. Cada microservicio NIM empaqueta:

• El modelo con optimizaciones de rendimiento
• APIs estandarizadas (compatibles con OpenAI)
• Flexibilidad de despliegue (nube, local, edge)

Desplegando Qwen3.5 con NIM

# Extrae el contenedor NIM de Qwen3.5
docker pull nvcr.io/nim/qwen/qwen3.5-397b-a17b:latest

# Ejecuta el contenedor
docker run --gpus all --rm -p 8000:8000 \
  -e NVIDIA_API_KEY=$NVIDIA_API_KEY \
  nvcr.io/nim/qwen/qwen3.5-397b-a17b:latest

Ahora tu modelo se está ejecutando localmente en http://localhost:8000/v1/chat/completions.

Beneficios de NIM

• Despliegue en cualquier lugar: Ejecuta en local, en la nube o en entornos híbridos
• Rendimiento optimizado: Sintonizado para la inferencia con GPU de NVIDIA
• APIs consistentes: Interfaz compatible con OpenAI
• Escalable: Escala desde desarrollo hasta producción sin problemas

Personalización con NVIDIA NeMo

Para aplicaciones específicas de un dominio, puedes ajustar Qwen3.5 usando NVIDIA NeMo.

Capacidades del Framework NeMo

• Ajuste fino de alto rendimiento: Entrenamiento nativo de PyTorch
• Soporte LoRA: Personalización eficiente en memoria
• Entrenamiento multinodo: Soporte para Slurm y Kubernetes
• Integración con Hugging Face: Entrenamiento directo sobre puntos de control existentes

Ejemplo: Ajuste fino para VQA médico

NVIDIA proporciona un tutorial técnico para el ajuste fino de Qwen3.5 en conjuntos de datos radiológicos para la Respuesta a Preguntas Visuales médicas. Esto demuestra cómo adaptar el modelo para dominios especializados como la atención médica.

Conclusión

Qwen3.5 representa una emocionante oportunidad para usar un modelo de IA multimodal de vanguardia sin costo a través de la plataforma para desarrolladores de NVIDIA. Con su arquitectura MoE de 397B parámetros, capacidades de visión nativas y acceso API gratuito, es una excelente opción para:

• Construir agentes de IA multimodales
• Desarrollar aplicaciones de razonamiento visual
• Crear asistentes de codificación con contexto visual
• Automatizar tareas de navegación de interfaz de usuario

Empezar es sencillo: regístrate en el Programa para Desarrolladores de NVIDIA, obtén tu clave API y empieza a construir.

Si estás creando aplicaciones que se integran con Qwen3.5 u otras APIs de IA, Apidog proporciona la infraestructura de pruebas que necesitas. Prueba tus integraciones de API, valida respuestas, gestiona variables de entorno y automatiza tus flujos de trabajo de pruebas con la plataforma integral de Apidog.

Preguntas Frecuentes

¿Es realmente gratuito el uso de Qwen3.5?

Sí, NVIDIA proporciona acceso gratuito a los puntos finales acelerados por GPU de Qwen3.5 a través de su Programa para Desarrolladores. No se requiere tarjeta de crédito. Simplemente regístrate en build.nvidia.com para obtener tu clave API.

¿Qué diferencia a Qwen3.5 de otros VLM?

Qwen3.5 fue construido específicamente para agentes autónomos, no adaptado de un modelo solo de texto. Su arquitectura Mixture of Experts (397B total, 17B activos) proporciona un razonamiento potente sin dejar de ser computacionalmente eficiente. Es particularmente bueno en la navegación de la interfaz de usuario y las tareas de razonamiento visual.

¿Puedo usar Qwen3.5 para proyectos comerciales?

Consulta los términos de licencia actuales en la plataforma de NVIDIA. Para uso en producción, considera NVIDIA NIM para el despliegue o contacta a NVIDIA sobre opciones empresariales.

¿Cuál es la diferencia entre el nivel gratuito y NIM?

El nivel gratuito (Programa para Desarrolladores) utiliza puntos finales alojados por NVIDIA. NIM te permite desplegar el modelo tú mismo utilizando contenedores, ya sea en local, en tu nube o en entornos híbridos. NIM está diseñado para despliegues a escala de producción.

¿Cómo gestiono los límites de tasa?

El nivel gratuito tiene ciertos límites de tasa. Para límites más altos, considera actualizar a un acceso de producción a través de NVIDIA NIM o contactar a NVIDIA sobre opciones empresariales.

¿Puedo realizar un ajuste fino de Qwen3.5?

¡Sí! El framework NVIDIA NeMo proporciona herramientas para el ajuste fino de Qwen3.5 en tus datos específicos de dominio. Esto incluye LoRA para una personalización eficiente en memoria y soporte multinodo para el entrenamiento a gran escala.