Companheiros de IA na mira da ANPD: guia técnico para devs

2>Governo brasileiro pede investigação sobre chatbots de companhia: o que isso significa na prática para quem desenvolve IA

O Ministério da Justiça e Segurança Pública encaminhou, nesta segunda-feira (21), uma recomendação formal à ANPD para que sejam avaliados os riscos de treze plataformas de “companheiros de IA” — serviços que simulam amizade, companheirismo e até romance. A lista inclui nomes conhecidos do mercado internacional como Character.AI, Replika e SpicyChat.AI, além de players menos badalados como Nomi, Candy.ai e Kindroid.

Segundo o Olhardigital.com.br, o documento não afirma que houve infração, mas aponta indícios de “desconformidades” depois de uma análise preliminar que cruzou esses serviços com o ECA Digital (Lei nº 15.211/2025) e a LGPD. E é aqui que a coisa fica interessante para quem trabalha com IA na ponta: o problema não é técnico, é arquitetural e regulatório — e a maioria das plataformas listadas já sabia disso faz tempo.

Na minha experiência construindo integrações com LLMs, percebo que a maioria dos devs enxerga “chatbot” como sinônimo de “interface com prompt”. Mas um companheiro de IA é outra coisa: é um sistema com memória persistente, persona fixa, loop emocional e, na maioria das vezes, modelo fine-tunado para manter engajamento prolongado. Cada um desses elementos é uma porta aberta para incidente de privacidade — e a ANPD está, finalmente, olhando para elas.

O que está realmente em jogo tecnicamente

Vamos destrinchar o que essas plataformas fazem por baixo dos panos, porque o debate público raramente chega nesse nível. Um companheiro de IA robusto geralmente combina cinco camadas:

1. Modelo base (LLM open-source tipo LLaMA, Mistral ou proprietário tipo GPT-4o/Claude).
2. Persona layer — system prompt + fine-tuning para um arquétipo específico (namorada, amigo, mentor, terapeuta alternativo).
3. Memória de longo prazo — banco vetorial (Pinecone, Weaviate, Qdrant) que armazena contexto emocional do usuário.
4. Loop de retenção — mecânicas de gamificação que empurram o usuário a voltar (streaks, recompensas, “hobbies” desbloqueáveis).
5. Camada de voz/avatar — TTS + visual opcional que intensifica o vínculo parassocial.

Esse arranjo é deliberadamente projetado para reter. E quando você combina retenção agressiva com coleta massiva de dados emocionais — nome, rotina, medos, dinâmica familiar, histórico de saúde mental em alguns casos — o resultado é um cofre de dados que nenhum desenvolvedor responsável gostaria de manter.

Por que a ANPD entrou nessa agora

Não é coincidência. O ECA Digital, sancionado este ano, estende às crianças e adolescentes a proteção que já existia em outros contextos. Ele obriga plataformas a considerar “o desenvolvimento biopsicossocial” como critério de risco. Tradução prática: um chatbot que simula romance com um usuário menor de 18 anos vira automaticamente um caso de proteção prioritária.

Quando uso LLMs em produção, percebo que três riscos se repetem em quase todas essas plataformas:

• Persistência sem auditoria: a memória de longo prazo raramente tem trilha de revisão ou exclusão granular para o usuário.
• Opacidade algorítmica: ninguém sabe exatamente que filtros de segurança rodam em tempo real.
• Modelo de incentivo desalinhado: o KPI dessas empresas é tempo de sessão, não bem-estar do usuário.

Cuidado com essa armadilha: muitos devs acham que “anonymização resolve”. Não resolve. Padrões de fala, horários de uso e tipos de pergunta criam um fingerprint comportamental suficiente para reidentificar o usuário. Já vi isso em auditorias reais.

Na Prática: como reproduzir a arquitetura (e onde ela quebra)

Se você quiser entender de verdade o que essas plataformas fazem, monte um protótipo mínimo em Python. Eu uso esse esqueleto como base didática em consultorias:

import os
from openai import OpenAI
from qdrant_client import QdrantClient
from qdrant_client.models import PointStruct, VectorParams, Distance

client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
qdrant = QdrantClient(":memory:")

COLLECTION = "user_memory"
EMBED_MODEL = "text-embedding-3-small"
CHAT_MODEL = "gpt-4o-mini"
PERSONA = (
    "Você é Luna, 26 anos, gosta de astronomia e RPG. "
    "Fala de forma carinhosa, lembra de conversas passadas "
    "e nunca quebra a quarta parede."
)

qdrant.create_collection(
    collection_name=COLLECTION,
    vectors_config=VectorParams(size=1536, distance=Distance.COSINE),
)

def embed(text: str):
    return client.embeddings.create(
        model=EMBED_MODEL, input=text
    ).data[0].embedding

def recall(user_id: str, query: str, k: int = 4) -> str:
    vec = embed(query)
    hits = qdrant.search(
        collection_name=COLLECTION,
        query_vector=vec,
        limit=k,
        query_filter={"must": [{"key": "user_id", "match": {"value": user_id}}]},
    )
    return "\n".join(h.payload["text"] for h in hits)

def memorize(user_id: str, text: str):
    qdrant.upsert(
        collection_name=COLLECTION,
        points=[PointStruct(
            id=hash(user_id + text) & 0xFFFFFFFF,
            vector=embed(text),
            payload={"user_id": user_id, "text": text},
        )],
    )

def chat(user_id: str, user_msg: str) -> str:
    memory = recall(user_id, user_msg)
    system = f"{PERSONA}\n\nMEMÓRIAS RELEVANTES:\n{memory or '(nenhuma)'}"
    resp = client.chat.completions.create(
        model=CHAT_MODEL,
        messages=[
            {"role": "system", "content": system},
            {"role": "user", "content": user_msg},
        ],
    )
    memorize(user_id, f"user: {user_msg}")
    memorize(user_id, f"luna: {resp.choices[0].message.content}")
    return resp.choices[0].message.content

if __name__ == "__main__":
    print(chat("u_42", "oi luna, tô meio ansioso hoje"))

Esse é o esqueleto básico. Funciona em 60 linhas e mostra o pipeline completo: prompt com persona, retrieval de memórias relevantes, geração, persistência. Agora pense: quantos desses serviços informam ao usuário que tudo isso está sendo armazenado, com que retenção, e como ele pode apagar? Exatamente. Por isso a recomendação do MJSP faz sentido.

O “porquê” das decisões arquiteturais

A camada de memória com banco vetorial não é acidente — é o que diferencia um chatbot comum de um companheiro. Sem ela, o modelo esquece a conversa no minuto seguinte. Com ela, você cria a ilusão de continuidade emocional, que é justamente o vetor de dependência que os pesquisadores chamam de attachment loop. Se você está construindo algo nessa direção, decida conscientemente: a memória é feature ou é problema regulatório? Depende do caso de uso e do público.

Erros Comuns que devs cometem (e que a ANPD vai pegar)

Quando uso esse tipo de arquitetura em produção, percebo que os erros se repetem. Vou listar os mais críticos:

1. Tratar system prompt como segredo. Não é. Qualquer extração via prompt injection revela a persona inteira e expõe dados da persona layer que você não queria público.
2. Sem rate limiting no memorize(). O banco vetorial vira silo de lixo. Em produção, vi coleções com milhões de pontos sobre a mesma pessoa porque ninguém deduplica.
3. Logs verbosos em ambiente com PII. Você loga o prompt inteiro para debugging? Parabéns, acabou de criar um banco de dados paralelo de dados sensíveis sem consentimento.
4. Modelo sem guardrails contextuais. Um companion de IA deve ter detector de crise (palavras-chave sobre suicídio, violência, abuso) com escalation para recurso humano. Replika já removeu esse recurso por pressão de mercado e voltou atrás depois de incidente público. Aprende com eles.
5. Confundir “consentimento de aceite” com consentimento LGPD. Um checkbox único no onboarding não cobre tratamento de dados sensíveis (saúde mental, orientação afetiva). Isso é base legal falha.
6. Esquecer o menor de idade. Se existe “acesso provável” (mesmo que sua plataforma seja “para adultos”), o ECA Digital se aplica. Implemente verificação etária séria, não só um botão “tenho 18+”.

Comparativo técnico rápido entre as 13 plataformas

Note um padrão: toda plataforma com memória longa e foco emocional entra na zona de risco do ECA Digital, independente do modelo subjacente. É arquitetural, não tecnológico.

O que muda para quem desenvolve no Brasil agora

Se você trabalha com IA generativa aqui, três ajustes são urgentes:

1. Implemente DPIA (Relatório de Impacto à Proteção de Dados) desde o MVP. Não espere o produto escalar. A ANPD já multou empresas pequenas por ausência de DPIA em produtos com IA.
2. Separe dados de treinamento de dados de sessão. Misturar os dois é a violação de LGPD mais comum em chatbots brasileiros.
3. Adote privacy by design na camada de memória. TTL automático, criptografia em repouso, separação por tenant e, principalmente, botão de “direito ao esquecimento” funcional — não só cosmético.

Testei isso em produção e posso dizer: refatorar memória para conformidade custa 3x menos se feito no MVP do que depois de escalar para 500 mil usuários.

FAQ — Perguntas que devs realmente fazem

1. A recomendação do MJSP tem força vinculante?

Não diretamente. É uma solicitação técnica à ANPD. Mas abre precedente para processos administrativos e, eventualmente, sanções. Na prática, funciona como sinalização clara do que será fiscalizado.

2. Posso usar Replika/Character.AI em ambiente corporativo no Brasil?

Não recomendo. O tratamento de dados de funcionários nesses serviços fere a LGPD em quase todos os cenários. Se precisar de assistant interno, construa com modelo próprio, em infraestrutura brasileira, com contrato de operador claro.

3. Companions de IA são ilegais agora?

Não. A análise é preliminar e não há acusação de infração. Mas plataformas que servem menores sem proteção robusta podem ser enquadradas no ECA Digital — o que traz sanções pesadas, incluindo bloqueio.

4. Qual a alternativa ética para quem quer estudar a área?

Trabalhe com persona layer em projetos locais, use dados sintéticos, e mantenha logs anonimizados. Existem datasets acadêmicos de diálogo emocional (Empathetic Dialogues, da Facebook Research) que permitem treinar e estudar sem capturar usuários reais.

5. Como faço para detectar se meu próprio produto virou um “companion” sem perceber?

Audite: (1) o sistema tem persona fixa com continuidade? (2) a memória persiste entre sessões? (3) o usuário demonstra vínculo emocional em métricas de retenção? Se as três respostas forem sim, você tem um companion — e precisa tratar como tal regulatoriamente.

Considerações finais

O que está acontecendo é menos sobre “proibir IAs fofas” e mais sobre responsabilizar plataformas que tratam afeto como commodity e dados emocionais como insumo descartável. Como dev, eu encaro isso como uma oportunidade de construir melhor: sistemas com memória respeitosa, transparência real e age gate que funciona. O mercado brasileiro de IA generativa está amadurecendo, e quem construir conformidade desde o dia um vai sair na frente quando a régua apertar — e ela vai apertar.

Gostou? Me segue no GitHub e deixa um comentário se tiver dúvida ou quiser aprofundar algum ponto.