Como criei minha IA local gratuita — e por que você deveria fazer isso também

Cansado de ficar olhando pro contador de tokens no ChatGPT? Eu também fiquei. Um dia resolvi parar de pagar por uso e colocar uma IA pra rodar direto no meu notebook. Funcionou melhor do que eu esperava — e você pode fazer o mesmo hoje.

Antes de qualquer coisa: isso não substitui o GPT-4 ou o Claude em qualidade. Não vou mentir pra você. Se você precisa de respostas sofisticadas, análise de documentos longos ou geração de código complexo, as APIs pagas ainda ganham. Mas pra rascunhar texto, responder perguntas simples, testar ideias ou explorar sem medo de gastar — uma IA local é imbatível.

O que vou mostrar aqui é exatamente o que eu fiz: instalar o Ollama, baixar um modelo chamado qwen3:8b, e subir um servidor web simples em Python pra ter uma interface de chat no navegador. Tudo rodando na minha máquina, sem internet, sem cobrança por token, sem nada sair do computador.

Por que o Ollama?

Existem outras formas de rodar IA localmente, mas o Ollama é de longe a mais simples. Você instala como qualquer programa, ele roda em segundo plano, e expõe uma API REST na porta 11434. É basicamente um servidor de modelos com uma CLI amigável — não precisa configurar Docker, não precisa entender de CUDA, não precisa de nada especial.

E o modelo que vou usar, o qwen3:8b? É da Alibaba, tem 8 bilhões de parâmetros, ocupa cerca de 5 GB de RAM e funciona razoavelmente bem sem placa de vídeo dedicada. Não é o mais poderoso do mundo, mas pra maioria das tarefas do dia a dia ele dá conta.

Mão na massa

Vou dividir em seis passos. Nenhum deles é complicado, mas tem uma ordem certa pra seguir.

Passo 1 — Instalar o Ollama

Acesse ollama.com, baixe o instalador para Windows e execute normalmente. Ele se instala e fica rodando em segundo plano — aparece como ícone na bandeja do sistema.

Abra o terminal (PowerShell ou CMD) e confirme que instalou certo:

Se aparecer um número de versão, está ótimo. Se der “comando não encontrado”, reinstale marcando a opção Add to PATH.

Passo 2 — Baixar o modelo

Agora você vai baixar o qwen3:8b. São cerca de 5 GB — coloca pra baixar e vai tomar um café.

Depois que terminar, confirme que o modelo está disponível:

Passo 3 — Criar o projeto no VS Code

Crie uma pasta chamada projeto-ia-local em algum lugar do computador e abra ela no VS Code. Dentro, você vai precisar de três arquivos:

Passo 4 — Criar o ambiente virtual

Esse passo é o que mais vejo as pessoas pulando — e depois vira dor de cabeça. Sempre crie um ambiente virtual antes de instalar dependências Python. Ele isola as bibliotecas do projeto e evita conflitos com outros programas na sua máquina.

No terminal integrado do VS Code (Ctrl + `):

Ative o ambiente virtual:

Você vai saber que funcionou quando aparecer (.venv) no começo da linha do terminal. O VS Code também detecta automaticamente e pergunta se quer usar essa venv — aceite.

Passo 5 — O código do projeto

Aqui está o código completo dos três arquivos. Copie cada um pra dentro da sua pasta.

flask==3.1.0
requests==2.32.3

"""
Cliente simples para comunicar com a API local do Ollama.
"""

import requests
import json

OLLAMA_URL = "http://localhost:11434"
DEFAULT_MODEL = "qwen3:8b"


def chat(messages: list[dict], model: str = DEFAULT_MODEL, stream: bool = False) -> str:
    """
    Envia uma conversa para o Ollama e retorna a resposta.

    messages: lista de dicts com 'role' (user/assistant/system) e 'content'
    """
    payload = {
        "model": model,
        "messages": messages,
        "stream": stream,
    }

    response = requests.post(
        f"{OLLAMA_URL}/api/chat",
        json=payload,
        timeout=120,
    )
    response.raise_for_status()
    return response.json()["message"]["content"]


def list_models() -> list[str]:
    """Retorna os modelos disponíveis no Ollama local."""
    response = requests.get(f"{OLLAMA_URL}/api/tags", timeout=10)
    response.raise_for_status()
    return [m["name"] for m in response.json().get("models", [])]


def is_ollama_running() -> bool:
    """Verifica se o Ollama está rodando."""
    try:
        requests.get(f"{OLLAMA_URL}/api/tags", timeout=5)
        return True
    except requests.ConnectionError:
        return False

"""
Interface web para chat com IA local via Ollama.
Execute: python app.py
Acesse: http://localhost:5000
"""

from flask import Flask, request, jsonify, render_template_string
from ollama_client import chat, list_models, is_ollama_running, DEFAULT_MODEL

app = Flask(__name__)

# Histórico de mensagens por sessão (em memória — reinicia com o servidor)
conversation_history: list[dict] = []

SYSTEM_PROMPT = (
    "Você é um assistente inteligente e prestativo. "
    "Responda sempre em português do Brasil, de forma clara e objetiva."
)

HTML_PAGE = """
... (template HTML da interface do chat)
"""  # interface completa omitida aqui por brevidade; veja o arquivo app.py


@app.route("/")
def index():
    model = DEFAULT_MODEL
    try:
        models = list_models()
        if models:
            model = models[0] if DEFAULT_MODEL not in models else DEFAULT_MODEL
    except Exception:
        pass
    return render_template_string(HTML_PAGE, model=model)


@app.route("/chat", methods=["POST"])
def chat_endpoint():
    data = request.get_json()
    user_message = data.get("message", "").strip()

    if not user_message:
        return jsonify({"error": "Mensagem vazia."}), 400

    if not is_ollama_running():
        return jsonify({"error": "Ollama não está rodando. Execute: ollama serve"}), 503

    conversation_history.append({"role": "user", "content": user_message})
    messages = [{"role": "system", "content": SYSTEM_PROMPT}] + conversation_history

    try:
        reply = chat(messages)
        conversation_history.append({"role": "assistant", "content": reply})
        return jsonify({"response": reply})
    except Exception as e:
        return jsonify({"error": f"Erro ao chamar Ollama: {str(e)}"}), 500


@app.route("/clear", methods=["POST"])
def clear():
    conversation_history.clear()
    return jsonify({"ok": True})


if __name__ == "__main__":
    print("\n🚀 IA Local com Ollama")
    print("=" * 40)

    if not is_ollama_running():
        print("⚠️  Ollama não detectado! Execute primeiro: ollama serve")
    else:
        models = list_models()
        print(f"✅ Ollama rodando | Modelos disponíveis: {', '.join(models)}")

    print(f"\n🌐 Acesse: http://localhost:5000\n")
    app.run(debug=False, host="0.0.0.0", port=5000)

Passo 6 — Instalar dependências e rodar

Com a venv ativa, instale as bibliotecas:

Agora inicie o servidor:

Se aparecer ✅ Ollama rodando no terminal, abra o navegador em http://localhost:5000 e comece a conversar.

Vale a pena mesmo?

Depende do que você precisa. Fiz uma comparação rápida pra deixar claro:

No meu caso, uso a IA local pra rascunhos, revisões rápidas de texto e exploração de ideias. Pra código complexo ou análise de documentos sérios, ainda recorro às APIs pagas. O ideal, honestamente, é ter os dois.

Problemas que você vai encontrar

“Ollama não está rodando” — Execute ollama serve no terminal, ou procure o ícone do Ollama na bandeja do sistema (cantinho direito da barra de tarefas do Windows).

“Module not found” — A venv não está ativa. O terminal precisa mostrar (.venv) no começo. Se não mostrar, execute .venv\Scripts\Activate e instale de novo.

Respostas muito lentas — Sem GPU é assim mesmo. O qwen3:8b pode levar 10 a 30 segundos por resposta. Se incomodar, troque pro qwen3:1.7b ou phi3:mini no arquivo ollama_client.py.

“python não é um comando reconhecido” — O Python não está no PATH do sistema. Reinstale pelo python.org marcando a opção Add Python to PATH na primeira tela da instalação.

O que fazer depois

Se você chegou até aqui com o chat funcionando, parabéns — você tem uma IA rodando 100% na sua máquina. A partir daqui tem bastante coisa pra explorar:

Você pode trocar o modelo quando quiser. O Ollama tem um catálogo enorme em ollama.com/library. Modelos menores como o phi3:mini respondem mais rápido; modelos maiores como o phi4:14b são mais capazes mas precisam de mais RAM.

Pode também personalizar o comportamento da IA editando o SYSTEM_PROMPT no app.py. Quer uma IA especialista em Python? Em redação? Em análise de contratos? Só mudar uma linha.

E se quiser avançar mais: streaming de resposta (o texto aparecer palavra por palavra como no ChatGPT), salvar histórico em JSON, ou empacotar tudo como app desktop com PyWebView. O código base que a gente criou aqui é simples o suficiente pra qualquer um desses caminhos.

Atenção sobre segurança: por padrão, o servidor sobe com host="0.0.0.0", o que significa que outras pessoas na mesma rede Wi-Fi conseguem acessar sua IA. Em casa isso normalmente não é problema — o roteador bloqueia o acesso externo. Mas em redes públicas (café, coworking, aeroporto), troque para host="127.0.0.1" no final do app.py. Assim só o seu computador acessa.

Boa sorte — e aproveite a IA sem olhar pro contador de tokens.