Como executar vários modelos no Ollama: Qwen, Llama e DeepSeek em paralelo

Desde o Ollama 0.2, é possível executar vários modelos ao mesmo tempo. Você não precisa mais usar ollama run deepseek-coder para mudar para código e depois ollama run qwen2.5 para tradução, esperando mais de dez segundos a cada novo carregamento. Um único serviço pode chamar três modelos sob demanda: DeepSeek para código, Qwen para conteúdo em chinês e Llama para perguntas gerais.

Três variáveis de ambiente habilitam a execução paralela: OLLAMA_MAX_LOADED_MODELS controla quantos modelos ficam carregados ao mesmo tempo, OLLAMA_NUM_PARALLEL define a concorrência de cada modelo e OLLAMA_KEEP_ALIVE determina por quanto tempo eles permanecem em espera. A seguir, veremos como configurar essas opções, quais são os pontos fortes dos três modelos e como gerenciar a memória — pré-carregando os modelos mais usados, chamando os demais sob demanda e recorrendo à memória do sistema quando a GPU não for suficiente.

Configuração básica para executar vários modelos no Ollama

Comecemos com uma boa notícia: desde o Ollama 0.2, a execução paralela de vários modelos tem suporte nativo. Você não precisa instalar nenhum plugin adicional nem lidar com arquivos de configuração complexos. Algumas variáveis de ambiente bastam para deixar vários modelos prontos para uso.

A má notícia é que, se a memória da sua placa de vídeo (VRAM) não for suficiente, esses modelos podem consumir toda a memória do sistema. Quando isso acontece, o computador fica lento a ponto de testar sua paciência.

Três variáveis de ambiente essenciais

Abra o terminal e confira primeiro estas três variáveis:

# Número máximo de modelos carregados ao mesmo tempo
export OLLAMA_MAX_LOADED_MODELS=3

# Número máximo de solicitações processadas em paralelo por modelo
export OLLAMA_NUM_PARALLEL=2

# Tamanho máximo da fila de espera (novas solicitações serão recusadas ao ultrapassá-lo)
export OLLAMA_MAX_QUEUE=512

OLLAMA_MAX_LOADED_MODELS é a variável principal. Ao defini-la como 3, você pode executar Qwen, Llama e DeepSeek ao mesmo tempo. Mas não aumente esse valor sem pensar: ele é limitado pelo seu hardware. Falarei em detalhes sobre os requisitos de memória mais adiante.

OLLAMA_NUM_PARALLEL controla a capacidade de concorrência de cada modelo. Se o seu serviço recebe várias solicitações simultâneas, pode ser útil aumentar esse valor. Para uso pessoal, porém, o valor padrão costuma ser suficiente.

Configuração do serviço no Linux

Se você gerencia o serviço do Ollama com systemd, que é o padrão na maioria das distribuições Linux, a configuração também é simples:

sudo systemctl edit ollama.service

Adicione o seguinte conteúdo no editor:

[Service]
Environment="OLLAMA_MAX_LOADED_MODELS=3"
Environment="OLLAMA_NUM_PARALLEL=2"
Environment="OLLAMA_KEEP_ALIVE=30m"

Salve, feche o editor e reinicie o serviço:

sudo systemctl restart ollama

A variável OLLAMA_KEEP_ALIVE é especialmente útil. Ela controla por quanto tempo o modelo fica “em espera” na memória. Com o valor 30m, ele permanece carregado durante 30 minutos e não precisa ser recarregado na próxima chamada. Se quiser mantê-lo carregado indefinidamente, use -1.

Como saber se há memória suficiente?

Depois de concluir a configuração, resta uma pergunta: há memória suficiente?

Alibaba Cloud - Escolha dos desenvolvedores, 15% de desconto exclusivo em Lighthouse

Ganhar 15% off →Anúncio

Uma estimativa aproximada é que um modelo 7B precise de cerca de 4 a 5 GB de VRAM com quantização FP16, enquanto um modelo 14B exige entre 8 e 10 GB. Para carregar três modelos 7B ao mesmo tempo, você precisará de uma placa de vídeo com pelo menos 16 GB de VRAM.

Minha RTX 3060 tem apenas 12 GB de VRAM. Dois modelos 7B funcionam sem grandes problemas, mas o terceiro precisa recorrer à memória do sistema — e a velocidade cai bastante. No Mac com Apple Silicon, a memória do sistema e a memória da GPU são compartilhadas; 32 GB de memória unificada são mais do que suficientes para executar três modelos.

Características dos três modelos e estratégia de escolha

Com a configuração pronta, é hora de decidir qual dos três modelos usar. No começo, eu também ficava indeciso: tinha baixado os três, mas não sabia qual chamar em cada situação. Depois de algum tempo testando, identifiquei alguns padrões.

Qwen: excelente para chinês e vários idiomas

A família Qwen, de código aberto e desenvolvida pela Alibaba, é realmente forte em chinês. Já a usei para escrever vários documentos nesse idioma e traduzir alguns artigos técnicos em inglês, sempre com bons resultados. Segundo os dados oficiais, o Qwen oferece suporte a mais de 100 idiomas — não apenas chinês e inglês, mas também japonês, coreano, francês e espanhol.

Se você trabalha com frequência com conteúdo em chinês ou tradução multilíngue, o Qwen é a primeira opção. Usei o qwen2.5:7b para traduzir um documento técnico com 5.000 caracteres chineses, e a qualidade foi bem superior à de muitas ferramentas de tradução online. Ele lida especialmente bem com termos técnicos e não produz traduções literais estranhas, como converter “API endpoint” em algo equivalente a “ponto final da API” fora do contexto técnico.

Llama: o melhor equilíbrio para uso geral

A família Llama, da Meta, é uma veterana entre os modelos de código aberto. Quando você não souber exatamente qual é o tipo de tarefa, use o Llama: é pouco provável que dê errado.

Uma vantagem importante é a licença comercial flexível. Desde que o seu produto não ultrapasse 7 milhões de usuários ativos por mês, você pode usá-lo comercialmente sem custo. Para muitos desenvolvedores independentes e equipes pequenas, esse é um critério relevante.

Outra vantagem é a ampla janela de contexto. O Llama 3.2 chega a 128K tokens — espaço suficiente para quase um romance inteiro. Se você precisa processar documentos muito longos, a diferença fica evidente.

DeepSeek: uma ferramenta eficaz para programação e raciocínio

Comecei a usar o DeepSeek há pouco tempo, mas ele me conquistou rapidamente. Em tarefas de programação, sobretudo, o desempenho me surpreendeu: o código gerado tem boa qualidade e o modelo costuma explicar a lógica por iniciativa própria.

Segundo um relatório comparativo da Premai, o custo de raciocínio do DeepSeek é 95% menor que o de modelos semelhantes. Para quem executa muitas tarefas de raciocínio, essa é uma vantagem concreta. Um custo menor significa que você pode processar mais tarefas com hardware limitado.

Qual escolher? Esta tabela resolve

Minha preferência é simples: DeepSeek para programar, Qwen para escrever documentos em chinês e Llama para conteúdo em inglês ou tarefas cujo tipo não esteja claro. Com essa divisão, quase nunca preciso pensar muito sobre qual modelo escolher.

Troca de modelos e gerenciamento de memória

No começo, meu maior problema com vários modelos era a lentidão da troca. Sempre que eu chamava um modelo diferente, precisava esperar um pouco: o modelo era recarregado, as ventoinhas da placa de vídeo aceleravam e a espera se tornava frustrante. Mais tarde, descobri que era possível reduzir essa latência.

Por que a troca demora?

A latência para trocar de modelo fica, em geral, entre 10 e 30 segundos. O tempo exato depende do tamanho do modelo, da velocidade de leitura do disco e do estado da memória. Carregar um modelo 7B do disco para a GPU leva cerca de 10 a 15 segundos; um modelo 14B pode levar de 20 a 30 segundos.

Essa espera incomoda bastante no uso cotidiano. Durante a depuração de código, por exemplo, você pode usar o DeepSeek para gerar uma função e logo depois querer traduzir os comentários com o Qwen, mas acaba aguardando o carregamento.

keep_alive: mantenha o modelo pronto na memória

A solução é o OLLAMA_KEEP_ALIVE, mencionado anteriormente.

O princípio é simples: depois do primeiro carregamento, o modelo permanece na memória. Na próxima chamada, ele pode ser usado diretamente, sem outro carregamento.

Você pode definir a variável globalmente:

KiloClaw - OpenClaw gerenciado para empresas: orquestração de agentes IA e roteamento inteligente

Começar →Anúncio

export OLLAMA_KEEP_ALIVE=30m  # Manter o modelo carregado por 30 minutos
# ou
export OLLAMA_KEEP_ALIVE=-1   # Manter indefinidamente, até o descarregamento manual

Também é possível substituir esse valor em uma solicitação específica:

curl http://localhost:11434/api/generate \
  -d '{"model": "qwen2.5:7b", "prompt": "", "keep_alive": "60m"}'

Ao enviar uma solicitação vazia, com prompt sem conteúdo, o modelo é carregado e permanece na memória. É uma boa forma de pré-carregar os modelos mais usados para que as chamadas seguintes respondam de imediato.

Como descarregar um modelo manualmente

Se a memória estiver apertada, você pode descarregar um modelo manualmente:

curl http://localhost:11434/api/generate \
  -d '{"model": "qwen2.5:7b", "keep_alive": 0}'

Ao definir keep_alive como 0, o modelo é removido imediatamente da memória. Esse comando não exclui os arquivos do modelo; apenas libera a memória que ele ocupava.

Requisitos de memória por tamanho de modelo

Levei algum tempo para reunir os dados desta tabela. Use-os apenas como referência, pois vêm de relatos da comunidade e dos meus próprios testes:

Minha RTX 3060 tem 12 GB de VRAM. Com quantização Q4, consigo executar ao mesmo tempo um modelo 14B e um 7B, ou três modelos 7B. O terceiro modelo recorre à memória do sistema e fica um pouco mais lento, mas não trava.

Se a VRAM da sua placa de vídeo não for suficiente, mas você tiver bastante memória do sistema (32 GB ou mais), também poderá executar a inferência na CPU. Será muito mais lento, mas funcionará. Às vezes, isso já basta.

Uma dica: carregue primeiro os modelos mais usados

Costumo manter na GPU o modelo que mais uso e deixar os demais recorrerem à memória do sistema.

No meu fluxo de trabalho, por exemplo, o DeepSeek é o mais usado e fica sempre pronto na GPU. Qwen e Llama são usados com menos frequência e só são carregados quando necessário, possivelmente na memória do sistema.

Essa organização oferece a resposta mais rápida nas tarefas frequentes e aceita um pequeno atraso nas ocasionais, melhorando a experiência geral. Você pode ajustar a ordem de acordo com seus próprios hábitos.

Cenários práticos de uso

Depois de toda essa teoria, vejamos como usar a configuração na prática. Estes são alguns dos meus cenários mais frequentes e podem servir de ponto de partida.

Assistente de programação: código + documentação

Este é o cenário que mais uso. Durante a programação, dois modelos trabalham em conjunto:

• DeepSeek gera a lógica do código, explica o código e depura bugs
• Qwen traduz comentários do código e gera documentação em chinês

Veja um exemplo. Ao criar uma API, primeiro uso o DeepSeek para gerar a estrutura do código:

curl http://localhost:11434/api/generate \
  -d '{"model": "deepseek-coder:6.7b", "prompt": "Crie uma API RESTful em Express.js para cadastro e login de usuários"}'

Depois que o código é gerado, uso o Qwen para traduzir os comentários para chinês:

curl http://localhost:11434/api/generate \
  -d '{"model": "qwen2.5:7b", "prompt": "Traduza os comentários em inglês deste código para chinês:\n[conteúdo do código]"}'

Com essa divisão, os dois modelos são bem mais eficientes que um modelo sozinho. O código gerado pelo DeepSeek costuma ser confiável, e a tradução do Qwen é natural e fluente.

Vultr - Servidor cloud NVMe de alto desempenho, 32 locais globais, deploy Docker com um clique

Ver preços →Anúncio

Atendimento inteligente: chinês e inglês

Se você estiver criando um sistema de atendimento para usuários internacionais, pode organizar os modelos desta forma:

• Llama atende às solicitações de usuários em inglês
• Qwen atende às solicitações de usuários em chinês

A implementação não é complicada. Detecte o idioma da entrada do usuário e chame o modelo correspondente:

import requests

def get_response(user_input, language):
    model = "llama3.2:3b" if language == "en" else "qwen2.5:7b"

    response = requests.post(
        "http://localhost:11434/api/generate",
        json={"model": model, "prompt": user_input, "stream": False}
    )

    return response.json()["response"]

Assim, cada usuário recebe uma resposta natural no idioma correspondente, com uma experiência muito melhor do que a oferecida por um único modelo de idioma.

Perguntas e respostas: raciocínio + conversa

Algumas perguntas dos usuários exigem abordagens diferentes:

• DeepSeek cuida de perguntas que exigem raciocínio, como “por quê” e “como fazer”
• Llama cuida de perguntas abertas, como “o que você acha” e “qual é a sua opinião”

Perguntas de raciocínio exigem análise lógica. O DeepSeek é mais forte nessa área e tende a produzir respostas mais organizadas. Perguntas abertas não precisam de um raciocínio tão rigoroso, e as respostas do Llama soam mais naturais, como uma conversa.

Você pode identificar o tipo da pergunta por palavras-chave. Se ela contiver expressões como “por quê”, “motivo” ou “princípio”, use o DeepSeek; se contiver “o que você acha”, “qual é a sua opinião” ou “fale sobre”, use o Llama.

Um exemplo completo de chamada

Este script simples em Python escolhe automaticamente um modelo conforme o tipo da tarefa:

import requests

def call_ollama(task_type, prompt):
    """Escolhe o modelo adequado conforme o tipo da tarefa"""

    model_map = {
        "code": "deepseek-coder:6.7b",
        "chinese": "qwen2.5:7b",
        "english": "llama3.2:3b",
        "reasoning": "deepseek-coder:6.7b",
        "general": "llama3.2:3b"
    }

    model = model_map.get(task_type, "llama3.2:3b")

    # Pré-carregar o modelo (opcional)
    requests.post(
        "http://localhost:11434/api/generate",
        json={"model": model, "prompt": "", "keep_alive": "30m"}
    )

    # Chamada efetiva
    response = requests.post(
        "http://localhost/11434/api/generate",
        json={"model": model, "prompt": prompt, "stream": False}
    )

    return response.json()["response"]

# Exemplo de chamada
result = call_ollama("code", "Escreva uma função Python que calcule o N-ésimo termo da sequência de Fibonacci")
print(result)

O script é simples, mas já implementa um roteamento básico entre vários modelos. Você pode estendê-lo conforme necessário, adicionando outros tipos de tarefa, uma lógica de escolha mais sofisticada ou até combinando as respostas dos três modelos.

Se quiser conhecer melhor os fundamentos do Ollama, confira os dois primeiros artigos da série: “Introdução ao Ollama: os primeiros passos para executar grandes modelos de linguagem localmente” e “Parâmetros do Modelfile do Ollama em detalhes”. Este artigo dá continuidade à série e aborda o tema mais avançado da implantação de vários modelos.

Tabela de referência rápida da configuração

Conclusão

Depois de tudo isso, os pontos essenciais são apenas três:

1. Configure três variáveis de ambiente para executar vários modelos em paralelo. OLLAMA_MAX_LOADED_MODELS controla a quantidade, enquanto OLLAMA_KEEP_ALIVE controla o tempo de espera na memória.

2. Escolha o modelo conforme a tarefa. Use DeepSeek para código, Qwen para conteúdo em chinês e Llama para uso geral. Cada um tem seus pontos fortes.

3. Gerencie bem a memória. Pré-carregue os modelos mais usados e carregue os demais sob demanda. Quando a placa de vídeo não for suficiente, recorra à memória do sistema.

Se você tem uma placa de vídeo com pelo menos 16 GB de VRAM ou um Mac com pelo menos 32 GB de memória unificada, vale a pena testar a implantação paralela dos três modelos. Pode levar algum tempo para ajustar a configuração, mas, depois disso, a experiência fica muito melhor do que com um único modelo. Sem trocas frequentes nem espera por carregamentos, o fluxo de trabalho se torna bem mais fluido.

Se tiver alguma dúvida ou encontrar algum problema, compartilhe nos comentários. Também continuo aprendendo e talvez já tenha encontrado uma resposta para a mesma questão.