# Hermes Agent com um modelo local: ligar o Ollama

> Como ligar um modelo local ao Hermes Agent: Local Models na aplicação de desktop ou Ollama, um modelo com chamada de ferramentas, contexto de 64 000 e como verificar se funciona.

Source: https://ailoot.ai/blog/pt-pt/hermes-local-model-ollama-context/
Canonical: https://ailoot.ai/blog/pt-pt/hermes-local-model-ollama-context/
Language: pt-PT
Publisher: Ailoot (https://ailoot.ai/)
Translation: guide-115
Revision: sha256-df853c93d3e0e2fd47deb8c47bd96924596ff20ad5df305e36a73a497b587953


Pode ligar um modelo local ao Hermes Agent na aplicação de desktop através de Settings → Providers → Local Models em quatro cliques, ou manualmente através do Ollama. Em qualquer dos casos, não é necessária uma chave, não paga por cada pedido e a conversa não sai do seu computador.

A execução de um modelo local não custa nada, e o Hermes consegue trabalhar com ele. O mais importante é escolher um modelo capaz de trabalhar com ficheiros e comandos e dar-lhe um contexto de, pelo menos, 64 000; caso contrário, o agente transforma-se num chat normal.

Vejamos para que é útil hoje um modelo local, como ligá-lo e como verificar se o agente está a trabalhar com ficheiros. Vamos a isso.

Documentação de referência da Ailoot: [ailoot.ai/docs/](https://ailoot.ai/docs/).



<div class="aside" data-semantic="key-takeaway" role="note" aria-label="Pontos principais desta secção">

Pontos principais

A forma mais fácil é na aplicação de desktop Hermes: Settings → Providers → Local Models, Install runtime, escolha um modelo, Download e Use. A aplicação escolhe o tamanho do contexto por si. Com o Ollama: transfira um modelo com chamada de ferramentas (na tabela do Hermes, apenas `gemma4:31b` suporta essa funcionalidade e precisa de 24+ GB de memória), defina um contexto de 64 000 em vez do valor predefinido de 2 048 e selecione Custom Endpoint em `hermes setup`, com o endereço `http://localhost:11434/v1` e sem chave. Verifique-o com uma tarefa que produza um resultado no disco, não pelo texto da resposta.

</div>

## Deve usar um modelo local com um agente?





Onde um modelo local já é útil:

- **Transcrição de fala.** Existem modelos gratuitos e de código aberto para isso: são pequenos e reconhecem bem o áudio. A sua voz não vai para a nuvem, por isso todos os seus planos astutos ficam consigo. Há um guia para configurar isto [num artigo separado](https://ailoot.ai/blog/pt-pt/free-voice-input-whisper/).
- **Tarefas de rotina.** Já pode usar modelos pequeninos e estúpidos para tarefas de rotina: conseguem executá-las.
- **Dados que tem receio de enviar para fora.** Se estiver mesmo preocupado, pode executar um modelo no seu próprio computador. Mas a qualidade será fraca.

No próximo ano, os modelos locais provavelmente ocuparão ainda menos espaço. Já existem métodos de compressão poderosos, e pode usar RAM em vez de memória de vídeo. Acho que, dentro de um ano ou assim, toda a gente terá uma caixinha com um pequeno modelo estúpido que executa tarefas ao nível do Sonnet 5. Veremos.

Para a configuração, é útil ter à mão uma tabela «que modelo para que tarefa» e um PDF com os comandos de instalação do Hermes.

## A forma mais fácil: Local Models no Hermes para desktop

Se tiver a aplicação de desktop Hermes, não precisa de instalar nada manualmente. O Hermes instala o servidor llama.cpp local, transfere um modelo e escolhe o tamanho do contexto por si:

1. Abra **Settings → Providers → Local Models** ou escolha **Run models locally** no primeiro arranque.
2. Clique em **Install runtime**: o Hermes transfere uma compilação do llama.cpp para o seu hardware; são algumas centenas de megabytes.
3. Escolha um modelo do catálogo e clique em **Download**.
4. Clique em **Use**: os novos chats passam a usar o modelo local.

Cada modelo do catálogo tem uma etiqueta colorida: verde significa que cabe por inteiro na memória de vídeo, amarelo significa que funciona através da RAM e é mais lento, e vermelho significa que é demasiado grande para o seu computador. A aplicação define um contexto de 64 000 ou mais para os modelos recomendados. Uma placa gráfica com 8+ GB consegue executar os modelos pequenos do catálogo; uma com 16+ GB consegue executar modelos 27-35B. Se não usar um modelo durante 15 minutos, a aplicação descarrega-o da memória; volta a carregá-lo quando enviar outra mensagem.

A secção está incluída nas compilações de teste (canary) da aplicação; nas outras compilações, abra-a com a opção de arranque `--local`. Se não vir Local Models nas definições, é provavelmente esse o motivo. No terminal, o percurso é o mesmo: `hermes model` → **Local models**.

Depois de escolher um modelo, verifique-o com uma tarefa que envolva um ficheiro, como na secção abaixo.

Se criar os seus próprios projetos com agentes de IA, verifique o resultado numa tarefa pequena e real.



## Usar o Ollama: de que hardware precisa

Precisa do Ollama se o Hermes estiver instalado num servidor ou se não tiver a secção Local Models. Requisitos de hardware do guia do Hermes:

| O quê | Mínimo | Melhor |
|----|----|----|
| RAM | 8 GB (modelos 3B) | 32+ GB (modelos 27B+) |
| Espaço em disco | 5 GB | 30+ GB se tiver vários modelos |
| Processador | 4 núcleos | 8+ núcleos |
| Placa gráfica | Não é necessária | Uma NVIDIA com 8+ GB de memória de vídeo faz uma diferença notória |

8 GB chegam apenas para um modelo pequeno que responde só com texto. Para que o modelo funcione como agente, precisa de 24 GB ou mais; consulte o passo 2 para obter mais detalhes. Tudo funciona sem placa gráfica, mas lentamente: um modelo 9B num processador de 8 núcleos gera cerca de 10 tokens por segundo; um modelo 31B, 2-5, e cada resposta demora 30-120 segundos.

## Passo 1. Instale o Ollama

O Ollama executa modelos diretamente no seu computador. Em Mac e Linux, instale-o com um comando no terminal:

```bash
curl -fsSL https://ollama.com/install.sh | sh
```

No Windows, o comando do PowerShell é:

```powershell
irm https://ollama.com/install.ps1 | iex
```

Verifique se o programa está instalado e se o servidor responde:

```bash
ollama --version
curl http://localhost:11434/api/tags
```

Se ainda não tiver modelos, o segundo comando devolve uma lista vazia. Lembre-se da porta 11434: o Hermes usa-a para chegar ao modelo.

## Passo 2. Transfira um modelo capaz de executar ações

O que faz um modelo? Gera texto. A camada que o envolve, o Hermes, trata do trabalho com ficheiros, comandos de terminal e pesquisa. Para a camada funcionar, o modelo tem de conseguir chamar ferramentas. Sem isso, o agente limita-se a responder e não faz nada.

| Modelo         | No disco | Memória | Chamada de ferramentas |
|---------------|----------|--------|--------------------|
| `gemma4:31b`  | ~20 GB   | 24+ GB | sim                |
| `gemma2:27b`  | ~16 GB   | 20+ GB | não                 |
| `gemma2:9b`   | ~5 GB    | 8+ GB  | não                 |
| `llama3.2:3b` | ~2 GB    | 4+ GB  | não                 |

Dos quatro modelos, apenas `gemma4:31b` funciona como agente. Se tiver menos de 24 GB de memória, não conseguirá executar um agente: os modelos da tabela só responderão com texto. Estão sempre a surgir modelos novos na biblioteca do Ollama; para cada um, verifique primeiro se consegue chamar ferramentas.

```bash
ollama pull gemma4:31b
```

Pode transferir vários modelos e alternar entre eles no Hermes com o comando `/model`.

## Passo 3. Aumente o contexto para 64 000

Por predefinição, o Ollama dá ao modelo um contexto de 2 048 tokens, enquanto o Hermes precisa de, pelo menos, 64 000 para trabalhar com ferramentas. Com o contexto predefinido, a tarefa não caberá e o agente apresentará erros.

Crie uma variante do modelo com um contexto maior. Execute isto no terminal:

```bash
cat > Modelfile << 'EOF'
FROM gemma4:31b
PARAMETER num_ctx 64000
EOF

ollama create gemma4-64k -f Modelfile
```

Agora tem o modelo `gemma4-64k`. A partir de agora, use-o em todo o lado, em vez do original.

## Passo 4. Ligue-o ao Hermes

Inicie o assistente de configuração:

```bash
hermes setup
```

Quando lhe perguntarem pelo fornecedor, escolha **Custom Endpoint** e introduza:

- endereço: `http://localhost:11434/v1`;
- chave: deixe em branco ou introduza `no-key`;
- modelo: `gemma4-64k`.

Pode introduzir a mesma configuração manualmente em `~/.hermes/config.yaml`:

```yaml
model:
  default: "gemma4-64k"
  provider: "custom"
  base_url: "http://localhost:11434/v1"
```

## Como verificar se o agente funciona

Execute `hermes` e dê-lhe uma tarefa cujo resultado seja visível no disco. Por exemplo: «Liste todos os ficheiros Python nesta pasta e conte as linhas de cada um» e, em seguida, «Crie um ficheiro chamado test.txt». Verifique com o comando `ls` ou na pasta se o ficheiro apareceu. Um modelo sem ferramentas pode produzir tranquilamente uma lista com aspeto plausível sem abrir um único ficheiro.

Quanto mais barata for a rede neuronal que usar, mais avançado terá de ser o editor de cabedal que ela exige. Esse editor é você. Quanto mais inteligente for a sua rede neuronal, menos terá de usar a sua própria cabeça, mas terá sempre de trabalhar.

Vídeo sobre a configuração completa do Hermes Agent desde o início:

<figure>
O vídeo será carregado quando percorrer a página
<figcaption>Guia completo do Hermes Agent desde o início para automatização empresarial</figcaption>
</figure>

O vídeo mostra como instalar o Hermes desde o início, criar o seu primeiro funcionário de IA e comparar o pagamento por cada pedido com uma subscrição.

## Porque é que a primeira resposta demora vários minutos

A cada pedido, o Hermes envia uma parte fixa: as instruções do sistema e as descrições de todas as ferramentas ativadas. Sem uma placa gráfica, o modelo demora muito tempo a processar primeiro essa parte e, depois, escreve à velocidade habitual. É normal.

O que ajuda:

- `hermes prompt-size` mostra o tamanho da parte fixa;
- `hermes tools` desativa conjuntos de ferramentas desnecessários, e `hermes skills` ajuda a remover competências extra. Cada MCP ligado (serviço externo) aumenta o tamanho de cada pedido: se não o usar, desligue-o;
- `ollama ps` mostra quantas camadas do modelo foram transferidas para a placa gráfica. Mesmo uma transferência parcial acelera as coisas: um modelo 31B numa placa gráfica com 12 GB coloca cerca de 40 camadas nela; o processador trata do resto;
- numa máquina lenta, defina `HERMES_API_TIMEOUT=1800` em `~/.hermes/.env` para que o Hermes não interrompa o pedido por exceder o tempo limite.

Se o agente funcionar num servidor continuamente ou responder no Telegram, tenha em conta que o Ollama descarrega o modelo após 5 minutos de inatividade e a resposta seguinte começará por voltar a carregá-lo. A definição do Ollama `OLLAMA_KEEP_ALIVE=24h` mantém o modelo na memória. Encontra um guia para transferir o agente para um servidor com funcionamento contínuo [no artigo sobre executar o Hermes Agent num servidor sem interrupções](https://ailoot.ai/blog/pt-pt/hermes-agent-vps-24-7/), e para configurar um bot [no guia de configuração do Hermes para Telegram](https://ailoot.ai/blog/pt-pt/hermes-agent-telegram-setup/).

## Se algo correr mal

| O que vê | O que fazer |
|----|----|
| «Connection refused» no arranque | O Ollama não está a funcionar: `ollama serve` ou `sudo systemctl start ollama` |
| `provider 'ollama' has no endpoint configured` | Introduza o endereço do Ollama em `providers.ollama.base_url` ou `model.base_url` |
| O agente responde, mas não faz nada | O modelo não consegue chamar ferramentas; instale `gemma4:31b` e defina um contexto de 64 000 |
| Erros causados pelo contexto | O passo 3 ainda não foi concluído |
| As conversas longas são lentas | Execute `/compress` regularmente |

## Um modelo na nuvem como alternativa

A documentação do Hermes sugere manter um modelo local como modelo principal e ligar um modelo na nuvem como alternativa. Para isso, adicione o bloco da documentação ao lado da secção `model` em `~/.hermes/config.yaml`:

[Encontrar guias de ferramentas na documentação do Ailoot](https://ailoot.ai/docs/)

Se o modelo local falhar três vezes, o Hermes envia a tarefa para o modelo na nuvem. Esses pedidos são pagos e seguem para a nuvem.

Outra opção é deixar um modelo poderoso com subscrição tratar do raciocínio e da tomada de decisões, enquanto o modelo local executa tarefas de rotina. O objetivo é preservar a qualidade e reduzir gradualmente os custos dos tokens. Esta abordagem usa modelos mais baratos em passos individuais, podendo os modelos locais ser uma opção mais tarde. O artigo «Quanto custa um agente de IA para empresas?» descreve o custo dos agentes com subscrição. Se ainda não instalou o Hermes, comece pelo guia sobre [como instalar o Hermes Agent](https://ailoot.ai/blog/pt-pt/hermes-agent-install-setup/).

Já experimentou configurar um modelo local? O que executa com ele? Conte-nos; temos curiosidade.

<div class="section" role="doc-bibliography" aria-label="Fontes">

### Fontes

- [Hermes Agent: Run Hermes Locally with Ollama](https://raw.githubusercontent.com/NousResearch/hermes-agent/357f51c49106f47136caf9b01015467b7b633fe8/website/docs/guides%2Flocal-ollama-setup.md) - requisitos de hardware, instalação e verificação do Ollama, tabela de modelos e chamada de ferramentas, tamanhos de contexto de 2 048 e 64 000, ligação através de Custom Endpoint, primeira resposta e limite de tempo, descarga após 5 minutos, resolução de problemas, fornecedor alternativo (verificado a 7 de outubro de 2026, corresponde à versão atual).
- [Hermes Agent: Local Models](https://raw.githubusercontent.com/NousResearch/hermes-agent/main/website/docs/user-guide/local-models.md) - Local Models na aplicação de desktop, etiquetas de memória, contexto de 64K, descarga após 15 minutos, `hermes model`, opção `--local` (consultado a 7 de outubro de 2026).
- [Ollama: download for Windows](https://ollama.com/download/windows) - comandos de instalação para Mac, Linux e Windows (consultado a 7 de outubro de 2026).

</div>








Continue a explorar a Ailoot em [ailoot.ai](https://ailoot.ai/).

## Perguntas frequentes

### Como verifico o uso de ferramentas, em vez de uma resposta textual plausível?

Peça ao Hermes uma pequena tarefa com ficheiros e inspecione pessoalmente a pasta e o conteúdo real. Uma lista gerada no chat não prova que o modelo leu ficheiros ou criou um artefacto.

### Uma alternativa de modelo local mantém todos os pedidos na minha máquina?

Só enquanto os pedidos ficarem no modelo local. A configuração opcional de alternativa aqui descrita envia a tarefa ao fornecedor na nuvem após falhas locais repetidas; esses pedidos saem da máquina e podem ser pagos.


## Ailoot · A empresa e a sua carteira de projetos

A Ailoot assenta numa experiência operacional consolidada, numa ampla base de clientes, num serviço estável e no acompanhamento contínuo dos KPI.

A empresa e a sua carteira de projetos: milhões de clientes; vendas mensais na ordem dos milhares de milhões.

A Ailoot aplica essa experiência operacional ao acesso por API a funcionalidades de IA nos produtos dos clientes, agentes, aplicações e automatizações.