Jan: a alternativa open-source ao ChatGPT, 100% locale

#Por que Jan?

Três coisas distinguem o Jan no cenário concorrido dos clientes de LLM para desktop. Primeiro, ele é realmente de código aberto: código no GitHub (menloresearch/jan), licença AGPL-3.0 e build reprodutível. LM Studio e Msty são gratuitos, mas de código fechado. Se a transparência do binário que roda continuamente na sua máquina importa para você, o Jan é o único dos três que atende a esse critério.

Segundo, a filosofia offline-first é radical. Jan não faz nenhuma chamada de rede ao iniciar. Sem verificação automática de atualizações, sem telemetria, sem "phone home" disfarçado. Os modelos são baixados sob demanda do Hugging Face, e pronto. Você pode usá-lo em uma máquina fisicamente isolada da rede sem comprometer seu funcionamento.

Terceiro, a arquitetura é limpa: Jan é um front-end Electron sobre o Cortex, um motor de inferência separado (anteriormente chamado Nitro). O Cortex utiliza o llama.cpp no backend e expõe uma API REST. Assim, você pode usar o servidor Cortex sem o front-end Jan, ou conectar outros clientes ao Cortex. Isso é mais modular que LM Studio que é monolítico.

#Pré-requisitos

Sistema

Windows 10/11 (x64), macOS 12+ (Intel ou Apple Silicon), Linux (deb, AppImage ou rpm).

RAM

8 GB é o mínimo absoluto (modelos 2B-3B), 16 GB oferece uma margem confortável (modelos 8-9B Q4), 32 GB ou mais para modelos de 24B ou maiores.

Espaço em disco

Reserve 5 GB para Jan + Cortex e mais 2 a 40 GB por modelo, dependendo do tamanho. Uma pasta dedicada em um SSD é ideal.

GPU (opcional, mas recomendado)

NVIDIA com CUDA para Windows/Linux, Metal automático em Apple Silicon. Sem GPU, o Jan roda na CPU — lento, mas funcional para modelos pequenos.

#1. Instalação

Baixe o instalador do site oficial. O Jan se apresenta como um instalador de 1 clique — sem operações via linha de comando, sem dependências Python para gerenciar.

https://jan.ai

1. 01
   Iniciar o instalador

   Clique duas vezes no .exe (Windows), .dmg (macOS) ou .AppImage (Linux). No Linux, torne o AppImage executável com chmod +x Jan-*.AppImage, se necessário.
2. 02
   Primeira execução

   Jan cria sua pasta de dados (~/jan no macOS/Linux, %APPDATA%\Jan no Windows). É nela que ficarão os modelos, as conversas e a configuração. Leve isso em conta se quiser colocar essa pasta em um SSD secundário.
3. 03
   Verificar o Cortex

   Ao iniciar, o Jan inicia o serviço Cortex em segundo plano. Se uma janela de firewall abrir, permita a conexão local (o Cortex escuta em 127.0.0.1, não na rede).
4. 04
   Onboarding

   O Jan sugere um modelo para começar (geralmente um Qwen ou Granite pequeno). Você pode aceitá-lo para testar em 2 minutos ou selecionar skip para escolher por conta própria no Hub.

#2. Primeiro modelo

Jan integra um Hub de modelos que aponta para o Hugging Face com versões GGUF preparadas e testadas. Abra a aba "Hub" na barra lateral esquerda para ver o catálogo.

Para começar, três opções sólidas em francês de acordo com sua VRAM:

Configuração leve (8 GB de RAM, sem GPU)

Granite 4.2 3B Q4_K_M (≈2,2 GB). Muito leve, suficiente para conversar, resumir um texto curto, fazer brainstorming. Taxa razoável de tokens por segundo na CPU. Ainda mais leve: Qwen 3.5 2B (≈1,9 GB).

Configuração padrão (16 GB RAM, GPU de 6 a 8 GB)

Qwen 3.5 9B Q4_K_M (≈6,6 GB). A escolha para 8 GB em 2026: 256k de contexto, visão, excelente equilíbrio FR/EN para a maioria dos usos cotidianos.

Configuração confortável (32 GB de RAM, GPU de 12 GB+)

Gemma 4 12B (multimodal, ≈7,6 GB) ou Mistral Small 24B em Q4_K_M (≈14 GB, bom em francês). Raciocínio consideravelmente superior ao dos modelos 8-9B.

Clique em "Download" na ficha do modelo. Jan exibe o progresso e armazena o arquivo GGUF em sua pasta data. Após o download, o botão passa a ser "Use" — um clique e o modelo é carregado na memória.

#3. Começar a usar

A interface do Jan segue o padrão do ChatGPT: barra lateral de conversas à esquerda, área de chat no centro, painel de configurações contextuais à direita. Três coisas que você precisa saber para ser produtivo:

Threads

Cada conversa é um "Thread" independente com seu próprio modelo atribuído. Você pode abrir vários threads em paralelo (útil para comparar a resposta de um 7B e de um 14B sobre a mesma pergunta).

Assistentes

Aba Assistants: crie personas com prompt de sistema, temperatura e modelo previamente atribuído. Útil para ter um "Assistente de código" (Qwen3-Coder, temperatura 0,2) e um "Assistente de redação" (Mistral Small, temperatura 0,8) separados.

Parâmetros de geração

Painel da direita — temperatura, top-p, top-k, max tokens, penalidade por frequência. Esses parâmetros podem ser alterados por thread. A janela de contexto (n_ctx) é ajustada no nível do modelo em Settings → My Models.

#4. Extensões e Cortex

Jan tem uma arquitetura baseada em extensões. Os principais componentes são, eles próprios, extensões internas (Inference Cortex Extension, Model Extension, etc.), o que permite substituí-los no futuro. Para o usuário, o ecossistema de extensões de terceiros ainda é mais jovem que o do VS Code, mas algumas valem a pena conhecer:

Motores de inferência alternativos

Além do Cortex/llama.cpp usado por padrão, você pode ativar extensões que se conectam a um endpoint remoto compatível com OpenAI (Ollama, vLLM ou até a nuvem da OpenAI, se aceitar sair do ambiente local).

Cortex em modo standalone

O Cortex vem com o Jan, mas pode funcionar sozinho. cortex run qwen3.5:2b na CLI inicia um servidor na porta padrão sem a interface do Jan. Útil para criar scripts ou implantar em um servidor sem interface gráfica.

Model Hub configurável

Você pode adicionar fontes personalizadas de modelos (um repositório HF privado, um espelho interno) editando as configurações do Hub. Útil em empresas para distribuir modelos com ajuste fino feito internamente.

# Lancer le serveur Cortex seul
cortex start

# Lister les modèles disponibles
cortex models list

# Charger et servir un modèle
cortex run qwen3.5:9b-gguf-q4-km

#5. Modo de servidor de API

O modo servidor de Jan expõe uma API compatível com OpenAI na rede local. Isso transforma o Jan de um simples cliente de chat em um verdadeiro backend para seus scripts, automações n8n ou um copiloto no VS Code via Continue.dev.

1. 01
   Ativar o servidor

   Settings → Local API Server. Marque "Start Local API Server". O Jan inicia o Cortex em modo servidor na porta 1337 por padrão (configurável).
2. 02
   Escolher o modelo servido

   Todos os modelos baixados são disponibilizados pela API. Cada um tem um identificador que pode ser usado no campo "model" das requisições (visível na coluna ID de My Models).
3. 03
   Teste rápido com curl

   Verifique se o servidor responde com uma chamada /v1/chat/completions padrão. A sintaxe é idêntica à da OpenAI.

curl http://localhost:1337/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "qwen3.5:9b-gguf-q4-km",
    "messages": [{"role": "user", "content": "Bonjour, qui es-tu ?"}],
    "temperature": 0.7
  }'

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:1337/v1",
    api_key="jan-local",  # n'importe quelle string, Jan ne vérifie pas
)

response = client.chat.completions.create(
    model="qwen3.5:9b-gguf-q4-km",
    messages=[
        {"role": "system", "content": "Tu réponds toujours en français."},
        {"role": "user", "content": "Explique-moi ce qu'est un LLM en deux phrases."},
    ],
)
print(response.choices[0].message.content)

#Jan vs LM Studio vs Msty

As três aplicações são clientes de desktop para LLMs locais com interface limpa e servidor de API local. O diabo está nos detalhes.

Jan

Código aberto (AGPL), com prioridade estrita ao funcionamento offline, arquitetura modular com Cortex como motor separado. Catálogo de modelos mais restrito que o do LM Studio. Ideal para quem quer software livre e auditável.

LM Studio

De código fechado, mas gratuito. O catálogo do Hugging Face mais rico dos três (busca diretamente no HF). Suporte a MCP, MLX nativo no Mac, predição de múltiplos tokens. Mais funcionalidades, mas opaco.

Msty

Código-fonte fechado, freemium (versão Aurum paga). O melhor para RAG: espaços de trabalho com documentos, chat dividido (comparar dois modelos lado a lado), Knowledge Stacks. Menos sólido no uso apenas como chat, mais voltado para um "agente pessoal".

#Solução de problemas

Modelo não carrega / OOM

Verifique a VRAM/RAM disponível. Em Settings → My Models → [modelo] → Edit Parameters, reduza n_gpu_layers para transferir menos camadas para a GPU. Ou passe para uma quantização menor (Q4_K_S em vez de Q4_K_M, ou IQ3_M).

Taxa de tokens por segundo muito baixa

Confirme que a GPU está realmente sendo utilizada: em placas NVIDIA, abra nvidia-smi durante uma geração; você deve ver Jan ou cortex-server consumindo VRAM. No Apple Silicon, o Metal está ativado por padrão, sem necessidade de ajustes.

Cortex não inicia (Windows)

Redistribuível do Visual C++ faltando. Instale o vc_redist x64 da Microsoft. Verifique também se nenhum outro processo está usando a porta 1337 (mude a porta nas configurações, se necessário).

Linux: AppImage não inicia

Instale o libfuse2 (sudo apt install libfuse2 no Ubuntu 22.04+). Para depuração, execute o AppImage a partir de um terminal para ver os erros.

Download do modelo travado em 99%

Interrompa e reinicie. O Jan retoma o download. Se o problema persistir, baixe o GGUF manualmente do Hugging Face e importe-o por meio de Settings → My Models → Import.

Respostas em inglês apesar de um prompt em francês

O modelo não é capaz o suficiente para manter a coerência entre os dois idiomas. Adicione ao assistente um prompt de sistema explícito: "Responda sempre em francês", ou mude para um modelo com bom desempenho em francês (Mistral Small 24B, Qwen 3.5, Gemma 4).

#Para se aprofundar

Dependendo de onde você quer chegar agora:

Comparar Jan com seus concorrentes diretos

« Ollama vs LM Studio vs Jan vs GPT4All » apresenta um quadro detalhado para escolher a ferramenta adequada ao seu perfil.

Compreender as quantizações Q4/Q5/Q8

« Escolher a quantização (Q4, Q5, Q8, FP16) » explica os compromissos qualidade/memória — útil para escolher de forma inteligente no Hub de Jan.

Fazer RAG em seus documentos

Jan não tem RAG nativo sólido. « RAG local com Ollama sem codificar (Open WebUI, AnythingLLM) » mostra alternativas sem código que também se conectam ao servidor API de Jan.