É possível rodar uma inteligência artificial no próprio computador e usá-la em outras aplicações, sem contratar uma API paga por mensagem. Neste tutorial, mostro como fiz isso com o LM Studio, o modelo Qwen3-4B e Python, desde a primeira conversa até um chat acessado pelo navegador.
O teste foi realizado em um computador com Windows, 32 GB de memória RAM e uma placa NVIDIA GeForce RTX 3050 com 6 GB de memória de vídeo. Primeiro, conversei com o modelo dentro do LM Studio. Depois, ativei sua API, enviei uma pergunta por Python e conectei uma página local à IA.
Você pode seguir essas mesmas etapas para experimentar uma IA local e entender como integrá-la aos seus projetos.
O que é uma IA local?
Uma IA local executa o modelo no seu próprio dispositivo. No caso deste tutorial, o computador recebe a pergunta, processa o texto e gera a resposta.
O modelo utilizado é um LLM, sigla de Large Language Model, ou modelo de linguagem de grande porte. Esse tipo de modelo consegue realizar tarefas como responder perguntas, explicar conceitos, ajudar na escrita e produzir código.
Depois de baixar o modelo e os componentes necessários, o LM Studio permite conversar com ele sem conexão com a internet. Os downloads e a busca de novos modelos ainda dependem de acesso à rede.
Uma aplicação possível é desenvolver um assistente para apoiar estudos, programação ou atividades de pesquisa. Também é possível integrar o modelo a um sistema próprio, como faremos com Python.
Rodar uma IA local é gratuito?
Neste teste, não foi necessário contratar uma API nem pagar por cada pergunta enviada ao modelo.
Isso não significa que a execução não tenha custos. O processamento utiliza o computador, consome energia elétrica e ocupa espaço de armazenamento e memória.
Também é necessário observar as condições de uso do aplicativo e a licença do modelo escolhido, especialmente em projetos comerciais.
Para experimentar, a vantagem é poder fazer testes com os recursos do próprio computador, sem uma cobrança por quantidade de mensagens ou tokens enviados a um serviço remoto.
O que você precisa para acompanhar o tutorial?
Neste exemplo, utilizei:
| Recurso | Configuração utilizada |
|---|---|
| Sistema operacional | Windows de 64 bits |
| Memória RAM | 32 GB |
| Placa de vídeo | NVIDIA GeForce RTX 3050 Laptop |
| Memória de vídeo | 6 GB |
| Aplicativo | LM Studio |
| Modelo | Qwen3-4B em formato GGUF |
| Quantização | Q4_K_M |
| Linguagem para integração | Python |
Essa tabela apresenta a configuração do teste, não os requisitos mínimos universais. A memória necessária e a velocidade de resposta dependem do modelo, da quantização, do tamanho da conversa e das configurações de execução.
A IA utiliza RAM ou memória de vídeo?
Ela pode utilizar ambas.
O arquivo baixado fica armazenado no SSD ou no disco do computador. Durante a execução, os dados necessários ao processamento são carregados na memória RAM e, quando a configuração permite, na memória da placa de vídeo, chamada VRAM.
A GPU pode acelerar a geração das respostas porque realiza muitas operações em paralelo. A velocidade também depende da capacidade de processamento da placa, da largura de banda da memória e de quanto do modelo consegue ser executado nela.
Ter 32 GB de RAM não equivale a ter 32 GB de VRAM. São recursos diferentes, embora ambos possam participar da execução.
1. Instale o LM Studio
O LM Studio é um aplicativo que permite baixar modelos de linguagem, conversar com eles e disponibilizá-los por uma API local.
Acesse o site oficial do LM Studio e baixe a versão correspondente ao seu sistema operacional. Neste teste, utilizei a versão para Windows de 64 bits.
Depois da instalação, abra o programa.
O aplicativo e o modelo são elementos diferentes: instalar o LM Studio prepara o ambiente, mas ainda é necessário baixar o modelo que produzirá as respostas.
2. Baixe o modelo Qwen3-4B
Na área de pesquisa de modelos do LM Studio, procure:
Qwen3-4BNeste teste, utilizei o modelo do repositório:
lmstudio-community/Qwen3-4B-GGUFA variante escolhida foi Q4_K_M, com download de aproximadamente 2,50 GB.
O termo “4B” indica que o modelo possui cerca de quatro bilhões de parâmetros. Já “Q4_K_M” identifica uma forma de quantização, que reduz o espaço ocupado pelos pesos do modelo e a memória necessária para carregá-los, com possíveis diferenças na qualidade das respostas.
O formato GGUF é utilizado por ferramentas de execução local compatíveis, como o ambiente empregado neste teste.
O tamanho do arquivo baixado não representa todo o consumo de memória durante a execução. O processamento também precisa de espaço para o contexto da conversa e outros dados.
3. Faça a primeira conversa no LM Studio
Depois de concluir o download, selecione o modelo e clique em Use in New Chat, ou na opção equivalente da sua versão.
Envie uma pergunta simples, por exemplo:
O que é uma inteligência artificial local?No meu teste, o Qwen3-4B respondeu em português. Isso confirmou que o modelo estava carregado e conseguia gerar respostas no computador.
Alguns modelos apresentam uma etapa de raciocínio antes de entregar o texto final. O tempo de resposta pode variar conforme a pergunta, o contexto e o hardware.
Mesmo funcionando localmente, o modelo pode produzir informações incorretas. Para uso acadêmico, técnico ou profissional, é necessário verificar fatos, cálculos e referências.
4. Ative o servidor local do LM Studio
Conversar dentro do aplicativo é a primeira etapa. Para outra aplicação utilizar o modelo, precisamos ativar o servidor de API do LM Studio.
Na área de servidor ou desenvolvimento do programa, ative a opção de iniciar o servidor. Os nomes e a posição dos controles podem variar entre versões.
No teste, o endereço utilizado foi:
http://127.0.0.1:1234Esse endereço tem duas partes importantes:
- 127.0.0.1: representa o próprio computador.
- 1234: é a porta utilizada pelo servidor neste exemplo.
Mantenha o servidor ligado e confirme que o modelo está disponível. O identificador utilizado nos próximos códigos é:
qwen3-4bSe o seu modelo apresentar outro identificador, ajuste esse valor nos exemplos.
5. Verifique se a API está funcionando
Com o servidor ligado, abra no navegador:
http://127.0.0.1:1234/v1/modelsA resposta deve ser um documento JSON com os modelos visíveis para o servidor.
No meu teste, a lista incluiu o identificador qwen3-4b.
Esse resultado confirma que a API responde. O próximo teste verifica se ela também consegue gerar uma resposta a partir de uma pergunta.
O LM Studio oferece endpoints compatíveis com o formato da API da OpenAI. Aqui, utilizaremos /v1/chat/completions para enviar mensagens ao modelo local.
Essa compatibilidade não significa que a pergunta seja enviada à OpenAI: o endereço configurado no código aponta para o LM Studio no próprio computador.
6. Envie uma pergunta à IA usando Python
Com Python instalado, crie um arquivo chamado:
teste_ia.pyCole o código abaixo:
import json
import urllib.request
url = "http://127.0.0.1:1234/v1/chat/completions"
dados = {
"model": "qwen3-4b",
"messages": [
{
"role": "user",
"content": "Explique em português o que é Arduino."
}
],
"max_tokens": 1000,
"stream": False
}
requisicao = urllib.request.Request(
url,
data=json.dumps(dados).encode("utf-8"),
headers={"Content-Type": "application/json"},
method="POST"
)
with urllib.request.urlopen(requisicao, timeout=180) as resposta:
resultado = json.loads(resposta.read().decode("utf-8"))
print(resultado["choices"][0]["message"]["content"])Esse exemplo utiliza apenas módulos da biblioteca padrão do Python. Não é necessário instalar um pacote adicional para executar essa chamada.
Como executar o código
No Windows, abra o terminal na pasta em que salvou o arquivo e execute:
py teste_ia.pyO LM Studio precisa estar com o servidor ativo e o modelo disponível.
No meu teste, o terminal exibiu uma explicação sobre Arduino. Com isso, ficou confirmada a comunicação entre uma aplicação Python e o modelo local.
O que acontece nessa integração?
O programa Python transforma a pergunta em uma requisição HTTP e a envia ao LM Studio. O servidor processa a mensagem com o Qwen3-4B e devolve um JSON.
A última linha do código extrai desse JSON o texto da resposta e o apresenta no terminal.
O parâmetro max_tokens limita a quantidade de tokens gerados. Tokens são unidades de texto usadas pelo modelo; não correspondem exatamente a palavras.
7. Crie um chat local no navegador
Depois do teste no terminal, o passo seguinte foi criar uma interface web.
A aplicação utiliza um servidor Python para entregar a página ao navegador e encaminhar as mensagens ao LM Studio. A página abre em:
http://127.0.0.1:8000O servidor da página e o servidor da IA usam portas diferentes:
| Endereço | Função |
|---|---|
127.0.0.1:8000 | Página do chat |
127.0.0.1:1234 | API do LM Studio |
Para reproduzir esse teste, salve o código abaixo em um arquivo chamado chat_local.py:
import json
import urllib.request
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
PAGINA = """<!DOCTYPE html>
<html lang="pt-BR">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>Chat com IA local</title>
<style>
body {
font-family: Arial, sans-serif;
max-width: 850px;
margin: 30px auto;
padding: 0 16px;
background: #f5f7fb;
color: #182230;
}
#chat {
min-height: 250px;
background: white;
border: 1px solid #ccd3df;
border-radius: 12px;
padding: 16px;
}
.mensagem {
white-space: pre-wrap;
overflow-wrap: anywhere;
margin: 12px 0;
padding: 12px;
border-radius: 8px;
}
.usuario { background: #e8efff; }
.assistente { background: #eef6ee; }
textarea {
box-sizing: border-box;
width: 100%;
min-height: 90px;
margin-top: 16px;
padding: 12px;
font: inherit;
}
button { padding: 10px 16px; margin-top: 8px; cursor: pointer; }
#status { min-height: 24px; }
</style>
</head>
<body>
<h1>Chat com IA local</h1>
<p>Modelo Qwen3-4B pelo LM Studio.</p>
<div id="chat" aria-live="polite"></div>
<form id="formulario">
<label for="pergunta">Sua mensagem</label>
<textarea id="pergunta" required></textarea>
<button id="enviar" type="submit">Enviar</button>
<button id="limpar" type="button">Nova conversa</button>
</form>
<p id="status" role="status"></p>
<script>
const chat = document.getElementById("chat");
const campo = document.getElementById("pergunta");
const enviar = document.getElementById("enviar");
const limpar = document.getElementById("limpar");
const status = document.getElementById("status");
let historico = [];
function mostrar(nome, texto, classe) {
const bloco = document.createElement("div");
bloco.className = "mensagem " + classe;
bloco.textContent = nome + ":\\n" + texto;
chat.appendChild(bloco);
}
document.getElementById("formulario").addEventListener(
"submit", async (evento) => {
evento.preventDefault();
const texto = campo.value.trim();
if (!texto || enviar.disabled) return;
const mensagens = [
...historico,
{role: "user", content: texto}
];
mostrar("Você", texto, "usuario");
campo.value = "";
enviar.disabled = true;
limpar.disabled = true;
status.textContent = "Aguardando a IA...";
try {
const resposta = await fetch("/chat", {
method: "POST",
headers: {"Content-Type": "application/json"},
body: JSON.stringify({messages: mensagens})
});
const dados = await resposta.json();
if (!resposta.ok) {
throw new Error(dados.error || "Falha na resposta.");
}
historico = [
...mensagens,
{role: "assistant", content: dados.resposta}
];
mostrar("IA", dados.resposta, "assistente");
status.textContent = "";
} catch (erro) {
status.textContent = "Erro: " + erro.message;
} finally {
enviar.disabled = false;
limpar.disabled = false;
campo.focus();
}
}
);
limpar.addEventListener("click", () => {
historico = [];
chat.replaceChildren();
status.textContent = "";
campo.focus();
});
</script>
</body>
</html>"""
class Servidor(BaseHTTPRequestHandler):
def responder_json(self, codigo, dados):
conteudo = json.dumps(
dados, ensure_ascii=False
).encode("utf-8")
self.send_response(codigo)
self.send_header(
"Content-Type", "application/json; charset=utf-8"
)
self.send_header("Content-Length", str(len(conteudo)))
self.end_headers()
self.wfile.write(conteudo)
def do_GET(self):
if self.path != "/":
self.send_error(404)
return
conteudo = PAGINA.encode("utf-8")
self.send_response(200)
self.send_header(
"Content-Type", "text/html; charset=utf-8"
)
self.send_header("Content-Length", str(len(conteudo)))
self.end_headers()
self.wfile.write(conteudo)
def do_POST(self):
if self.path != "/chat":
self.send_error(404)
return
try:
tamanho = int(self.headers.get("Content-Length", "0"))
if not 0 < tamanho <= 100000:
self.responder_json(
400, {"error": "Tamanho da mensagem inválido."}
)
return
entrada = json.loads(
self.rfile.read(tamanho).decode("utf-8")
)
dados = {
"model": "qwen3-4b",
"messages": entrada["messages"],
"max_tokens": 2048,
"stream": False
}
requisicao = urllib.request.Request(
"http://127.0.0.1:1234/v1/chat/completions",
data=json.dumps(dados).encode("utf-8"),
headers={"Content-Type": "application/json"},
method="POST"
)
with urllib.request.urlopen(
requisicao, timeout=180
) as resposta:
resultado = json.loads(
resposta.read().decode("utf-8")
)
texto = resultado["choices"][0]["message"]["content"]
self.responder_json(200, {"resposta": texto or ""})
except Exception as erro:
self.responder_json(
502,
{
"error": (
"Confira o servidor e o modelo no LM Studio. "
+ str(erro)
)
}
)
if __name__ == "__main__":
servidor = ThreadingHTTPServer(("127.0.0.1", 8000), Servidor)
print("Abra http://127.0.0.1:8000 no navegador.")
print("Para encerrar, pressione Ctrl+C.")
try:
servidor.serve_forever()
except KeyboardInterrupt:
pass
finally:
servidor.server_close()Como abrir o chat
Mantenha o servidor do LM Studio ativo. Em outro terminal, na pasta do arquivo, execute:
py chat_local.pyDepois, abra no navegador:
http://127.0.0.1:8000Digite uma pergunta e clique em Enviar.
A página encaminha a mensagem ao servidor Python, que consulta o LM Studio e devolve a resposta. O navegador também envia o histórico das mensagens anteriores para que o modelo tenha o contexto da conversa.
Esse histórico fica na memória da página. Ao recarregá-la ou clicar em Nova conversa, ele é apagado. O exemplo não grava as conversas em um banco de dados.
As respostas são apresentadas como texto. Se o modelo gerar marcações Markdown, como asteriscos para indicar negrito, elas poderão aparecer literalmente.
Problemas comuns e como resolver
A API não abre no navegador
Verifique se o servidor do LM Studio está ligado e se a porta configurada é 1234.
Se você tiver escolhido outra porta, atualize os endereços dos exemplos.
O código informa que o modelo não está disponível
Abra:
http://127.0.0.1:1234/v1/modelsConfira o identificador do modelo e ajuste o campo "model" no código.
O Windows não encontra o arquivo Python
Abra o terminal na pasta em que o arquivo foi salvo.
Se estiver usando o Bloco de Notas, selecione Todos os arquivos ao salvar e confira se o nome não ficou como chat_local.py.txt.
A resposta demora
O tempo depende do hardware, do tamanho da conversa e da quantidade de texto gerada.
Uma conversa longa aumenta o contexto enviado ao modelo. Para um novo teste, clique em Nova conversa e faça uma pergunta curta.
A porta 8000 já está sendo utilizada
Encerre a outra aplicação que está usando essa porta ou altere o número no final do código:
servidor = ThreadingHTTPServer(("127.0.0.1", 8001), Servidor)Nesse caso, abra a página em http://127.0.0.1:8001.
Posso conectar essa IA ao meu site WordPress?
Sim, mas essa é uma etapa posterior à integração local apresentada aqui.
O endereço 127.0.0.1 representa o computador em que o programa está sendo executado. Portanto, uma hospedagem externa não consegue chegar à IA do meu computador usando esse mesmo endereço.
Para conectar um site WordPress à IA local, seria necessário criar uma comunicação protegida entre a hospedagem e o computador. O site enviaria a pergunta, o modelo local produziria a resposta e o resultado voltaria à página.
Para um chat de uso pessoal, também seria necessário restringir o acesso à conta autorizada no WordPress e autenticar a comunicação com o computador.
O código deste tutorial é um protótipo local e não possui autenticação para publicação na internet. Ele foi configurado para ouvir apenas em 127.0.0.1.
Se a IA continuar rodando no computador pessoal, ele deverá permanecer ligado e com os serviços ativos para atender às perguntas enviadas pelo site.
O que consegui fazer neste teste?
Ao final da experiência, consegui conversar com o Qwen3-4B dentro do LM Studio, ativar sua API, enviar uma pergunta com Python e utilizar um chat no navegador.
Isso demonstra uma possibilidade útil para quem desenvolve aplicações: o modelo pode ser acessado por código e integrado a uma interface própria.
A partir dessa base, é possível explorar assistentes de estudo, ferramentas de escrita e aplicações para apoiar programação. No meu caso, o próximo passo será estudar uma conexão protegida com o WordPress para uso pessoal.
Perguntas frequentes sobre IA local
Preciso de internet para conversar com o modelo?
Depois de baixar o modelo e os componentes de execução, o chat local pode funcionar sem internet. Integrações que consultam serviços externos ou acessam um site remoto precisam de conexão.
Preciso de uma placa de vídeo dedicada?
Não necessariamente. Dependendo do modelo e do ambiente de execução, é possível utilizar a CPU e a memória RAM. Uma GPU compatível pode acelerar as respostas.
Com 32 GB de RAM consigo rodar qualquer modelo?
Não. Modelos maiores podem exigir mais memória do que o computador possui. A quantização, o contexto e os recursos da GPU também influenciam o consumo.
Preciso pagar por cada pergunta?
Neste exemplo, as perguntas são processadas localmente e não utilizam uma API externa paga. Há custos de equipamento e energia, além das condições de uso e licenciamento aplicáveis.
Posso usar outro modelo no mesmo código?
Sim, desde que esteja disponível no servidor e seja compatível com a chamada utilizada. Ajuste o identificador do campo "model" para o nome retornado pela API.
A IA aprende permanentemente com minhas conversas?
Este exemplo envia o histórico como contexto, mas não realiza treinamento nem altera os pesos do modelo. Manter uma conversa contextualizada é diferente de treinar uma IA.