llama.cpp no Windows nativo | Isso é ENORME

Autoria: Prompt Engineer 48 · Assistir no YouTube

Vídeo de autoria do canal indicado, não da IANIA; todos os direitos pertencem ao criador. Transcrição, resumo e tradução gerados automaticamente; o conteúdo no idioma original é preservado na versão em idioma original.

Idioma original: inglês

Vídeo original: LlamaCPP on Native Windows | This is HUGE · Canal: Prompt Engineer 48 · 09:13 · Assistir no YouTube

Tópicos: Ferramentas de desenvolvimento com IA, Inferência e otimização de modelos, Modelos locais e open source

Resumo

O vídeo demonstra a instalação e o uso do llama.cpp em um aplicativo nativo do Windows, com modelos baixados do Hugging Face e controlados pela bandeja do sistema. O apresentador testa a interface de chat, chamadas via curl e Python, visão, tool calling, saída estruturada e geração de código, tudo localmente. Em uma máquina com GPU de 8 GB, Gemma 4 alcança cerca de 58 tokens por segundo, enquanto o processamento do prompt chega a milhares de tokens por segundo. O vídeo também destaca limitações de memória, o tempo inicial para carregar um modelo e o consumo extra de tokens de raciocínio do Gemma 4.

Pontos-chave

O aplicativo para Windows instala o llama.cpp sem exigir terminal, WSL, Python ou configuração manual do CUDA toolkit.
Os modelos são baixados do Hugging Face e ficam no cache compartilhado com outras ferramentas Hugging Face.
O aplicativo oferece uma interface de chat, sobreposição acessível por atalho e gerenciamento de modelos pela bandeja do sistema.
O servidor local na porta 9931 é compatível com a OpenAI API e pode ser acessado por curl, Python e outros aplicativos compatíveis.
Os testes demonstram processamento de imagens, tool calling, saída JSON estruturada e geração de código localmente.
Gemma 4 gerou cerca de 58 tokens por segundo, e Gemma 3 4B chegou a aproximadamente 61–69 tokens por segundo nos testes.
O processamento de prompts foi muito mais rápido que a geração: cerca de 2.800–3.100 tokens por segundo nos testes relatados.
Em uma GPU de 8 GB, o Gemma 4 E 4B cabe na memória de vídeo, mas modelos maiores apresentados no vídeo não cabem integralmente.

Capítulos

Início	Capítulo	Resumo
00:00	Demonstração e apresentação do aplicativo	O apresentador mostra o Gemma 4 rodando localmente no Windows e apresenta o aplicativo nativo do llama.cpp.
01:33	Instalação e uso da interface de chat	O vídeo mostra a instalação, o download de modelos, o cache compartilhado e a conversa com o modelo pela interface.
03:47	Servidor local, API e linha de comando	O apresentador demonstra o servidor compatível com a OpenAI API e acessa os modelos usando curl, Python e a CLI.
05:26	Testes de capacidades e desempenho	O vídeo testa visão, tool calling, saída estruturada e código, e compara a velocidade de processamento e geração.
07:02	Limites de memória e recomendações	O apresentador compara o consumo de tokens e o uso de VRAM, e recomenda modelos adequados para uma GPU de 8 GB.

Citações

Tudo está rodando no meu sistema local. — 00:00

Uma sessão de estudo completa rodando no meu laptop, sem API key e sem login. — 03:12

O comprimento de contexto é de 131.000 tokens. — 04:21

Ler é cerca de 50 vezes mais rápido do que escrever. — 07:33

Se você tem um PC com Windows 11 e quer IA local sem terminal, esta é a maneira mais fácil que encontrei para começar. — 08:41

Conceitos e entidades

llama.cpp (ferramenta): Projeto usado para executar modelos localmente e oferecer um servidor compatível com a OpenAI API.
gmml-orgs/llama.cpp (repo): Repositório apresentado no vídeo para o aplicativo nativo de Windows baseado no llama.cpp.
Hugging Face (empresa): Plataforma de onde o aplicativo baixa modelos e cujo cache é compartilhado com outras ferramentas.
Gemma 4 (modelo): Modelo testado no vídeo para chat, visão e outras tarefas, com geração de raciocínio que pode consumir tokens adicionais.
Gemma 3 (modelo): Modelo comparado ao Gemma 4 em velocidade de geração e processamento de prompts.
OpenAI API (conceito): Interface de API compatível oferecida pelo servidor local do aplicativo.
WinUI 3 (ferramenta): Tecnologia usada para criar o aplicativo nativo de Windows descrito no vídeo.
RunPod (empresa): Serviço de GPU mencionado pelo apresentador como opção de GPUs econômicas.

Tradução completa (pt-BR)

00:00 Esta é a Gemma 4 respondendo no meu laptop Windows a cerca de 58 tokens por segundo, e tudo é controlado por um único ícone na bandeja do sistema. Sem Linux, sem WSL, sem Mac. Agora, vale lembrar que este é o laptop AGB RTX 406 que tenho aqui. Tudo está rodando no meu sistema local. Neste vídeo, vou instalá-la do zero, executá-la de três maneiras diferentes e mostrar os números reais de velocidade, incluindo um que me surpreendeu. Vamos testar. Então, se você já tentou executar modelos

00:31 localmente, conhece a história. As ferramentas legais apareceram primeiro no Mac e, no Windows, você acabava num terminal, compilando o llama.cpp ou configurando o WSL. Agora temos um aplicativo nativo para Windows, e ele está aqui no blog do Hugging Face. Dá para ver que é um aplicativo WinUI 3 que fica na área de notificação. Você escolhe um modelo no hub do Hugging Face e ele é baixado com um clique. A página diz: “Sem terminal, sem etapa de compilação e sem privilégios de administrador”. E guarde isso, porque mais tarde vou mostrar o mesmo servidor respondendo a chamadas simples com curl e

01:02 Python. Vamos conferir o repo de verdade. É gmml-orgs/llama.cpp, e dá para ver que está sob a licença MIT, com cerca de 142 estrelas e 18 forks no momento em que estou gravando. A versão mais recente é a V0.12, de 10 de outubro. Então, este é um projeto muito novo, e vou dizer claramente: ainda está no início, então esperem algumas arestas. No site llama.app, há documentação sobre instalação, início rápido, linha de comando, servidor, interface web e servidor de API. Vamos usar praticamente

01:33 tudo isso neste vídeo. Certo, vamos instalar. Acesso llama.app, clico em download e o Windows abre um instalador. Aqui está a janela, e ela diz que o llama está pronto, com Hugging Face como publicador. Então, clico em iniciar. Agora, este aplicativo não tem uma janela própria. Ele fica na bandeja do sistema, ao lado do relógio, e, se você não o vir, clique na setinha para mostrar os ícones ocultos. Sinceramente, essa é toda a instalação. Não é preciso configurar Python nem o CUDA Toolkit manualmente. E, se o llama.cpp não estiver na máquina, o aplicativo o instala para

02:04 você. A documentação também lista outras formas de instalar: um script de instalação de uma linha para outras plataformas, binários pré-compilados, Docker e compilação a partir do código-fonte. Mas, no Windows, o aplicativo para desktop é a opção recomendada. Agora, clique no ícone do llama e este menu suspenso aparece. No topo, há uma lista de modelos recomendados, e você pode ver Gemma 3, Gemma 4 e alguns outros. Cada um mostra o tamanho em disco e se tem recursos de visão. Isso importa porque você pode conferir se cabe na sua GPU antes de baixar qualquer coisa. Escolho Gemma 4 e clico em download, e dá para ver o progresso ao vivo aqui.

02:37 Os modelos são armazenados no cache normal do Hugging Face, na pasta do seu usuário .cache huggingface hub. Assim, o llama.cpp e outras ferramentas do Hugging Face compartilham a mesma cópia. Você baixa uma vez. Certo, o modelo está carregado, então vamos abrir a interface web. Esta é a interface de chat do llama.cpp rodando nesta máquina. Primeiro, vou perguntar qual é o modelo, e dá para ver que, antes da resposta, aparece um bloco de raciocínio. A Gemma 4 pensa primeiro, e a interface web mostra esse pensamento, o que é útil para verificar por que ela respondeu daquela maneira. Agora, vamos tentar algo mais prático. Digito: “Você pode me entrevistar sobre

03:12 meu conhecimento de LLMs?” e ela me faz uma primeira pergunta sobre a diferença fundamental entre os modelos tradicionais de IA e a arquitetura por trás dos LLMs modernos. Eu respondo, ela avalia minha resposta e depois passa para a fase de treinamento, então para RLHF e, em seguida, para engenharia de prompt. Então, esta é uma sessão de estudo completa rodando no meu laptop, sem chave de API nem login. De volta à bandeja, o painel de modelos mostra o que há no meu cache: Gemma 3 4B, Gemma 4 E 4B e um pequeno modelo de agent de programação de 2B. Você pode carregar e descarregar cada um deles

03:47 por ali. Também há um atalho. O aviso diz para pressionar Alt e Espaço em qualquer lugar do Windows para abrir uma sobreposição de chat, assim você pode perguntar algo ao seu modelo local sem trocar de janela. E o commit mais recente no repo adiciona links diretos do llama.cpp, então um link pode abrir um chat com um prompt ou carregar um modelo. Agora, esta é a parte para desenvolvedores. O aplicativo executa um servidor llama.cpp na porta 9931 e oferece compatibilidade com a API da OpenAI. Então, no terminal, executo curl localhost:9931/models.

04:21 Você pode ver os três IDs de modelo, cada um com o status carregado ou descarregado, e o tamanho da context window é de 131.000 tokens. Para a Gemma 4, também aparecem texto, imagem, áudio e vídeo como entradas. Agora, em Python, uso o cliente normal da OpenAI. Só mudo a URL base, e a chave pode ser qualquer coisa. Na minha primeira tentativa, o texto veio vazio porque defini o máximo de tokens como 200 e a Gemma 4 usou todos eles para raciocinar. Quando aumentei para 1.500, ela usou 450 tokens e cerca de

04:51 1.500 caracteres disso foram de raciocínio, antes do haicai de três linhas. Então, se você fizer chamadas a ela pelo código, deixe espaço suficiente. E não é só uma ideia minha. A página inicial do aplicativo llama.cpp diz isso diretamente. Aponte qualquer aplicativo que funcione com a OpenAI para localhost:9931/v1; ela lista agents de programação, editores e aplicativos de chat. Também há uma linha de comando. Se eu digitar llama help, ela lista serve, CLI, update, download, version e licenses. E llama CLI cache list mostra os mesmos três modelos baixados pelo aplicativo da bandeja, então o

05:26 aplicativo e a linha de comando realmente compartilham um único cache. A documentação também mostra o llama CLI com -hf e o nome de um modelo para conversar no terminal, e llama serve para iniciar o mesmo servidor sem o aplicativo. Agora, vou testar coisas que não dá para fazer numa janela de chat simples. Estes são quatro testes que executei, um após o outro, no mesmo servidor local. Primeiro, visão: envio uma captura de tela da minha própria gravação e pergunto o que aparece na tela. Ele responde em duas frases: uma mensagem de confirmação de assinatura e uma barra lateral com a lista de

05:58 modelos. Isso levou cerca de 11 segundos, com 434 tokens só para a imagem. Segundo, tool calling. Defino uma função, get disk free, que recebe uma letra de unidade, e pergunto quanto espaço livre há na minha unidade D. O modelo não chuta: retorna uma chamada de ferramenta com o nome da função e o argumento D em cerca de 5 segundos e meio. Seu código executa a função e envia o resultado de volta. E é assim que um agent local funciona. Terceiro, saída estruturada. Dou a ele um schema JSON com quatro campos e uma frase sobre esta versão. Ele retorna

06:31 name llama windows version v0.12.0 date 10 October 2026 license MIT como JSON válido em menos de 6 segundos. Quarto, código. Peço um script Python que imprima os primeiros 15 números de Fibonacci. Pego o bloco de código que ele fornece, salvo num arquivo e o executo. E dá para ver que ele imprime 011235 até 377, em cerca de 4 segundos. Então, temos chat, visão, ferramentas, saída estruturada e código, tudo em um único

07:02 aplicativo na bandeja, e nada saiu da máquina. Certo, agora o número que prometi: usei os campos de tempo do próprio servidor, na mesma máquina e com os mesmos prompts. A Gemma 4 E 4B gera cerca de 58 tokens por segundo. Medi 59, 56 e 58 em três prompts. A Gemma 3 4B, a versão quantizada, é um pouco mais rápida, entre 61 e 69 tokens por segundo. A surpresa foi a parte do prompt. Quando envio um prompt de cerca de 4.000 tokens, a Gemma 4 o processa a cerca de 2.800

07:33 tokens por segundo, e a Gemma 3, a cerca de 3.100. Então, a leitura é aproximadamente 50 vezes mais rápida do que a escrita. A documentação tem uma página exatamente sobre isso: prefill versus decode. O prefill é limitado pela capacidade de processamento. Ele processa todo o prompt em paralelo. O decode é limitado pela largura de banda da memória, um token de cada vez. Por isso, um documento longo entra rápido, mas a resposta sai na velocidade de leitura. Além disso, vale lembrar que a primeira chamada a um modelo que não estava carregado levou cerca de 34 segundos, porque o servidor precisou carregá-lo. Depois disso, é rápido. Mais uma comparação, a mesma pergunta para

08:06 os dois modelos. Explique em duas frases o que é um arquivo GGUF. A Gemma 3 respondeu em 62 tokens. A Gemma 4 usou 292 porque raciocina primeiro e, ainda assim, rodou a cerca de 62 tokens por segundo. Então, a velocidade é parecida, mas o modelo de raciocínio usa mais tokens por resposta. Então, para quem é isso e o que você deveria… sabe, minha GPU tem 8 GB, e a Nvidia me deixa com cerca de 7 GB usados e quase 8 GB no pico, com dois modelos carregados. Então, um modelo muito maior não vai caber. O aplicativo está na versão 0.12, então é novo.

08:41 O raciocínio no Gemma 4 usa tokens, então defina limites mais altos. Testei em uma máquina, com uma GPU, então seus números serão diferentes. Se você tem um PC com Windows 11 e quer usar IA local sem terminal, esta é a maneira mais fácil que encontrei para começar. Quanto ao tamanho, a página do llama.cpp mostra modelos de exemplo para PC: um 27B com 19GB, um 20B com 12.1 e o Gemma 4E 4B com 4.59. Em uma placa de 8GB, só o último cabe por completo na GPU. Então, essa é a categoria de

09:13 modelo com que eu começaria. Se você está procurando GPUs baratas e confiáveis, eu uso o RunPod, e o link está na descrição. Neste vídeo, vimos como instalar o llama.cpp, escolher e baixar um modelo, conversar com ele e chamá-lo usando curl e Python na nossa própria máquina. Experimente no seu sistema e me diga qual modelo você usou. No próximo vídeo, vou testar até onde essa placa de 8GB realmente consegue ir. Então, confira o próximo vídeo.

Transcrição original

[00:00] This is Gemma 4 answering on my Windows laptop at about 58 tokens a second and the whole thing is controlled from one icon in the system tray. No Linux, no WSL, no Mac. Now, mind you that this is the AGB RTX 406 laptop that I have here. Everything is running on my local system. In this video, I’ll install it from scratch, run it three different ways, and show you the real speed numbers, including the one that surprised me. Let’s go ahead and test this out. So, if you’ve tried running models

[00:31] locally, you know the story. The nice tools showed up on Mac first, and on Windows, you ended up in a terminal building llama.cpp or setting up WSL. Now, we have a native Windows app, and it’s on the Hugging Face blog right here. You can see that it’s a WinUI 3 app that sits in the notification area. You pick a model from the Hugging Face hub, and it downloads in one click. The page says, “No terminal, no build step, and no admin rights.” And hold on to this because later I’ll show you the same server answering plain curl and

[01:02] Python calls. Let’s look at the actual repo. It’s gmml-orgs/llama.cpp, and you can see it’s MIT license with about 142 stars and 18 forks as I’m recording this. The latest release is V0.12 from the 10th of October. So, this is a very new project, and I’ll say that plainly it’s early, so expect rough edges. On the llama.app site, there are docs for installation, quick start, the command line, the server, the web UI, and the API server. We’ll use pretty

[01:33] much all of those in this video. Okay, so let’s install it. I go to llama.app, click download, and Windows opens an installer. Here’s the dialogue, and it says llama is ready, publisher Hugging Face. So, I’ll click launch. Now, this app has no window of its own. It lives in the system tray next to the clock, and if you don’t see it, click the little arrow to show hidden icons. That’s honestly the whole install. There’s no Python and no CUDA toolkit to set up by hand. And if llama.cpp isn’t on the machine, the app installs it for

[02:04] you. The docs list other ways to install, too. A one-line install script for other platforms, pre-built binaries, Docker, and building from source. But on Windows, the desktop app is the recommended route. Now, click the llama icon and you get this flyout. On the top, there’s a recommended models list, and you can see Gemma 3, Gemma 4, and a few others. Each one with the size on disk and whether it has vision. That matters because you can check if it fits your GPU before you download anything. I pick Gemma 4 and click download, and you can see the live progress right here.

[02:37] The models land in the normal Hugging Face cache under your user folder .cache huggingface hub. So, llama.cpp and other Hugging Face tools share the same copy. You download once. All right, the model is loaded, so let’s open the web UI. This is the llama.cpp chat interface running on this machine. First, I’ll ask which model are you, and you can see that before the answer, there’s a reasoning block. Gemma 4 thinks first, and the web UI shows you that thinking, which is useful for checking why it answered the way it did. Now, let’s try something more real. I type, “Can you interview me on

[03:12] knowledge of LLMs?” and it asks me a first question about the core difference between traditional AI models and the architecture behind modern LLMs. I answer it, and it grades my answer, and then moves to the training phase, then RLHF, and then prompt engineering. So, this is a full study session running on my laptop with no API key and no login. Back in the tray, the models panel shows what’s in my cache, Gemma 3 4B, Gemma 4 E 4B, and a small 2B coding agent model. You can load and unload each one from

[03:47] there. There’s also a shortcut. The block says to press Alt and Space from anywhere in Windows to open a chat overlay, so you can ask your local model something without switching windows. And the latest commit in the repo adds llama.cpp deep links, so a link can open a chat with a prompt or load a model. Now, here’s the part for developers. The app runs a llama.cpp server on port 9931 and it speaks the OpenAI API. So, in a terminal, I run curl localhost:9931/models.

[04:21] You can see the three model IDs, each with status loaded or unloaded, and the context length is 131,000 tokens. For Gemma 4, it also lists text, image, audio, and video as inputs. Now, in Python, I use the normal OpenAI client. I just changed the base URL and the key can be anything. My first try returned empty text because I set max tokens to 200 and Gemma 4 spent all of them on reasoning. When I raised it to 1,500, it used 450 tokens and about

[04:51] 1,500 characters of that was reasoning before the three-line haiku. So, if you call it from code, give it room. And this isn’t just my idea. The llama.cpp app homepage says it directly. Point any app that works with OpenAI at localhost:9931/v1 and it lists coding agents, editors, and chat apps. There’s also a command line. If I type llama help, it lists serve, CLI, update, download, version, and licenses. And llama CLI cash list shows the same three models that tray app downloaded, so the

[05:26] app and the command line really share one cash. The docs also show llama CLI with -hf and a model name to chat in the terminal and llama serve to start the same server without the app. Now, let me try things you can’t do in a plain chat window. These are four tests I ran against the same local server one after another. First vision, I send it a screenshot from my own recording and ask what’s on the screen. It answers in two sentences, a subscription confirmation message and a sidebar listing the

[05:58] models. That took about 11 seconds with 434 tokens just for the image. Second, tool calling. I define one function, get disk free, that takes a drive letter and ask how much free space is on my D drive. The model doesn’t guess, it returns a tool call with the function name and the argument D in about 5 and 1/2 seconds. Your code runs the function and sends the result back. And that’s how a local agent works. Third, structured output. I give it a JSON schema with four fields and a sentence about this release. It returns

[06:31] name llama windows version v0.12.0 date 10 October 2026 license MIT valid JSON in under 6 seconds. Fourth, code. I ask for Python script that prints the first 15 Fibonacci numbers. I take the code block it gives, save it to a file, and run it. And you can see it prints 011235 all the way to 377, about 4 seconds. So, that’s chat, vision, tools, structured output, and code from one

[07:02] tray app, and nothing left the machine. Okay, so the number I promised, I used the server’s own timing fields, same machine, same prompts. Gemma 4E4B generates about 58 tokens a second. I measured 59, 56, and 58 across three prompts. Gemma 3 4B, the quantized one is a bit faster, between 61 and 69 tokens a second. The surprise was the prompt side. When I send a prompt of about 4,000 tokens, Gemma 4 processed it at around 2,800

[07:33] tokens a second, and Gemma 3 at around 3,100. So, reading is roughly 50 times faster than writing. The docs have a page on exactly this, prefill versus decode. Prefill is compute bound. It handles the whole prompt in parallel. Decode is memory bandwidth bound, one token at a time. That’s why long document goes in fast, but the answer comes out at reading speed. Also, mind you, the first call to a model that wasn’t loaded took about 34 seconds because the server had to load it. After that, it’s quick. One more comparison, same question to

[08:06] both models. Explain what a GGF file is in two sentences. Gemma 3 answered in 62 tokens. Gemma 4 spent 292 because it reasons first and still ran at about 62 tokens a second. So, the speed is similar, but the reasoning model uses more tokens per answer. So, who is this for and what should, you know, my GPU is 8GB and Nvidia has me short about 7GB used and almost 8 at the peak with two models resident. So, a much bigger model won’t fit. The app is on release 0.12, so it’s new.

[08:41] The reasoning in Gemma 4 uses tokens, so set your limits higher and I tested one machine, one GPU, so your numbers will differ. If you have a Windows 11 PC and want local AI without a terminal, this is the easiest way I’ve seen to start. And about size, the llama.cpp page shows example models on a PC, a 27B at 19GB, a 20B at 12.1, and Gemma 4E 4B at 4.59. On an 8GB card, only the last one fits fully on a GPU. So, that’s the class of

[09:13] model I’d start with. If you’re looking for cheap and reliable GPUs, I use RunPod and the link is in the description. So, in this video, we have seen how to install llama.cpp pick and download a model, chat with it, and call it from curl and Python on our own machine. Go ahead and try it on your own system and let me know which model you ran. Next, I’ll test how far that 8GB card can really go. So, check out the next video.