
Tutorial passo-a-passo para configurar e usar modelos de linguagem no teu próprio computador.
Imagina ter o teu próprio ChatGPT - completamente gratuito, sem internet, e com a garantia de que ninguém vê o que lhe perguntas. Parece ficção científica? Em 2026, é realidade. Com ferramentas como Ollama e LM Studio, podes correr modelos de IA poderosos no teu próprio computador. Neste guia, vamos configurar tudo do zero - mesmo que nunca tenhas feito nada parecido.
Um LLM (Large Language Model) é, essencialmente, como um amigo muito culto que leu milhões de livros, artigos e websites. Quando lhe fazes uma pergunta, ele não "pensa" como um humano - em vez disso, prevê qual é a resposta mais provável com base em tudo o que já "leu". É por isso que às vezes acerta brilhantemente e outras vezes diz disparates com ar convicto (chamamos a isto "alucinações").
O ChatGPT, o Claude, o Gemini - todos são LLMs. A diferença é que estes funcionam nos servidores das empresas que os criaram (na "nuvem"). Quando usas o ChatGPT, a tua pergunta viaja pela internet até aos computadores da OpenAI, é processada lá e a resposta volta para ti. Correr um LLM localmente significa que tudo acontece dentro do teu computador - a pergunta nunca sai da tua máquina.
É a diferença entre alugar um apartamento e ter casa própria. No apartamento alugado (serviços na nuvem como o ChatGPT), pagas renda todos os meses, o senhorio pode mudar as regras e alguém pode ver quem entra e sai. Na casa própria (LLM local), pagas uma vez (o download do modelo) e tens liberdade total.
Privacidade total: Os teus dados nunca saem do computador. Isto é crucial para empresas com dados sensíveis (imagina um advogado que quer usar IA para analisar contratos confidenciais), código proprietário ou informação regulada pelo RGPD. Com um LLM local, ninguém vê as tuas perguntas - nem a empresa que criou o modelo.
Custo zero após instalação: Sem subscrições mensais de 20€, sem limites de mensagens, sem custos por token. Depois do download inicial do modelo (grátis), podes usá-lo milhares de vezes por dia sem gastar um cêntimo. Para estudantes ou pequenas empresas, isto é uma enorme vantagem.
Funciona sem internet: Num avião, no campo, ou numa rede empresarial restrita. O modelo funciona offline, o que significa zero latência de rede e independência total de serviços cloud.
Personalização total: Podes criar um assistente com a "personalidade" que quiseres: que fale só português, que se especializa no teu domínio, que responda num formato específico. É como ter um empregado que podes treinar exatamente para as tuas necessidades.
Que computador precisas? Não precisas de um supercomputador, mas ajuda ter uma boa máquina. Para modelos "pequenos" (7 mil milhões de parâmetros, como o Llama 3 ou Mistral): 8GB de RAM mínimo, 16GB ideal. Para modelos médios (13B): 16GB RAM mínimo. Para os modelos maiores (70B): 32GB+ RAM ou uma placa gráfica NVIDIA com 24GB de memória. Se tens um MacBook com chip M1/M2/M3, estás numa posição privilegiada - estes chips são excelentes para LLMs.
Se os LLMs são filmes, o Ollama é o teu Netflix local. Uma aplicação que te permite "descarregar" modelos de IA (como quem descarrega filmes) e usá-los sempre que quiseres, sem internet. A interface é por linha de comandos (o terminal), o que pode parecer intimidante, mas é surpreendentemente simples - essencialmente são 3 comandos.
O Ollama é a ferramenta mais popular para correr LLMs localmente em 2026. Suporta dezenas de modelos, tem uma API REST compatível com a OpenAI (o que significa que qualquer programa feito para o ChatGPT funciona com Ollama quase sem alterações), e a instalação demora menos de 2 minutos.
# Instalação
# macOS e Linux (uma linha):
curl -fsSL https://ollama.com/install.sh | sh
# Windows: descarregar de https://ollama.com/download
# Verificar instalação
ollama --version
# Descarregar modelos populares
ollama pull llama3.1 # Meta Llama 3.1 8B (4.7 GB)
ollama pull mistral # Mistral 7B (4.1 GB)
ollama pull codellama # Code Llama 7B (3.8 GB)
ollama pull phi3 # Microsoft Phi-3 (2.3 GB)
ollama pull gemma2 # Google Gemma 2 9B (5.4 GB)
# Ver modelos instalados
ollama list
# Correr um modelo (chat interativo)
ollama run llama3.1
# Correr com prompt direto
ollama run llama3.1 "Explica o que é recursão em Python"
# Correr modelo de código
ollama run codellama "Escreve uma função Python para quicksort"Pensa na API REST como uma janela de atendimento. O Ollama cria automaticamente uma "janela" no porto 11434 do teu computador, onde qualquer programa pode "chegar ao balcão", fazer uma pergunta e receber a resposta. Isto significa que podes ligar o teu LLM local a websites, aplicações, scripts Python, ou qualquer outro software - não ficas limitado ao chat no terminal.
# Gerar texto com a API REST (compatível com curl)
# Chat completion
curl http://localhost:11434/api/chat -d '{
"model": "llama3.1",
"messages": [
{"role": "system", "content": "És um assistente que responde em português."},
{"role": "user", "content": "O que é machine learning?"}
],
"stream": false
}'
# Gerar embeddings
curl http://localhost:11434/api/embeddings -d '{
"model": "llama3.1",
"prompt": "Texto para gerar embedding"
}'
# Listar modelos disponíveis
curl http://localhost:11434/api/tagsSe a API REST é a janela de atendimento, a biblioteca Python do Ollama é como ter um número de telefone direto - ligas diretamente do teu programa Python para o modelo, sem intermediários. É a forma mais fácil de integrar o LLM local num projeto de software. Mesmo que sejas iniciante em Python, o código abaixo é surpreendentemente simples.
# pip install ollama
import ollama
# Chat simples
response = ollama.chat(
model='llama3.1',
messages=[
{'role': 'system', 'content': 'Responde sempre em português de Portugal.'},
{'role': 'user', 'content': 'Explica o padrão MVC em 3 frases.'}
]
)
print(response['message']['content'])
# Chat com streaming (resposta em tempo real)
stream = ollama.chat(
model='llama3.1',
messages=[{'role': 'user', 'content': 'Escreve um poema sobre Python.'}],
stream=True,
)
for chunk in stream:
print(chunk['message']['content'], end='', flush=True)
# Gerar embeddings
embedding = ollama.embeddings(
model='llama3.1',
prompt='Texto para converter em vetor numérico'
)
print(f"\nDimensão do embedding: {len(embedding['embedding'])}")
# Listar modelos
models = ollama.list()
for m in models['models']:
size_gb = m['size'] / (1024**3)
print(f" {m['name']}: {size_gb:.1f} GB")Um Modelfile é como uma ficha de personagem num jogo de RPG. Defines quem o modelo "é": como se chama, como se comporta, qual é o seu domínio de conhecimento e como responde. É assim que podes criar, por exemplo, um assistente especializado na tua empresa que só responde em português e foca-se nos teus produtos.
# Ficheiro: Modelfile-assistente-pt
FROM llama3.1
PARAMETER temperature 0.7
PARAMETER num_ctx 4096
PARAMETER top_p 0.9
SYSTEM """
És o assistente virtual da Vibe Coding Academy, uma escola de IA em Portugal.
Regras:
- Responde SEMPRE em português de Portugal (PT-PT)
- Sê amigável e profissional
- Foca-te em temas de IA, programação e tecnologia
- Quando não souberes, admite e sugere fontes
- Usa exemplos práticos sempre que possível
"""
# Criar o modelo customizado:
# ollama create assistente-vibe -f Modelfile-assistente-pt
# Usar:
# ollama run assistente-vibe "Que linguagem devo aprender para ML?"Se o Ollama é como conduzir com caixa manual (mais controlo, mas precisas de saber usar o terminal), o LM Studio é a caixa automática - uma interface gráfica bonita onde fazes tudo com cliques do rato. Descarregas modelos com um botão, conversas numa janela de chat e ajustas parâmetros com sliders visuais.
O LM Studio é ideal para quem está a começar ou prefere uma experiência visual. Mas tem um trunfo escondido: também cria um servidor API local compatível com a API da OpenAI. Isto significa que qualquer programa feito para funcionar com o ChatGPT funciona automaticamente com o LM Studio - basta mudar o endereço do servidor. É como ter um adaptador universal: liga qualquer coisa.
# LM Studio expõe uma API compatível com OpenAI em localhost:1234
# Podes usar a biblioteca openai standard!
# pip install openai
from openai import OpenAI
# Apontar para o servidor local do LM Studio
client = OpenAI(
base_url="http://localhost:1234/v1",
api_key="lm-studio" # qualquer string serve
)
# Usar exatamente como a API da OpenAI
response = client.chat.completions.create(
model="local-model", # nome do modelo carregado no LM Studio
messages=[
{"role": "system", "content": "És um programador Python experiente."},
{"role": "user", "content": "Escreve uma classe para gerir uma fila de tarefas com prioridades."}
],
temperature=0.7,
max_tokens=1000
)
print(response.choices[0].message.content)
# Isto significa que qualquer código que use a API OpenAI
# funciona localmente sem alterações (só muda o base_url)!"The most interesting thing about running LLMs locally is not the cost savings — it is the ability to iterate and experiment without any constraints."
Agora vem a parte mais divertida: vamos construir o teu próprio chatbot! É como montar um robô LEGO - vamos juntar peças simples (modelo de IA + histórico de conversa + interface no terminal) para criar algo funcional e impressionante. Este chatbot corre 100% no teu computador, mantém memória das últimas mensagens (para não repetires contexto) e funciona totalmente offline. Se alguém te perguntar "o que andas a aprender?", podes mostrar isto e impressionar.
import ollama
class ChatbotLocal:
def __init__(self, model: str = "llama3.1"):
self.model = model
self.historico = []
self.system_prompt = {
'role': 'system',
'content': """És um assistente de programação prestável.
Responde em português de Portugal. Quando dás exemplos de código,
usa comentários em português. Sê conciso mas completo."""
}
def perguntar(self, mensagem: str) -> str:
self.historico.append({'role': 'user', 'content': mensagem})
response = ollama.chat(
model=self.model,
messages=[self.system_prompt] + self.historico[-10:] # últimas 10
)
resposta = response['message']['content']
self.historico.append({'role': 'assistant', 'content': resposta})
return resposta
def limpar(self):
self.historico = []
print("Histórico limpo.")
# Utilização
bot = ChatbotLocal()
print("=== Chatbot Local (escreve 'sair' para terminar) ===\n")
while True:
pergunta = input("Tu: ")
if pergunta.lower() in ('sair', 'exit', 'quit'):
break
if pergunta.lower() == 'limpar':
bot.limpar()
continue
resposta = bot.perguntar(pergunta)
print(f"\nAssistente: {resposta}\n")Recomendação por caso de uso: Para chat geral, usa llama3.1. Para código, usa codellama ou deepseek-coder. Para tarefas rápidas em hardware limitado, usa phi3 (2.3 GB). Para qualidade máxima com GPU potente, usa llama3.1:70b.
Queres ir mais fundo? O nosso curso de Fundamentos de IA cobre LLMs locais, APIs e muito mais. Se já tens experiência, o curso de Desenvolvimento Avançado com Claude Code ensina-te a integrar LLMs em workflows profissionais.
Engenheiro de segurança e entusiasta de IA open source.
Seguir no LinkedInExplora o nosso curso relacionado e leva as tuas competências ao próximo nível.
Ver CursosRecebe artigos como este diretamente no teu email. Sem spam.

Um guia completo para iniciantes que querem começar a aprender Machine Learning. Descobre os conceitos fundamentais e os melhores recursos.

Aprende técnicas avançadas como Chain-of-Thought, Few-Shot Learning e Tree of Thoughts para maximizar os resultados com LLMs.

Uma comparação detalhada entre as duas ferramentas de programação assistida por IA mais populares do momento.