Como configurar e executar o Qwen 3 localmente com o Ollama

O Qwen3 é a última geração de modelos de linguagem de grande porte de peso aberto da Alibaba. Com suporte para mais de 100 idiomas e excelente desempenho em tarefas de raciocínio, codificação e tradução, o Qwen3 rivaliza com muitos modelos de primeira linha disponíveis atualmente, incluindo DeepSeek-R1, o3-mini e Gemini 2.5.

Neste tutorial, explicarei passo a passo como executar o Qwen3 localmente usando o Ollama.

Também criaremos um aplicativo local leve com o Qwen 3. O aplicativo permitirá que você alterne entre os modos de raciocínio do Qwen3 e traduza entre diferentes idiomas.

Mantemos nossos leitores atualizados sobre as últimas novidades em IA enviando o The Median, nosso boletim informativo gratuito de sexta-feira que detalha as principais histórias da semana. Inscreva-se e fique atento em apenas alguns minutos por semana:

Por que executar o Qwen3 localmente?

A execução do Qwen3 localmente oferece vários benefícios importantes:

• Privacidade: Seus dados nunca saem de sua máquina.
• Latência: A inferência local é mais rápida sem as viagens de ida e volta da API.
• Eficiência de custo: Você não precisa pagar taxas simbólicas ou contas na nuvem.
• Controle: Você pode ajustar os prompts, escolher modelos e configurar modos de raciocínio.
• Acesso off-line: Você pode trabalhar sem uma conexão com a Internet depois de fazer o download do modelo.

O Qwen3 é otimizado para raciocínio profundo (modo de raciocínio) e respostas rápidas (modo de não raciocínio), e suporta mais de 100 idiomas. Vamos configurá-lo localmente.

Configurando o Qwen3 localmente com o Ollama

O Ollama é uma ferramenta que permite que você execute modelos de linguagem como o Llama ou o Qwen localmente em seu computador com uma interface de linha de comando simples.

Etapa 1: Instalar Ollama

Faça o download do Ollama para macOS, Windows ou Linux em: https://ollama.com/download.

Siga as instruções do instalador e, após a instalação, verifique executando isso no terminal:

ollama --versionTecnologia

Etapa 2: Faça o download e execute o Qwen3

A Ollama oferece uma gama crescente de modelos Qwen3 projetados para atender a uma variedade de configurações de hardware, desde laptops leves até servidores de ponta.

ollama run qwen3Tecnologia

A execução do comando acima iniciará o modelo padrão do Qwen3 no Ollama, que atualmente tem como padrão o endereço qwen3:8b. Se você estiver trabalhando com recursos limitados ou quiser tempos de inicialização mais rápidos, poderá executar explicitamente variantes menores, como o modelo 4B:

ollama run qwen3:4bTecnologia

Atualmente, o Qwen3 está disponível em diversas variantes, desde o menor modelo de parâmetros de 0,6 b (523 MB) até o maior de 235 b (142 GB). Essas variantes menores oferecem um desempenho impressionante para raciocínio, tradução e geração de código, especialmente quando usadas no modo de raciocínio.

Os modelos MoE (30b-a3b, 235b-a22b) são particularmente interessantes, pois ativam apenas um subconjunto de especialistas por etapa de inferência, o que permite uma contagem maciça de parâmetros totais e, ao mesmo tempo, mantém os custos de tempo de execução eficientes.

Em geral, use o maior modelo que seu hardware puder suportar e volte para os modelos 8B ou 4B para experimentos locais responsivos em máquinas de consumo.

Aqui está uma rápida recapitulação de todos os modelos Qwen3 que você pode executar:

Etapa 3: Execute o Qwen3 em segundo plano (opcional)

Para servir o modelo via API, execute este comando no terminal:

ollama serveTecnologia

Isso tornará o modelo disponível para integração com outros aplicativos em http://localhost:11434.

Usando o Qwen3 localmente

Nesta seção, mostrarei várias maneiras de usar o Qwen3 localmente, desde a interação básica com a CLI até a integração do modelo com o Python.

Opção 1: Execução de inferência via CLI

Depois que o modelo for baixado, você poderá interagir com o Qwen3 diretamente no terminal. Execute o seguinte comando em seu terminal:

echo "What is the capital of Brazil? /think" | ollama run qwen3:8bTecnologia

Isso é útil para testes rápidos ou interação leve sem que você precise escrever nenhum código. A tag /think no final do prompt instrui o modelo a se envolver em um raciocínio mais profundo, passo a passo. Você pode substituí-lo por /no_think para obter uma resposta mais rápida e superficial ou omiti-lo totalmente para usar o modo de raciocínio padrão do modelo.

Opção 2: Acesso ao Qwen3 via API

Quando o ollama serve estiver em execução em segundo plano, você poderá interagir com o Qwen3 programaticamente usando uma API HTTP, o que é perfeito para integração de back-end, automação ou teste de clientes REST.

curl http://localhost:11434/api/chat -d '{
  "model": "qwen3:8b",
  "messages": [{ "role": "user", "content": "Define entropy in physics. /think" }],
  "stream": false
}'Tecnologia

Veja como isso funciona:

• curl Você faz uma solicitação POST (como chamamos a API) para o servidor Ollama local em execução em localhost:11434.
• A carga útil é um objeto JSON com:
• "model": Especifica o modelo a ser usado (aqui é: qwen3:8b).
• "messages": Uma lista de mensagens de bate-papo contendo role e content.
• "stream": false: Garante que a resposta seja retornada de uma só vez, e não token por token.

Opção 3: Acessando o Qwen3 via Python

Se você estiver trabalhando em um ambiente Python (como Jupyter, VSCode ou um script), a maneira mais fácil de interagir com o Qwen3 é por meio do Ollama Python SDK. Comece instalando o ollama:

pip install ollamaTecnologia

Em seguida, execute seu modelo Qwen3 com este script (estamos usando qwen3:8b abaixo):

import ollama
response = ollama.chat(
    model="qwen3:8b",
    messages=[
        {"role": "user", "content": "Summarize the theory of evolution. /think"}
    ]
)
print(response["message"]["content"])Tecnologia

No código acima: 

• ollama.chat(...) envia uma solicitação no estilo de bate-papo para o servidor Ollama local.
• Você especifica o modelo (qwen3:8b) e uma lista de mensagens em um formato semelhante à API da OpenAI.
• A tag /think informa ao modelo que você deve raciocinar passo a passo.
• Por fim, a resposta é retornada como um dicionário, e você pode acessar a resposta do modelo usando ["message"]["content"].

Essa abordagem é ideal para experimentação local, prototipagem ou criação de aplicativos apoiados pelo LLM sem depender de APIs de nuvem.

Criando um aplicativo de raciocínio local com o Qwen3

O Qwen3 oferece suporte ao comportamento de inferência híbrida usando as tags /think (raciocínio profundo) e /no_think (resposta rápida). Nesta seção, usaremos o Gradio para criar um aplicativo da Web local interativo com duas guias separadas:

1. Uma interface de raciocínio para alternar entre os modos de pensamento.
2. Uma interface multilíngue para traduzir ou processar textos em diferentes idiomas.

Etapa 1: Demonstração de raciocínio híbrido 

Nesta etapa, criamos nossa guia de raciocínio híbrido com as tags /think e /no_think.

import gradio as gr
import subprocess
def reasoning_qwen3(prompt, mode):
    prompt_with_mode = f"{prompt} /{mode}"
    result = subprocess.run(
        ["ollama", "run", "qwen3:8b"],
        input=prompt_with_mode.encode(),
        stdout=subprocess.PIPE
    )
    return result.stdout.decode()
reasoning_ui = gr.Interface(
    fn=reasoning_qwen3,
    inputs=[
        gr.Textbox(label="Enter your prompt"),
        gr.Radio(["think", "no_think"], label="Reasoning Mode", value="think")
    ],
    outputs="text",
    title="Qwen3 Reasoning Mode Demo",
    description="Switch between /think and /no_think to control response depth."
)Tecnologia

No código acima:

• A função reasoning_qwen3() recebe um prompt de usuário e um modo de raciocínio ("think" ou "no_think").
• Ele acrescenta o modo selecionado como um sufixo ao prompt.
• Em seguida, o método subprocess.run() executa o comando ollama run qwen3:8b, alimentando o prompt como entrada padrão.
• Por fim, a saída (resposta do Qwen3) é capturada e retornada como uma string decodificada.

Depois que a função geradora de saída é definida, a função gr.Interface() a transforma em uma interface de usuário interativa da Web, especificando os componentes de entrada - um Textbox para o prompt e um botão Radio para selecionar o modo de raciocínio - e mapeando-os para as entradas da função.

Etapa 2: Demonstração de aplicativo multilíngue

Agora, vamos configurar nossa guia de aplicativo multilíngue.

import gradio as gr
import subprocess
def multilingual_qwen3(prompt, lang):
    if lang != "English":
        prompt = f"Translate to {lang}: {prompt}"
    result = subprocess.run(
        ["ollama", "run", "qwen3:8b"],
        input=prompt.encode(),
        stdout=subprocess.PIPE
    )
    return result.stdout.decode()
multilingual_ui = gr.Interface(
    fn=multilingual_qwen3,
    inputs=[
        gr.Textbox(label="Enter your prompt"),
        gr.Dropdown(["English", "French", "Hindi", "Chinese"], label="Target Language", value="English")
    ],
    outputs="text",
    title="Qwen3 Multilingual Translator",
    description="Use Qwen3 locally to translate prompts to different languages."
)Tecnologia

Semelhante à etapa anterior, esse código funciona da seguinte forma:

• A função multilingual_qwen3() recebe um prompt e um idioma de destino.
• Se o destino não for o inglês, ele anexa a instrução "Translate to {lang}:" para orientar o modelo.
• Novamente, o modelo é executado localmente por meio de um subprocesso usando o Ollama.
• O resultado é retornado como texto simples.

Etapa 3: Abra as duas guias no Gradio

Vamos reunir as duas guias em um aplicativo Gradio.

demo = gr.TabbedInterface(
    [reasoning_ui, multilingual_ui],
    tab_names=["Reasoning Mode", "Multilingual"]
)
demo.launch(debug = True)Tecnologia

Aqui está o que estamos fazendo no código acima:

• A função gr.TabbedInterface() cria uma interface do usuário com duas guias:
• Um para controlar a profundidade do raciocínio.
• Um para tradução rápida multilíngue.
• A função demo.launch(debug=True) executa o aplicativo localmente e o abre no navegador com a depuração ativada.

Conclusão

O Qwen3 traz raciocínio avançado, decodificação rápida e suporte multilíngue para sua máquina local usando Ollama.

Com uma configuração mínima, você pode:

• Execute a inferência LLM local sem a dependência da nuvem
• Alternar entre respostas rápidas e ponderadas
• Use APIs ou Python para criar aplicativos inteligentes

Se você quiser ter uma visão geral dos recursos do Qwen3, recomendo a leitura deste blog introdutório sobre Qwen3.