Aprendendo, desaprendendo e reaprendendo

Há algum tempo decidi fazer um experimento que, para quem trabalha ou acompanha a área de tecnologia, parecia quase inevitável: montar minha própria infraestrutura local de Inteligência Artificial.

Assisti a dezenas de vídeos no Youtube e li diversas publicações.

A ideia inicial era sedutora. Ter um servidor local de IA, com modelos rodando na minha própria máquina, com bases de conhecimento sob meu controle, privacidade dos meus arquivos, autonomia relativa e até se quisesse, fazer integração com ferramentas externas.

Parecia  uma experiência interessante... Algo parecido com o “serviço” das grandes plataformas comerciais, mas construído por mim.

Comecei achando que estava “apenas” instalando algumas ferramentas. No fim, percebi que estava atravessando um processo muito mais profundo: aprender, desaprender e reaprender, a própria razão e essência desta coluna que escrevo há anos.

E talvez essa tenha sido a parte mais valiosa da experiência.

Meu ponto de partida foi um Mini PC, Beelink SER 5, com processador AMD Ryzen 7 5800H, 32 Gb de RAM, SSD e HD de 1 Tb. Pensei que para um laboratório pessoal, seria uma máquina bastante razoável.

A ideia inicial era instalar algumas ferramentas, conectar os modelos de LLM (Large Language Model) como os influencers do Youtube propagavam, testar as bases de conhecimento e construir um ambiente que me permitisse fazer as próprias pesquisas, escrever, comparar as respostas e experimentar a IA generativa sem depender o tempo todo das plataformas comerciais.

Comecei pelo caminho mais natural para quem gosta de tecnologia: instalei, testei, desinstalei, reinstalei, li muita documentação, analisei os logs e tentei entender por que aquilo que parecia simples nos tutoriais ficava mais trabalhoso na prática.

O caminho não foi fácil. Cada vídeo do Youtube ensinava para ir em uma direção. Instalei Docker, Open WebUI, Ollama, LM Studio e AnythingLLM.

Em paralelo, mantive meu uso cotidiano do ChatGPT Go e também continuei usando as versões gratuitas do Claude, Qwen, Kimi, além de consultas ocasionais ao NotebookLM, Gemini e Copilot.

Mas o que eu queria mesmo era ter o meu “próprio GPT”, uma versão tupiniquim do ChatGPT.

Parecia um bom projeto técnico. E era. Aos poucos fui percebendo que ele me ensinaria coisas que iam além da instalação das ferramentas.

A primeira fase foi de descoberta.

Vi na prática que o Ollama permite rodar os modelos localmente. O diferencial estava em usar o Open WebUI com uma interface web agradável para “conversar” com esses modelos.

Depois veio o Docker, para empacotar os serviços. Já o LM Studio facilitava realizar os testes e o AnythingLLM era a alternativa para trabalhar com documentos e provedores externos.

Comecei a consultar diversas IAs para me ajudar a encontrar a estrutura ideal para organizar o ambiente:

A sugestão do ChatGPT foi:

Platforma-IA/

|-- Docker/

|-- Ollama/

       |-- modelos/

|-- Conhecimento/

|-- Prompts/

|-- Logs/

|-- Config/

|-- Scripts/

|-- Volumes/

|-- docker-compose.yml

|-- .env

A intenção era manter tudo em um lugar: modelos, volumes, configurações, prompts, bases de conhecimento, logs e scripts. Um ambiente próprio, documentado, repetível.

Essa organização me pareceu adequada. Quem trabalha na área de TI sabe o prazer de ver uma estrutura bem definida, com diretórios separados, nomes claros e a sensação de que cada peça tem seu lugar.

Mas a realidade apareceu rápido. O primeiro modelo de LLM a ser testado foi o Qwen3:8b, considerado “adequado ao hardware” porque iria consumir entre 4.9 GB a 5.2 Gb de memória RAM e os 32 Gb de RAM do mini PC permitiriam rodar o modelo com folga, mantendo o sistema operacional e outros serviços de servidor ativos simultaneamente. A promessa era: esse modelo iria realizar todo o processamento de dados inteiramente dentro do Mini PC, e seria “ideal” para analisar documentos pessoais ou códigos privados sem enviar dados para APIs externas (como OpenAI ou Google).

Mas a realidade foi outra: o modelo Qwen3:8b demorava entre 40 e 70 segundos para responder uma simples consulta. A CPU trabalhava intensamente. A GPU integrada quase não participava. Em alguns testes, o mini PC travava ou reiniciava.

O ChatGPT sugeriu investigar o hardware. Propôs atualizar a BIOS e aumentar a memória UMA do setup para a iGPU. Depois, testei outros modelos diferentes, monitorando a CPU, o consumo de memória RAM e uso da GPU.

Cada ajuste que eu fazia trazia algum aprendizado, mas a experiência continuava longe do que eu esperava para o uso frequente.

A máquina rodava os modelos, mas a produtividade esperada ficava comprometida.

Essa foi uma das primeiras lições do projeto: conseguir executar um modelo localmente representa apenas uma parte da experiência.

Existe uma diferença grande entre abrir um modelo, enviar uma pergunta e obter uma resposta aceitável em tempo razoável. Para estudar, tudo bem esperar um pouco. Para escrever, revisar, pesquisar e aprofundar ideias, a demora muda completamente a relação com a ferramenta.

Estamos mal-acostumados com uso e o ritmo da IA generativa. Fazemos uma pergunta, avaliamos a resposta, ajustamos o prompt, pedimos nova versão, comparamos alternativas. Quando cada interação leva um minuto ou mais, o pensamento esfria e vem o desânimo e a impaciência.

O que aprendi...

No meu caso, o mini PC se tornou uma ótima máquina de aprendizado, mas um ambiente limitado para uso produtivo com modelos locais. Ele me obrigou a olhar para consumo de memória, capacidade de GPU, quantização, tamanho dos modelos e comportamento do sistema sob carga.

Também me mostrou algo incômodo: boa parte do tempo que eu esperava economizar com o uso da IA local estava sendo consumida pelas próprias configurações da plataforma.

Então busquei uma alternativa com o Open WebUI com a promessa da interface única.

O Open WebUI ocupou um papel central nos testes.

A proposta era muito atraente: uma interface única para conversar com modelos locais via Ollama, usar APIs externas, conectar bases de conhecimento, ativar pesquisa Web e, no futuro, trabalhar com recursos mais avançados.

Durante um bom tempo, concentrei meus esforços nele.

Novamente, configurei o Docker, conectei o Ollama, testei OpenRouter, examinei o banco SQLite, revisei os parâmetros da interface e acompanhei os logs.

A cada recurso habilitado, surgia uma nova camada para entender.

O Open WebUI, como ferramenta, tem seus méritos. Ela aproxima o uso de modelos locais da experiência que temos com as plataformas comerciais, como ChatGPT, Claude ou Gemini. Também oferece muitos recursos em uma única aplicação.

Só que a combinação entre hardware limitado, mudanças frequentes de versão e os recursos avançados tornou a experiência mais trabalhosa do que eu previa.

Em vez de usar a IA para pesquisar, produzir textos, eu passava horas tentando fazer a plataforma funcionar do jeito esperado.

O cenário familiar de quem trabalha com TI se confirmava: estava diante de um ambiente promissor, começando pequeno, agregando novos componentes, ganhando integrações e logo passou a exigir cuidado permanente...

A curiosidade técnica era prazerosa, mas parecia que havia uma fronteira distante entre o meu laboratório e a ferramenta de trabalho desejada.

Adquiri as chaves de API da Anthropic e da OpenRouter (20 dólares de crédito em cada uma) para comparar modelos locais com os modelos externos e testei o AnythingLLM.

Opa! A diferença começou a aparecer! A experiência foi surpreendentemente boa. O acesso aos modelos avançados funcionou de forma simples. As respostas vieram com bom desempenho. A configuração pareceu mais direta. Em pouco tempo, eu estava usando a ferramenta, sem gastar horas examinando logs.

Essa experiência mudou minha percepção do projeto. Eu tinha passado muito tempo tentando construir uma plataforma própria, partindo do zero e, de repente, uma solução mais objetiva entregava resultado prático com menos desgaste.

Foi uma lição difícil e necessária porque, como profissionais de TI, reconhecemos que nem sempre a solução tecnicamente mais interessante será a melhor escolha para o uso diário.

Mas essa solução não resolvia o problema da privacidade desejada. Era preciso voltar para o servidor local com as limitações do hardware e tentar acertar nas configurações das ferramentas para atingir os objetivos do projeto: realizar as tarefas assíncronas, usar como assistente pessoal, e conduzir automações leves e aprofundar os estudos.

De volta ao Qwen3:8b percebi que ele estava estressando o processador a 100% de uso constantemente e isso gerou um aumento rápido de temperatura, fazendo com que as ventoinhas do mini PC operassem na rotação máxima (gerando ruído).

Outro aprendizado que veio do Qwen3: durante os testes, percebi que algumas respostas demoravam demais mesmo quando a pergunta era simples. Investigando, descobri que o modelo tinha capacidades como completion, tools e thinking. Isto é, o modo de raciocínio era ativado automaticamente em certas situações. Isso consumia tempo e memória, muitas vezes sem necessidade para a tarefa em questão.

Então encontrei o comando: /set nothink.

Com ele, reduzi bastante o tempo de resposta em vários testes. Foi uma descoberta pequena, mas reveladora, porque a alteração de um parâmetro muda a experiência inteira.

Um comportamento padrão do modelo altera o desempenho, o consumo de memória e a fluidez da conversa. Esse tipo de detalhe dificilmente aparece nas demonstrações rápidas. Ele surge quando usamos a ferramenta com insistência, em tarefas reais, medindo o que acontece e comparando respostas.

A fase dos documentos: o RAG entra em cena

Depois dos primeiros testes com os modelos, por sugestão do ChatGPT, avancei na proposta do projeto, para implementar um RAG, sigla para Retrieval-Augmented Generation.

A ideia era simples de explicar: carregar documentos próprios e fazer perguntas sobre eles. Eu queria algo próximo da experiência do NotebookLM, com respostas apoiadas em materiais meus, documentos e arquivos pdfs organizados por bases de conhecimento, tudo dentro do Open WebUI.

Na prática, a primeira experiência foi frustrante.

A interface e o modelo de LLM escolhidos ignoravam os documentos que estavam sendo carregados. Nos testes, eu perguntava algo presente em um PDF, e a resposta vinha baseada no conhecimento geral do modelo. Parecia que a base nem existia.

Comecei outras rodadas de investigação com o auxílio do ChatGPT: analisei embeddings, ChromaDB, collections, tamanho dos chunks, overlap, Query Prompt, Hybrid Search e indexação. Também precisei entender melhor a relação entre uma Collection e o chat em uso.

Algumas descobertas vieram aos poucos.

A Collection precisava estar realmente anexada ao chat. Em certas situações, era necessário invocá-la com #. Os documentos em markdown apresentavam resultados muito melhores do que PDFs. A qualidade da extração do texto influenciava diretamente a recuperação das informações.

Essa parte do projeto foi muito rica.

Há muita informação dizendo que RAG “funciona como algo quase automático”: adicione arquivos, pergunte, receba respostas.

Não é bem assim. Encontrei um cenário bem mais artesanal: o formato do documento importa, a limpeza do conteúdo importa, a divisão do arquivo em blocos importa, o modelo de embeddings importa e também a instrução enviada ao modelo também importa.

Logo, quando qualquer uma dessas peças não está bem configurada, o resultado é estranho: o documento está lá, mas a IA se comporta como se nunca tivesse visto o material.

Desisti, temporariamente, do RAG... Meu projeto estava se tornando um scope creep, crescimento desorganizado do escopo...

Voltei a insistir no acerto da configuração do Open WebUI. Queria testar o modelo local fazendo a pesquisa na Web para complementar as respostas com informações atualizadas e em tempo real, para quando isso fosse necessário.

Desinstalei tudo e fiz novas instalações: Ollama, modelos, Docker, LM Studio...

No Open WebUI configurei a Tavily, com uma chave API válida. A pesquisa Web estava habilitada. O botão da interface estava ligado. Verifiquei o banco SQLite, confirmei que as configurações estavam gravadas, revisei Docker, Ollama, OpenRouter e rede.

No navegador, o payload mostrava: features.web_search=true.  Ou seja, a interface enviava a informação corretamente, mas nos logs, o backend recebia:

POST /api/chat/completions e não aparecia nenhuma chamada para Tavily, search, fetch_url ou retrieval. A pesquisa simplesmente não começava.

O modelo respondia: “Não tenho acesso à Internet.”

O ChatGPT e Claude sugeriram investigar a arquitetura recente do Open WebUI. Nas versões atuais, especialmente na linha 0.10.x, a pesquisa Web passou a depender muito mais de um fluxo “agentic”. A interface habilita o recurso, mas o agente precisa decidir usar a ferramenta.

Consultei ChatGPT, Claude, Kimi e Qwen para comparar as hipóteses. As respostas apontaram para o mesmo conjunto de possibilidades: ocorreram mudanças profundas na versão 0.10 do Open WebUI, com o uso intenso de chamadas de ferramentas “tool calling” e várias situações envolvendo Web Search no Open WebUI.

O checklist de tentativa e erro foi: eliminar API, configurar Docker, olhar para o banco SQLite, aplicar chave API da Tavily, verificar payload, rede, Ollama e OpenRouter, sobrou uma suspeita forte: o problema estava na camada responsável por transformar a intenção do usuário em uma chamada efetiva à ferramenta de busca.

Essa investigação me ensinou bastante sobre esses sistemas modernos de IA. Habilitar um recurso na interface não garante que ele será chamado. Entre o botão e a execução existe uma cadeia de decisões, permissões, modelos, ferramentas e comportamentos internos.

Parece algo familiar para quem trabalha com tecnologia: o bug visível raramente conta a história inteira...

A mudança para o Mac Mini M4

Depois de muitas tentativas no mini PC, decidi migrar a plataforma.

Adquiri um Mac Mini M4 com sistema operacional macOS Tahoe 26.5.2, 16 Gb de memória unificada, SSD interno de 256 Gb, SSD externo de 512 Gb e HD externo de 2 Tb, com cerca de 1,5 Tb disponíveis.

A diferença apareceu logo.

O Ollama passou a responder com muito mais agilidade. O Docker ficou estável. O Open WebUI funcionou melhor. Os travamentos desapareceram nos testes mais comuns.

A limitação do mini PC tinha cumprido seu papel pedagógico. Aprendi bastante com ela. Mas o Mac Mini M4 se mostrou uma base mais adequada para continuar o Platforma-IA.

Aprender

O primeiro movimento foi aprender.

Aprendi sobre os modelos locais, o uso de APIs externas, ferramentas como Docker, Open WebUI, Ollama, LM Studio, AnythingLLM, embeddings, ChromaDB, Tavily, OpenRouter, Anthropic, Markdown, PDFs, bancos vetoriais e comportamento de modelos.

Também aprendi sobre os limites físicos do hardware. Para o servidor de IA local, memória, CPU, GPU e armazenamento continuam importando. A IA generativa pode parecer abstrata na interface, mas por trás dela existe carga computacional intensa. Um modelo simples, como o Qwen3, de 8 bilhões de parâmetros até roda em uma máquina modesta, mas a experiência pode ficar distante do uso confortável.

O laboratório me aproximou de aspectos que muitas vezes ficam escondidos quando usamos apenas ChatGPT, Claude, Gemini ou NotebookLM. Nessas plataformas, alguém já cuidou da infraestrutura. No ambiente local, cada detalhe aparece.

Desaprender

A segunda etapa exigiu abandonar algumas crenças.

A principal delas era a expectativa de manter tudo local com bom desempenho, baixo esforço e qualidade parecida com a dos melhores modelos comerciais.

Na teoria, essa ideia é atraente. Na prática, ela cobra um preço alto em configuração, manutenção, diagnóstico e atualização. Cada componente acrescenta possibilidades, mas também aumenta o trabalho de sustentação.

Passei a olhar a questão de outra forma.

Os modelos locais fazem sentido para a privacidade, a experimentação, o uso em tarefas simples, a busca por resumos rápidos, a classificação de textos, as consultas sobre documentos menores e testes técnicos.

Os modelos externos continuam muito fortes para raciocínio complexo, escrita refinada, análise longa, revisão crítica e produção profissional.

Esse ajuste de expectativa foi decisivo para o projeto da Platforma-IA.

O projeto deixou de perseguir autonomia total. Passou a buscar uma composição mais realista e equilibrada entre recursos locais e serviços externos.

Reaprender

A terceira etapa ainda está em construção.

Hoje vejo o Mac Mini M4 como núcleo de uma plataforma pessoal híbrida. Ele pode rodar Ollama nativamente, manter containers em Docker, organizar bases de conhecimento, armazenar prompts, registrar logs, testar RAG e preparar automações futuras.

Ao mesmo tempo, com as chaves API da Anthropic e da OpenRouter, modelos de LLM mais recentes e outros serviços entram como provedores especializados, acionados conforme a tarefa.

O Open WebUI continua no ambiente, mas com papel de laboratório técnico, principalmente enquanto a pesquisa Web na versão 0.10.x apresentar comportamento instável.
O AnythingLLM ganhou força como interface prática para uso diário.

O NotebookLM permanece como referência de experiência para estudo de documentos.

Para o RAG, passei a considerar o markdown como formato preferencial. Os arquivos PDFs entram como fonte original, depois são convertidos, limpos e organizados antes da indexação. As bases de conhecimento menores e bem descritas tendem a funcionar melhor do que grandes depósitos de arquivos heterogêneos.

O projeto também prevê o uso do n8n, que vai ficar para uma etapa posterior. Antes de criar automações, preciso consolidar a base com documentos confiáveis, buscas previsíveis, modelos bem escolhidos e processos simples.

O que fica para quem trabalha em TI

Essa experiência reforçou algo para quem acompanha a carreira em tecnologia há décadas: as ferramentas novas mudam, mas a necessidade de entender os fundamentos permanece.

Quem conhece infraestrutura, logs, APIs, containers, bancos de dados, versionamento e integração consegue investigar melhor o comportamento das plataformas de IA. A interface conversa em linguagem natural, mas o sistema continua dependendo de componentes técnicos.

Também ficou claro que a IA local exige curiosidade e tolerância a instabilidade. A documentação muda, as versões novas alteram os comportamentos, os modelos têm capacidades diferentes e os tutoriais envelhecem rápido.

Para os profissionais em transição ou em atualização de carreira, esse campo oferece muitas oportunidades de aprendizado. Há espaço para quem sabe configurar, integrar, avaliar, automatizar, documentar e traduzir possibilidades técnicas em uso real.

A habilidade central talvez seja saber formular boas perguntas sobre o próprio ambiente:

• Qual tarefa precisa ser resolvida?
• Qual parte deve ficar local?
• Que tipo de dado exige privacidade?
• Quando um modelo externo entrega melhor resultado?
• Quanto tempo estou gastando para manter a solução?
• A ferramenta está ajudando meu trabalho ou apenas alimentando meu laboratório?

Essas perguntas me acompanharam durante todo o processo.

O projeto Platforma-IA daqui para frente...

O projeto continua, agora com desenho mais pragmático.

O Mac Mini M4 será a base local. O Ollama ficará instalado nativamente. O Docker continuará para serviços como Open WebUI, AnythingLLM, SearXNG, bases vetoriais e, futuramente, n8n. Os modelos externos serão usados sem culpa quando fizerem sentido.

A próxima meta é produzir com a plataforma, não apenas configurá-la. Quero usá-la para apoiar a criação de artigos, organizar referências, comparar respostas, estudar documentos, preparar aulas, pautas e testar automações simples.

O mini PC continua tendo seu lugar nessa história. Ele foi o ambiente onde os limites apareceram com clareza.

O Mac Mini M4 abriu espaço para uma experiência mais fluida.

O Open WebUI mostrou a complexidade das ferramentas atuais. O AnythingLLM lembrou que uma solução prática pode avançar onde uma configuração sofisticada empaca.

Aprender, desaprender e reaprender virou menos um conceito abstrato e mais um método de sobrevivência técnica.

Aprendi montando.

Desaprendi insistindo.

Reaprendo agora ao transformar o projeto Platforma-IA em uma ferramenta pessoal de trabalho, combinando recursos locais, modelos externos e uma boa dose de paciência investigativa.