Chatbots de IA NSFW locais: roleplay sem censura no seu próprio PC

• Privacidade. As mensagens vão do SillyTavern para um programa no mesmo computador, e para nenhum outro lugar, a menos que você conecte um serviço na nuvem.
• Sem filtro de plataforma. Plataformas hospedadas definem e mudam as próprias regras de conteúdo. Localmente, os únicos limites são os que vieram do treinamento do modelo que você escolher.
• Sem assinatura nem limite de mensagens. Os programas e os modelos são gratuitos; você paga pelo hardware e pela energia elétrica.
• Uso offline depois que tudo estiver baixado.

As desvantagens:

• Custo do hardware. Uma boa experiência exige 12 GB ou mais de VRAM, ou um Mac de 32 GB para modelos médios; comprar isso custa mais do que muitos meses de assinatura de uma plataforma hospedada.
• Tempo de configuração. Dois programas, um download de vários gigabytes e um punhado de configurações que fazem diferença, além das atualizações.
• Modelos menores escrevem pior. Um modelo que cabe numa GPU gamer é muito menor que os maiores modelos hospedados: espere mais repetição, memória mais fraca e mais trabalho seu para conduzir a cena.
• Sem imagens nem voz de fábrica. O KoboldCpp consegue carregar modelos de imagem e de fala, e o SillyTavern tem extensões para os dois, mas cada um exige os próprios downloads e a própria memória.

O modelo precisa caber em memória rápida: a VRAM da sua placa de vídeo ou a memória unificada de um Mac com Apple Silicon. A tabela traz estimativas aproximadas, não medições, para Q4_K_M (a quantização de 4 bits mais comum, explicada abaixo) com um tamanho de contexto que caiba com folga; o uso real varia conforme o modelo e o backend.

Uma checagem rápida para qualquer modelo: o tamanho do arquivo GGUF mais 2 a 5 GB para contexto e espaço de trabalho deve caber na sua VRAM. Como referência, entre as placas de 12 GB estão a RTX 3060 12 GB, a 4070 e a 5070; de 16 GB, a RTX 4060 Ti 16 GB, a 4080 e a 5080; de 24 GB, a RTX 3090 e a 4090. GPUs de notebook costumam ter menos VRAM que a placa de desktop de mesmo nome; o Gerenciador de Tarefas mostra a sua em Desempenho, GPU.

Placas NVIDIA são as mais fáceis, já que todas as ferramentas suportam CUDA. Placas AMD e Intel funcionam via Vulkan (e ROCm, no caso da AMD), com mais configuração e, muitas vezes, menos velocidade.

VRAM, RAM do sistema e offload

Se um modelo não cabe na VRAM, o KoboldCpp, o Ollama e o LM Studio conseguem manter parte dele na RAM do sistema e rodar essa parte na CPU. Funciona, mas a RAM do sistema é bem mais lenta: algumas camadas lá custam um pouco de velocidade; metade do modelo pode deixar as respostas várias vezes mais lentas. Tenha 32 GB de RAM se pretende fazer offload.

Modelos de mistura de especialistas (mixture-of-experts, MoE) lidam melhor com isso. Um nome como 35B-A3B significa 35 bilhões de parâmetros no total, com cerca de 3 bilhões ativos por token: a memória acompanha o total, a velocidade acompanha a parte ativa, então esses modelos continuam utilizáveis quando ficam em parte na RAM do sistema.

Apple Silicon e memória unificada

Nos Macs da série M, a CPU e a GPU compartilham um único bloco de memória, então um Mac de 32 ou 64 GB consegue carregar modelos que, num PC, exigiriam uma placa de vídeo cara. O macOS reserva uma parte: conte com algo entre dois terços e três quartos disponíveis para o modelo. A velocidade acompanha a largura de banda da memória, que é maior nos chips Pro, Max e Ultra, e prompts longos são processados mais devagar do que numa configuração NVIDIA equivalente. Macs com Intel ficam basicamente limitados à CPU.

O backend carrega o modelo e gera o texto. O frontend é o app de chat que você usa: ele guarda os personagens, monta cada prompt e o envia ao backend. O SillyTavern é o frontend padrão para roleplay e funciona com todos os backends abaixo.

TextGen é o novo nome do text-generation-webui, muitas vezes chamado de oobabooga por causa do seu autor. O LM Studio é gratuito para uso doméstico e profissional, mas tem código fechado; os outros são de código aberto. A biblioteca própria do Ollama tem principalmente modelos de uso geral, mas ele consegue baixar fine-tunes de roleplay do Hugging Face.

Fontes oficiais: KoboldCpp em github.com/LostRuins/koboldcpp, SillyTavern em github.com/SillyTavern/SillyTavern, Ollama em ollama.com, LM Studio em lmstudio.ai, TextGen em github.com/oobabooga/textgen, llama.cpp em github.com/ggml-org/llama.cpp e os modelos em huggingface.co.

GGUF e quantização

Todos os backends acima carregam GGUF, o formato de arquivo do llama.cpp: um único arquivo com os pesos mais metadados, como o template de chat. Modelos grandes podem vir em partes numeradas; carregue a primeira.

A quantização guarda cada peso em menos bits que os 16 originais, reduzindo o uso de memória com alguma perda de qualidade:

• Q8_0: cerca de 8,5 bits por peso, praticamente indistinguível do original.
• Q6_K: cerca de 6,6 bits, muito próximo do original.
• Q5_K_M: cerca de 5,7 bits, um pequeno degrau abaixo.
• Q4_K_M: cerca de 4,8 bits, aproximadamente 0,6 GB por bilhão de parâmetros. O padrão mais usado, que troca uma perda modesta de qualidade por uma grande economia.
• Abaixo de Q4 (Q3_K_M, Q2_K e similares): estrago perceptível, pior em modelos pequenos.

Um modelo maior em Q4_K_M costuma escrever melhor que um menor da mesma família em Q8_0, então gaste a memória primeiro com tamanho. Nomes que começam com IQ, como IQ4_XS, usam outro método: menores com qualidade parecida, às vezes mais lentos.

Famílias base e fine-tunes da comunidade

A maioria dos modelos locais de roleplay são fine-tunes da comunidade: modelos base abertos de grandes laboratórios, treinados a mais com ficção e roleplay. Entre as famílias base que aparecem nos nomes dos modelos estão Llama (Meta), Mistral e Mistral Nemo (Mistral AI), Qwen (Alibaba) e Gemma (Google); muitos modelos populares são merges de vários fine-tunes. O rótulo "uncensored" (sem censura) é uma promessa vaga de que o modelo não recusa pedidos; "abliterated" significa que as recusas foram removidas editando os pesos.

De propósito, não apontamos um melhor modelo: fine-tunes surgem e somem em questão de semanas. Pesquise no Hugging Face uma família e um tamanho que você consiga rodar, mais GGUF, ordene por Trending ou Recently updated e veja o que os subreddits do SillyTavern e do LocalLLaMA dizem sobre os lançamentos recentes.

Como ler o card de um modelo

• Modelo base, indicado no card ou no painel Model tree do Hugging Face. Ele define, em grande parte, o template de instrução (instruct template).
• Tamanho. A contagem de parâmetros diz qual linha da tabela de hardware vale para você; em modelos MoE, use o total.
• Tamanho de contexto. Muitos fine-tunes pioram bem antes do máximo do modelo base; bons cards dizem a partir de onde.
• Licença. Confira a licença do modelo e a do modelo base. Os lançamentos abertos recentes de Qwen, Mistral e Gemma usam Apache 2.0; o Llama usa a licença comunitária da Meta, com uma política de uso aceitável.
• Uso pretendido e configurações recomendadas, incluindo o template de instrução e os valores de sampler que o autor testou.
• Links GGUF. Os arquivos quantizados costumam ficar num repositório separado com GGUF no nome, com link no Model tree.

Como avaliar um modelo por conta própria

1. Use o mesmo card de personagem, a mesma mensagem de abertura e as mesmas configurações para todos os modelos, mudando só o template de instrução.
2. Gere de três a cinco respostas para a mesma mensagem (os swipes, no SillyTavern) e compare.
3. Veja se o personagem mantém a voz e os fatos, não escreve as suas falas, varia as palavras e nunca escorrega para a linguagem de assistente.
4. Continue por 30 a 50 mensagens e depois pergunte sobre algo do começo da conversa.
5. Fique com o modelo que falha menos.

Os nomes dos menus correspondem às versões atuais; se algum tiver mudado de lugar, consulte a documentação do projeto.

Rota 1: KoboldCpp e SillyTavern no Windows

1. Baixe o KoboldCpp na página de releases do GitHub: koboldcpp.exe para placas NVIDIA, koboldcpp-nocuda.exe para placas de vídeo AMD ou Intel.
2. Baixe um fine-tune de roleplay como arquivo GGUF Q4_K_M, num tamanho que a sua VRAM comporte. O botão HF Search do launcher também encontra modelos.
3. Execute o koboldcpp.exe. O Windows pode avisar sobre um aplicativo não reconhecido, o que é comum com programas de código aberto sem assinatura digital.
4. Na aba Quick Launch, confira se Backend mostra Use CUDA (NVIDIA) ou Use Vulkan (AMD, Intel), depois clique em Browse ao lado de GGUF Text Model e escolha o seu arquivo.
5. Deixe GPU Layers em -1 (automático) no começo. Se o arquivo couber na sua VRAM com folga, digite o número total de camadas mostrado ao lado para que todas as camadas vão para a GPU.
6. Defina Context Size como 8192 ou 16384 e clique em Launch. A página de chat do próprio KoboldCpp abre em http://localhost:5001 quando o carregamento termina.
7. Instale o Node.js (LTS) e o Git. Numa pasta sua (não em Arquivos de Programas), rode git clone https://github.com/SillyTavern/SillyTavern -b release num terminal e depois dê dois cliques em Start.bat na pasta nova. O SillyTavern abre em http://127.0.0.1:8000.
8. Abra API Connections (o ícone de plugue), defina API como Text Completion e API Type como KoboldCpp, digite http://localhost:5001 como API URL, marque Derive context size from backend e clique em Connect.
9. Abra AI Response Formatting (o ícone de A), ative o Instruct Mode e ligue as opções que derivam do modelo os templates de contexto e de instrução. Se o template não for reconhecido, escolha o que o card do modelo indicar.

Rota 2: Ollama e SillyTavern no macOS ou Linux

1. Instale o Ollama: no macOS, o app de ollama.com (versão 14 ou posterior, Apple Silicon para usar a GPU); no Linux, o comando curl -fsSL https://ollama.com/install.sh | sh.
2. Baixe um fine-tune de roleplay do Hugging Face com ollama pull hf.co/user/repository:Q4_K_M, usando o caminho do modelo; a tag depois dos dois-pontos escolhe a quantização.
3. Mantenha o Ollama rodando (o app, o serviço do Linux ou ollama serve); ele escuta em http://127.0.0.1:11434.
4. Instale o Node.js e o Git (no Mac, o Homebrew é o jeito mais simples) e depois rode git clone https://github.com/SillyTavern/SillyTavern -b release, cd SillyTavern e ./start.sh.
5. Em API Connections, escolha Text Completion, API Type Ollama e API URL http://127.0.0.1:11434, clique em Connect e selecione o seu modelo em Ollama Model.
6. Em AI Response Formatting, ative o Instruct Mode e selecione o template que o card do modelo indica; a detecção automática não funciona com o Ollama.
7. Em AI Response Configuration (o ícone de controles deslizantes), defina Context (tokens), marcando Unlocked para passar de 8K. O SillyTavern repassa esse valor ao Ollama a cada requisição.

Rota 3: LM Studio como app único

1. Instale o LM Studio a partir de lmstudio.ai. Ele roda em Macs com Apple Silicon (macOS 14 ou posterior), PCs com Windows (x64 com AVX2, ou ARM) e Linux.
2. Na aba Discover, procure um fine-tune de roleplay e baixe um arquivo Q4_K_M; o LM Studio indica quais arquivos provavelmente cabem.
3. Na aba Chat, abra o carregador de modelos, escolha o modelo e defina o tamanho de contexto e o GPU offload.
4. Descreva o personagem e o cenário no system prompt e salve como preset. Macs também rodam modelos MLX, um formato específico da Apple que pode ser mais rápido.
5. Para usar cards de personagem, inicie o servidor na aba Developer, conecte o SillyTavern via Text Completion com API Type Generic (OpenAI-compatible) e a URL http://127.0.0.1:1234, e defina o template de instrução como na Rota 2.

Tamanho de contexto

O contexto é a memória de trabalho do modelo, contada em tokens; um token equivale a cerca de três quartos de uma palavra em inglês, então 8K tokens comportam umas 6 mil palavras. O system prompt, o card do personagem, as entradas do lorebook e a conversa recente dividem esse espaço, e o SillyTavern descarta as mensagens mais antigas quando ele enche. Mais contexto custa memória e tempo, então 8K a 16K é a faixa prática; use o mesmo valor no backend e no SillyTavern.

Temperatura, min-p e top-p

A temperatura define a aleatoriedade: mais alta dá texto mais variado e mais erros; mais baixa dá texto mais seguro e mais sem graça. O min-p descarta palavras improváveis em relação à primeira opção (em 0,05, qualquer uma com menos de 5 por cento da probabilidade dela), o que mantém o texto coerente em temperaturas mais altas. Top-p e top-k são filtros mais antigos e menos precisos; com min-p, defina top-p como 1 e top-k como 0 para desligá-los.

Penalidade de repetição

A penalidade de repetição torna menos prováveis as palavras usadas recentemente. Mantenha o valor baixo, por volta de 1,05 a 1,1 sobre os últimos 1.000 a 2.000 tokens (Rep. Pen. Range no SillyTavern); valores mais altos fazem o modelo evitar nomes e palavras comuns. Com KoboldCpp, llama.cpp e TextGen, o SillyTavern também oferece o DRY, que mira frases repetidas: defina o multiplicador dele em cerca de 0,8, mantenha os outros valores padrão e baixe a penalidade comum para 1,0.

Templates de instrução

Modelos ajustados para instruções esperam conversas envoltas em marcadores específicos, como ChatML ou os formatos Llama 3, Mistral e Gemma. O SillyTavern formata o prompt com o template que você seleciona, e um template errado dá na vista: o modelo escreve as suas falas, imprime tags soltas, continua sem parar ou perde a voz do personagem. O card do modelo indica o certo. Alguns modelos mais novos escrevem um bloco de raciocínio antes de responder, o que custa tempo e tokens; desligue isso quando o modelo permitir.

Um preset inicial sensato

Em AI Response Configuration, clique em Neutralize Samplers e depois defina Temperature entre 0,8 e 1,0, Min P entre 0,05 e 0,1, Top P 1, Top K 0 e Repetition Penalty 1,05 sobre 2048 tokens (ou DRY em 0,8 com a penalidade em 1,0). Defina Response (tokens) entre 250 e 400. Se as respostas ficarem incoerentes, baixe a temperatura em 0,1; se parecerem sem graça, aumente. Mude uma coisa de cada vez e parta dos valores do card do modelo quando ele os informar.

Um card de personagem é um arquivo pequeno que define uma persona. O formato mais comum, Chara Card V2, traz nome, descrição, personalidade, cenário, primeira mensagem, exemplos de diálogo, saudações alternativas, tags e um lorebook embutido opcional. Os cards vêm como JSON ou como imagens PNG com o JSON guardado dentro, então a imagem e a definição viajam juntas. Um formato V3 mais novo amplia o V2, e o SillyTavern lê os dois. Nosso guia sobre cards de personagem explica como ler um.

No SillyTavern, abra Character Management (o ícone de card) e use Import Character from File para um PNG ou JSON, ou Import content from external URL para um link de um site compatível, como o Chub. Confira antes a contagem de tokens: um card com mais de uns 2.000 tokens aperta um contexto pequeno. O Chub AI é uma das maiores bibliotecas públicas de cards e lorebooks, e os downloads dele funcionam no SillyTavern.

Os lorebooks, chamados de World Info no SillyTavern, guardam informações de fundo, como lugares, personagens secundários e regras. Uma entrada é incluída no prompt quando uma das palavras-chave dela aparece nas mensagens recentes, então um universo grande consome contexto sobretudo quando isso importa.

As regras de conteúdo continuam valendo em casa. Nosso diretório exclui cards que sugiram menores de idade (incluindo personagens com aparência jovem ou em ambientes escolares), pessoas reais e ausência de consentimento, como detalha a nossa política de conteúdo. Aplique o mesmo filtro ao que você baixa: um modelo local escreve o que o card pedir, e a responsabilidade é sua.

Se dois programas são mais do que você quer encarar, o HammerAI tem um app de desktop para Windows, macOS e Linux que roda modelos abertos localmente por meio de uma cópia embutida do Ollama, com uma interface de chat com personagens e sem precisar de conta para o chat local. Você abre mão de controle em troca de quase não precisar configurar nada.

Sem o hardware adequado, uma plataforma hospedada é a escolha prática: várias têm planos gratuitos generosos e muitas vezes rodam modelos maiores do que um PC doméstico consegue, ao custo de privacidade e de limites diários. Veja os limites gratuitos atuais no nosso ranking de chats de IA NSFW grátis ou compare todos os serviços na lista de plataformas.

• Suas conversas são arquivos. O SillyTavern guarda conversas e personagens na pasta de dados dele, que qualquer pessoa usando a sua conta consegue ler. Use senha, criptografia de disco (BitLocker ou Criptografia de Dispositivo no Windows, FileVault no Mac) e uma conta só sua em computadores compartilhados.
• Mantenha os servidores locais. Por padrão, o SillyTavern só aceita conexões do seu próprio computador. Se você abrir o acesso para a sua rede doméstica, mantenha a whitelist ativada e nunca o exponha à internet. Deixe o Remote Tunnel do KoboldCpp desligado e não mude o endereço de bind do Ollama, a menos que saiba por quê: qualquer pessoa que alcance esses servidores pode usá-los.
• Saiba para onde as mensagens vão. Se o SillyTavern estiver conectado a uma API na nuvem, as suas conversas vão para esse provedor.
• Baixe de fontes oficiais. Pegue modelos de autores conhecidos no Hugging Face e prefira arquivos GGUF ou safetensors; formatos pickle mais antigos (.bin, .pt, .pth) podem executar código ao serem carregados. Nunca rode um instalador que diga ser um modelo e mantenha o seu backend atualizado, já que falhas de segurança na leitura de arquivos de modelo já foram encontradas antes.
• Só adultos e só ficção. Nunca crie nem compartilhe conteúdo sexual sobre pessoas reais, e nunca envolva menores de idade de forma alguma.

Plataformas hospedadas levantam outras questões; o nosso checklist de privacidade trata delas.

Posso rodar um chatbot de IA NSFW no meu próprio PC?

Sim. Com uma placa de vídeo de 8 GB ou mais de VRAM, ou um Mac com Apple Silicon e 16 GB ou mais de memória, você consegue rodar um modelo aberto com programas gratuitos como o KoboldCpp e o SillyTavern. Não há filtro de plataforma nem conta, e as suas conversas ficam no seu computador.

De quanta VRAM eu preciso?

Aproximadamente 8 GB para modelos de 7 a 9B, 12 GB para 12 a 14B, 24 GB para 22 a 32B e 48 GB para 70B, na quantização comum de 4 bits com 8K a 16K tokens de contexto. Com menos VRAM, parte do modelo pode rodar na RAM do sistema, o que funciona, mas deixa as respostas bem mais lentas.

Roleplay com IA local é de graça?

Os programas são gratuitos, os modelos são gratuitos para baixar e não há assinaturas nem limites de mensagens. Você paga pelo hardware, pela energia elétrica e pelo seu tempo.

Qual é o jeito mais fácil de começar?

Para praticamente não configurar nada, instale o app de desktop do HammerAI, que roda modelos locais com uma interface de personagens. Para ter mais controle, use KoboldCpp com SillyTavern no Windows ou Ollama com SillyTavern no Mac, começando com um modelo de roleplay da classe 12B se a sua memória permitir.

Um Mac consegue rodar roleplay com IA local?

Sim, com um chip Apple Silicon (M1 ou posterior). Um Mac com 16 GB de memória dá conta de modelos pequenos; com 32 GB, de modelos médios; e com 64 GB ou mais, de modelos 70B. Ollama, LM Studio, KoboldCpp e SillyTavern rodam todos no Apple Silicon; Macs com Intel ficam basicamente limitados à CPU, que é lenta.

É permitido por lei?

Rodar modelos abertos no seu próprio computador é permitido na maioria dos países, mas o que você gera está sujeito à lei local, e a licença de um modelo pode restringir alguns usos. Conteúdo sexual envolvendo menores de idade é ilegal em muitos países mesmo quando é ficcional ou gerado por IA, e conteúdo sexual que retrata pessoas reais sem consentimento é ilegal ou passível de processo em um número crescente de lugares. Esta é uma informação geral, não aconselhamento jurídico.