Como Usar a API Qwen3.5 Grátis com NVIDIA

Resumo

O Qwen3.5 é o inovador modelo de linguagem visual de 397 bilhões de parâmetros da Alibaba com arquitetura Mixture of Experts (MoE). Você pode acessá-lo gratuitamente através dos endpoints acelerados por GPU da NVIDIA, registrando-se no Programa de Desenvolvedores da NVIDIA. Este guia o levará através da obtenção de sua chave API, realizando suas primeiras chamadas e integrando as capacidades multimodais do Qwen3.5 em seus aplicativos.

Introdução

O Qwen3.5 da Alibaba representa um avanço significativo na IA multimodal. Este modelo de 397 bilhões de parâmetros combina a arquitetura Mixture of Experts (MoE) com Gated Delta Networks, oferecendo poderosas capacidades de raciocínio enquanto mantém os parâmetros ativos em apenas 17 bilhões. O resultado é um modelo que pode entender imagens, navegar em interfaces de usuário e lidar com tarefas multimodais complexas, tudo acessível através de uma API gratuita.

A melhor parte? Você pode começar a usar o Qwen3.5 gratuitamente agora mesmo através da plataforma de desenvolvedores da NVIDIA. Seja você construindo agentes de IA, desenvolvendo aplicativos de raciocínio visual ou explorando IA multimodal, este guia o acompanhará em cada etapa.

O que é Qwen3.5 VLM?

O Qwen3.5 é o primeiro modelo de linguagem visual nativo da Alibaba na série Qwen3.5, projetado especificamente para a construção de agentes autônomos. Ao contrário dos VLMs anteriores que foram adaptados de modelos apenas de texto, o Qwen3.5 foi construído desde o início para raciocínio multimodal e navegação de UI.

Especificações Principais

O que Torna o Qwen3.5 Especial

A arquitetura Mixture of Experts (MoE) significa que apenas um subconjunto dos parâmetros do modelo está ativo para qualquer entrada. Isso torna o modelo computacionalmente eficiente, mantendo a capacidade de raciocínio complexo em todos os 397 bilhões de parâmetros.

As Capacidades Nativas de Agente Multimodal distinguem o Qwen3.5 de outros VLMs:

• Compreende e navega em interfaces de usuário
• Realiza raciocínio visual em interfaces móveis e web
• Gerencia tarefas de codificação complexas
• Potencializa aplicativos de chat com compreensão multimodal

Casos de Uso Ideais

• Codificação e Desenvolvimento Web: Escreva e depure código com contexto visual
• Raciocínio Visual: Analise capturas de tela, fotos e elementos de UI
• Aplicativos de Chat: Construa IA conversacional com compreensão multimodal
• Busca Complexa: Pesquise em imagens e texto simultaneamente
• Automação de UI: Navegue e interaja com interfaces autonomamente

Programa de Desenvolvedores NVIDIA: Obtenha Sua Chave API Gratuita

A NVIDIA oferece acesso gratuito ao Qwen3.5 através de seus endpoints acelerados por GPU. Veja como começar:

Passo 1: Junte-se ao Programa de Desenvolvedores NVIDIA

1. Visite build.nvidia.com
2. Clique em Entrar ou Criar Conta
3. Registre-se no Programa de Desenvolvedores NVIDIA (gratuito)
4. Verifique seu endereço de e-mail

Passo 2: Obtenha Sua Chave API

1. Após fazer login, navegue até as configurações da sua conta
2. Encontre Chaves API ou Chave API NVIDIA
3. Copie sua chave API (começa com nvapi-)
4. Armazene-a com segurança (você precisará dela para autenticação)

Importante

Passo 3: Teste Seu Acesso

Você pode testar o Qwen3.5 diretamente em seu navegador em build.nvidia.com/qwen/qwen3.5-397b-a17b. Isso permite que você experimente prompts e avalie o modelo com seus próprios dados antes de escrever qualquer código.

Sua Primeira Chamada de API do Qwen3.5

Agora vamos fazer sua primeira chamada de API para o Qwen3.5. A API é compatível com o formato da OpenAI, facilitando a integração em aplicativos existentes.

Chamada de API Básica

import requests

# Configuration
invoke_url = "https://integrate.api.nvidia.com/v1/chat/completions"
api_key = "YOUR_NVIDIA_API_KEY"  # Replace with your API key

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

# Payload - simple text-only request
payload = {
    "messages": [
        {
            "role": "user",
            "content": "What are the key features of Qwen3.5 VLM?"
        }
    ],
    "model": "qwen/qwen3.5-397b-a17b",
    "max_tokens": 1024,
    "temperature": 0.7,
}

# Make the request
session = requests.Session()
response = session.post(invoke_url, headers=headers, json=payload)
response.raise_for_status()

# Print the response
result = response.json()
print(result['choices'][0]['message']['content'])

Fazendo Solicitações Multimodais (Com Imagens)

Para usar as capacidades de visão do Qwen3.5, inclua dados de imagem em sua solicitação:

import requests
import base64

# Function to encode image to base64
def encode_image(image_path):
    with open(image_path, "rb") as image_file:
        return base64.b64encode(image_file.read()).decode('utf-8')

# Encode your image
image_base64 = encode_image("screenshot.png")

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

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

# Multimodal request with image
payload = {
    "messages": [
        {
            "role": "user",
            "content": [
                {
                    "type": "image_url",
                    "image_url": {"url": f"data:image/png;base64,{image_base64}"}
                },
                {
                    "type": "text",
                    "text": "What do you see in this image? Describe the UI elements."
                }
            ]
        }
    ],
    "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'])

Exemplos de Código em Python e JavaScript

Python: Exemplo de Integração Completa

import os
import requests
from requests.exceptions import RequestException

class QwenClient:
    """Python client for Qwen3.5 API"""

    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):
        """Send a chat message to 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),
        }

        # Enable thinking mode if requested
        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):
        """Send a chat message with image to 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()


# Usage example
client = QwenClient(api_key="YOUR_NVIDIA_API_KEY")

# Text-only chat
result = client.chat("Explain Mixture of Experts architecture in simple terms")
print(result['choices'][0]['message']['content'])

# Multimodal chat
result = client.chat_with_image(
    "What UI elements are in this screenshot?",
    "screenshot.png"
)
print(result['choices'][0]['message']['content'])

JavaScript/Node.js: Exemplo de Integração Completa

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;
  }
}

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

// Text chat
const result = await client.chat('What is the advantage of MoE architecture?');
console.log(result.choices[0].message.content);

// With thinking enabled
const deepResult = await client.chat('Explain how reasoning works in LLMs', {
  thinking: true
});
console.log(deepResult.choices[0].message.content);

Recursos Avançados: Modo de Pensamento e Chamada de Ferramentas

Modo de Pensamento

O Qwen3.5 suporta um modo avançado de "pensamento" que permite ao modelo exibir seu processo de raciocínio. Isso é particularmente útil para tarefas complexas de resolução de problemas.

payload = {
    "messages": [{"role": "user", "content": "Solve this step by step: If a train travels 120km in 2 hours, what is its speed?"}],
    "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'])

Chamada de Ferramentas

O Qwen3.5 suporta chamadas de função através de ferramentas compatíveis com OpenAI. Isso permite que você construa aplicativos com agentes que podem executar ações reais.

import json

# Define tools for the model to use
tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Get current weather for a location",
            "parameters": {
                "type": "object",
                "properties": {
                    "location": {"type": "string", "description": "City name"}
                },
                "required": ["location"]
            }
        }
    }
]

payload = {
    "messages": [
        {"role": "user", "content": "What's the weather like in Tokyo?"}
    ],
    "model": "qwen/qwen3.5-397b-a17b",
    "tools": tools,
    "tool_choice": "auto"
}

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

# Check if model wants to call a tool
if 'tool_calls' in result['choices'][0]['message']:
    tool_call = result['choices'][0]['message']['tool_calls'][0]
    print(f"Model wants to call: {tool_call['function']['name']}")
    print(f"Arguments: {tool_call['function']['arguments']}")

Compreendendo Limites de Taxa e Preços

Nível Gratuito Atual (Programa de Desenvolvedores NVIDIA)

O Que Isso Significa Para Você

• Não é necessário cartão de crédito: Basta se registrar no Programa de Desenvolvedores NVIDIA gratuito
• Acelerado por GPU: As solicitações são executadas em GPUs NVIDIA Blackwell
• Pronto para produção: Mesmos endpoints usados para cargas de trabalho de produção

Escalando para Produção

1. NVIDIA NIM: Implante modelos conteinerizados em qualquer lugar (nuvem, on-premises, híbrido)
2. NeMo: Personalize o modelo para seu domínio específico
3. Suporte empresarial: Entre em contato com a NVIDIA para infraestrutura dedicada

Implantação em Produção com NVIDIA NIM

NVIDIA NIM (NVIDIA Inference Microservices) facilita a transição do Qwen3.5 do desenvolvimento para a produção.

O que é NIM?

O NIM fornece contêineres pré-construídos e otimizados para inferência de IA. Cada microsserviço NIM inclui:

• O modelo com otimizações de desempenho
• APIs padronizadas (compatíveis com OpenAI)
• Flexibilidade de implantação (nuvem, on-premises, edge)

Implantando Qwen3.5 com NIM

# Pull the Qwen3.5 NIM container
docker pull nvcr.io/nim/qwen/qwen3.5-397b-a17b:latest

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

Agora seu modelo está sendo executado localmente em http://localhost:8000/v1/chat/completions.

Benefícios do NIM

• Implantação em qualquer lugar: Execute on-premises, na nuvem ou em ambientes híbridos
• Desempenho otimizado: Sintonizado para inferência de GPU NVIDIA
• APIs consistentes: Interface compatível com OpenAI
• Escalável: Escale do desenvolvimento para a produção de forma contínua

Personalização com NVIDIA NeMo

Para aplicativos específicos de domínio, você pode ajustar o Qwen3.5 usando o NVIDIA NeMo.

Capacidades do Framework NeMo

• Ajuste fino de alto desempenho: Treinamento nativo PyTorch
• Suporte a LoRA: Personalização com uso eficiente de memória
• Treinamento multinó: Suporte a Slurm e Kubernetes
• Integração com Hugging Face: Treinamento direto em checkpoints existentes

Exemplo: Ajuste Fino para VQA Médico

A NVIDIA oferece um tutorial técnico para o ajuste fino do Qwen3.5 em conjuntos de dados radiológicos para Perguntas e Respostas Visuais médicas (VQA). Isso demonstra como adaptar o modelo para domínios especializados como a saúde.

Conclusão

O Qwen3.5 representa uma oportunidade empolgante de usar um modelo de IA multimodal de ponta sem custo através da plataforma de desenvolvedores da NVIDIA. Com sua arquitetura MoE de 397 bilhões de parâmetros, capacidades de visão nativas e acesso gratuito à API, é uma excelente escolha para:

• Construir agentes de IA multimodais
• Desenvolver aplicativos de raciocínio visual
• Criar assistentes de codificação com contexto visual
• Automatizar tarefas de navegação de UI

Começar é simples: registre-se no Programa de Desenvolvedores NVIDIA, obtenha sua chave API e comece a construir.

Se você está construindo aplicativos que se integram com o Qwen3.5 ou outras APIs de IA, o Apidog oferece a infraestrutura de teste de que você precisa. Teste suas integrações de API, valide respostas, gerencie variáveis de ambiente e automatize seus fluxos de trabalho de teste com a plataforma abrangente do Apidog.

FAQ

O Qwen3.5 é realmente gratuito para usar?

Sim, a NVIDIA oferece acesso gratuito aos endpoints acelerados por GPU do Qwen3.5 através de seu Programa de Desenvolvedores. Não é necessário cartão de crédito. Basta registrar-se em build.nvidia.com para obter sua chave API.

O que diferencia o Qwen3.5 de outros VLMs?

O Qwen3.5 foi construído especificamente para agentes autônomos, e não adaptado de um modelo apenas de texto. Sua arquitetura Mixture of Experts (397B total, 17B ativos) fornece um raciocínio poderoso, mantendo-se computacionalmente eficiente. É particularmente bom em tarefas de navegação de UI e raciocínio visual.

Posso usar o Qwen3.5 para projetos comerciais?

Verifique os termos de licenciamento atuais na plataforma da NVIDIA. Para uso em produção, considere o NVIDIA NIM para implantação ou entre em contato com a NVIDIA sobre opções empresariais.

Qual a diferença entre o nível gratuito e o NIM?

O nível gratuito (Programa de Desenvolvedores) usa endpoints hospedados pela NVIDIA. O NIM permite que você implante o modelo por conta própria usando contêineres, seja on-premises, em sua nuvem ou em ambientes híbridos. O NIM é projetado para implantações em escala de produção.

Como lido com o limite de taxa?

O nível gratuito possui certos limites de taxa. Para limites mais altos, considere fazer upgrade para acesso de produção através do NVIDIA NIM ou entrar em contato com a NVIDIA sobre opções empresariais.

Posso fazer ajuste fino no Qwen3.5?

Sim! O framework NVIDIA NeMo fornece ferramentas para o ajuste fino do Qwen3.5 em seus dados específicos de domínio. Isso inclui LoRA para personalização eficiente em termos de memória e suporte multinó para treinamento em larga escala.