Sistemas de recomendação baseados em IA

Você já se viu olhando para uma planilha gigantesca, cheia de itens, clientes ou tarefas, e pensando: "Qual é o próximo passo mais inteligente aqui? O que deveria ser recomendado a quem?" Eu me pego nessa situação com uma frequência que chega a ser irritante. Não é sobre ter a informação, é sobre transformar aquela montanha de dados em algo acionável, relevante e, acima de tudo, útil para alguém. Foi exatamente assim que comecei a fuçar de verdade em sistemas de recomendação baseados em IA. Não por luxo, mas por pura necessidade de resolver um problema chato e repetitivo.

Meu dia a dia é isso: Sheets pra lá, Apps Script pra cá, Python rodando uns malabarismos com APIs. A ideia nunca foi montar um super sistema da Netflix, mas sim tirar uma dor de cabeça que estava me custando tempo e entregando recomendações "meia-boca" que ninguém usava. Por isso, a história que vou contar aqui é de quem precisou fazer a coisa funcionar, com os pés no chão e, muitas vezes, com a faca nos dentes contra limites de API e dados bagunçados.

O Que Diabos É um Sistema de Recomendação (e Por Que Eu Precisei de Um)

Em termos práticos, um sistema de recomendação é um jeito inteligente de ajudar alguém a encontrar o que precisa ou o que pode gostar, sem que essa pessoa precise procurar ativamente. Pense na Amazon te mostrando produtos, no YouTube sugerindo vídeos, ou até mesmo no LinkedIn indicando pessoas para você conectar. A IA aqui é o motor que entende padrões e faz essas sugestões parecerem quase mágicas.

Eu, por exemplo, tinha um problema interno. Tínhamos um acervo crescente de documentos técnicos, artigos de base de conhecimento e até tutoriais de automação. Muita coisa boa, mas quem precisava achar algo específico? Era um pesadelo. A busca interna era ruim, e as pessoas acabavam não encontrando o que precisavam, ou perdiam um tempão perguntando a alguém. Aquilo me irritava. Pensei: "Puts, se eu pudesse recomendar o documento certo para o usuário certo, baseado no que ele já leu, no que ele pesquisou ou no que ele está trabalhando, a vida de todo mundo seria mais fácil." Isso, meu amigo, é o berço de um sistema de recomendação. Não é luxo, é otimização do tempo.

As Duas Caras da Moeda: Conteúdo vs. Colaboração (e Onde a IA Acelera)

No começo, a gente tenta resolver as coisas no braço ou com umas regrinhas simples. "Se o usuário leu sobre Python, mostra mais coisas de Python." Isso é a base do que chamamos de recomendação baseada em conteúdo. Mas e quando o usuário não leu nada? Ou quando o documento tem um título genérico? Aí a coisa complica. A IA entra para dar um "up" nisso.

Recomendação Baseada em Conteúdo: Pegando no "DNA" do Item

A ideia aqui é entender o "DNA" de cada item (o documento, o produto, a tarefa) e o "DNA" do usuário. Se o usuário gosta de coisas com DNA X, Y e Z, você recomenda itens com DNA parecido. O desafio é: como você extrai esse "DNA" de forma eficiente e precisa?

• O Jeito Antigo (ou Nem Tanto): Eu começava lendo o título, a descrição, talvez umas tags. Se fosse um documento, lia o resumo. Isso era feito manualmente ou com algumas regras simples de extração de palavras-chave em Python. Era ok, mas limitado. Se o documento era longo, eu tinha que resumir na mão ou torcer para as tags estarem boas. Uma chatice.
• A Virada com IA (LLMs): Aqui a coisa ficou interessante. Em vez de eu mesmo tentar entender o documento, eu comecei a usar LLMs (Large Language Models) via API. Pego o texto do documento e mando para a API com um prompt tipo: "Gere 5 palavras-chave principais e um resumo conciso sobre este documento, focando em tópicos técnicos e área de aplicação." Ou: "Extraia entidades-chave como linguagens de programação, ferramentas e conceitos técnicos deste texto."

O resultado? Um perfil muito mais rico para cada documento. Armazenava isso numa aba do Google Sheets: uma coluna para o título, outra para o URL, outra para o resumo gerado pela IA, e outra para as palavras-chave. Com Apps Script, eu conseguia pegar esses dados do Sheet, chamar minha função Python que interagia com a API do LLM, e depois jogar as features geradas de volta no Sheet. Era tipo uma máquina de café, mas para transformar texto em dados estruturados. Isso me poupava horas e era muito mais consistente do que eu fazendo na mão.

Para o usuário, a mesma coisa. Pego o histórico de documentos que ele leu, as pesquisas que ele fez, e com a mesma técnica de LLM, crio um "perfil de interesse" para ele. Depois, é só comparar o perfil do usuário com o perfil dos documentos. Eu usava algo simples como a similaridade de cosseno entre vetores de embeddings gerados pelos LLMs (sim, LLMs também geram embeddings que representam o significado do texto, o que facilita muito a comparação). Tudo isso rodando em um script Python que eu acionava via Apps Script ou um webhook.

Filtragem Colaborativa: "Quem Gosta Disso, Gosta Daquilo"

Essa é a parte que a gente tenta inferir as preferências de um usuário com base nas preferências de usuários "parecidos" com ele. Se eu e você gostamos de 90% das mesmas coisas, é bem provável que você goste daquele décimo item que eu gostei e você ainda não viu. Não tem nada a ver com o conteúdo do item em si, mas com o comportamento dos usuários.

• O Jeito Quebra-Galho (Manual/Regras): No começo, eu tentava fazer umas matrizes de usuário-item no Google Sheets, marcando o que cada um leu. Depois, tentava encontrar usuários com padrões de leitura semelhantes na base de dados. Era doloroso e escalava muito mal. Se tivesse 20 usuários e 100 documentos, já virava uma bagunça de fórmulas VLOOKUP e INDEX/MATCH que travava a planilha.
• A Solução com Python e IA: Eu pegava os dados de interação (usuário X leu documento Y) de uma aba no Sheets, jogava para o Python. Lá, eu usava bibliotecas como o Surprise (para quem não quer reinventar a roda) ou até implementava uma decomposição de valores singulares (SVD) na mão, usando NumPy. Basicamente, o algoritmo aprende a encontrar esses "vizinhos" de preferência e sugere o que eles gostaram.

O Apps Script entrava aqui para coletar os dados de interação do Sheets, passava para um script Python que rodava em algum lugar (muitas vezes em um servidor local, ou em uma Cloud Function que eu chamava via API). O Python processava, gerava as recomendações e devolvia os resultados para uma aba de "Recomendações Personalizadas" no Sheets. Essa aba era então usada para alimentar um pequeno widget ou uma lista de e-mails diários via Apps Script, dizendo: "Olá, aqui estão 5 documentos que você pode gostar!"

A IA Entra em Campo: Tirando a Recomendação do Básico

Onde a IA realmente brilha é quando o sistema precisa ser mais inteligente que regras estáticas ou simples correlações. Isso acontece principalmente com o problema do cold start (como recomendar algo para um usuário novo ou um item recém-adicionado sem histórico de interações) e para explicar as recomendações.

Processando Textos e Preferências com LLMs

Uma das maiores dores de cabeça é quando chega um documento novo ou um usuário que nunca interagiu com nada. O sistema colaborativo não funciona. O baseado em conteúdo precisa de um bom perfil. LLMs mudaram meu jogo aqui.

Para Novos Itens: Se um novo documento chega, eu o processo com um LLM para extrair suas características. Posso pedir para o LLM não só resumir e pegar palavras-chave, mas também para categorizar o documento em categorias pré-definidas ou até sugerir tags. Isso cria um perfil rico instantaneamente, que posso usar para comparar com perfis de usuários existentes, mesmo que ninguém tenha lido o documento ainda.

Para Novos Usuários: Um usuário novo não tem histórico. Mas ele tem um cargo, um departamento, talvez ele preencha um pequeno questionário de interesse. Eu pego essa informação textual e jogo para o LLM: "Com base neste cargo e departamento, quais seriam os 5 principais tópicos de interesse técnico para este usuário?" O LLM me dá um perfil inicial que posso usar para as primeiras recomendações, antes mesmo de ele interagir com qualquer coisa. Não é perfeito, mas é infinitamente melhor do que nada. É um "chute" inteligente.

A beleza é que o Apps Script pega os dados de entrada (o novo documento ou o perfil do novo usuário no Sheets), manda via Python para a API do LLM, e os resultados são jogados de volta no Sheets, atualizando o dataset em tempo real para o meu sistema de recomendação. Isso transforma o "cold start" de um bloqueio em apenas um pequeno atraso.

Colocando a Mão na Massa: Um Exemplo Prático (e Sujo)

Vamos pegar o exemplo dos documentos internos. Basicamente, como eu montei isso:

Coleta de Dados (Onde a Magia Começa)

Eu tinha duas fontes principais de dados, ambas gerenciadas no Google Sheets:

1. Aba 'Documentos': Continha o ID do documento, Título, URL, Autor, Data e o texto completo do documento (ou um link para ele). Essa era a "prateleira" dos itens.
2. Aba 'Interações_Usuários': Registrava quem (ID do Usuário) leu qual documento (ID do Documento) e quando. Essa aba era atualizada via Apps Script cada vez que alguém clicava num link ou visualizava um documento.

A parte "suja" era garantir que os IDs de usuário fossem consistentes e que o registro de leitura realmente funcionasse. Várias vezes, o Apps Script falhava silenciosamente por um tempo e eu só percebia quando as recomendações começavam a ficar esquisitas. Aprendi a colocar log e monitoramento.

Pré-processamento e Geração de Features (A Chata Mas Necessária)

Aqui, Python + LLMs são os heróis. Eu tinha um script Python que rodava periodicamente:

• Ele lia a aba 'Documentos' do Google Sheets usando a biblioteca gspread.
• Para cada documento, se ele não tivesse um resumo e tags já processados, eu pegava o texto.
• Enviava o texto para a API de um LLM (usava OpenAI ou Gemini, dependendo do custo/performance da época) com prompts específicos para gerar resumo, palavras-chave e talvez até uma categoria.
• Recebia a resposta do LLM, formatava e atualizava as colunas correspondentes na aba 'Documentos' no Sheets. Isso enriquecia cada item com metadados gerados por IA.
• Também usava o LLM para gerar embeddings para o texto completo do documento. Essas são representações numéricas que capturam o significado do texto, facilitando a comparação. Uma coluna 'Embedding' no Sheets para cada documento (sim, uma célula com um array gigante de números) ou armazenado em um banco de dados vetorial se o volume crescesse.

Essa etapa era a mais custosa (em termos de chamadas de API) e a que mais dava erro. Limits de tokens, timeouts, formato de resposta inesperado... Cada um desses me fazia rever o código e os prompts. Aprendi a tratar exceções de forma robusta.

O Modelo de Recomendação (Onde a IA Age)

Depois de ter os dados processados e enriquecidos, o mesmo script Python (ou outro separado, disparado na sequência) fazia as recomendações:

• Para a Filtragem Colaborativa: Eu usava os dados da aba 'Interações_Usuários' para criar uma matriz usuário-item. Rodava um algoritmo simples de fatoração de matriz (tipo SVD) para prever as notas (preferências) que um usuário daria para documentos que ele ainda não viu. Isso me dava uma lista de documentos mais prováveis de serem do interesse do usuário, puramente baseado no comportamento de outros.
• Para a Recomendação Baseada em Conteúdo (e Cold Start): Se o usuário era novo ou se a colaborativa não tinha dados suficientes, eu usava os embeddings que o LLM gerou. Comparava o embedding do perfil do usuário (construído a partir de suas pesquisas recentes, cargo, etc.) com os embeddings dos documentos. Os documentos com os embeddings mais "próximos" (maior similaridade de cosseno) eram os recomendados.

Eu combinei os dois métodos: dava um peso maior para a colaborativa quando havia dados, e mais para a baseada em conteúdo/embeddings quando os dados eram escassos. Isso era feito com umas linhas de código em Python, somando as "pontuações" de cada método.

Apresentando as Recomendações (Apps Script no Frontend)

As recomendações geradas pelo Python eram salvas em uma aba chamada 'Recomendações_Ativas', com colunas como: ID_Usuário, ID_Documento_Recomendado, Score, e uma pequena 'Explicação' (gerada pelo LLM também, tipo: "Este documento foi recomendado porque outros usuários com interesses em [tópico Y] também gostaram, e seu conteúdo é similar a [documento Z] que você leu").

Um script Apps Script era então programado para:

• Disparar um e-mail diário com as 5 principais recomendações para cada usuário.
• Ou criar uma pequena interface na barra lateral do Google Sheets (com HtmlService) onde o usuário via suas recomendações personalizadas ao abrir a planilha.
• Ou até mesmo integrar isso em um sistema de notificação interno, usando um webhook.

A explicação gerada pela IA era um toque a mais que aumentava muito a confiança do usuário na recomendação. Não era só uma lista, era uma lista *com um motivo*.

É um trampo, mas no final, a economia de tempo para as pessoas e a relevância das informações que elas recebiam era impagável. E eu me livrava de ter que responder: "Onde está aquele documento sobre a API de automação de planilhas?"

Aspecto	Jeito Manual/Demorado	Jeito Automatizado (com IA, Python, Apps Script, APIs)
Criação de Perfil de Itens (Documentos/Produtos)	Leitura e resumo manual. Extração de palavras-chave no braço. Tempo gasto por item: 10-20 min.	Envio do texto para API de LLM via Python. Resumo, palavras-chave e embeddings gerados automaticamente. Tempo gasto por item: segundos (dependendo da API).
Criação de Perfil de Usuários	Análise manual do histórico de leitura/pesquisa. Entrevistas para entender interesses. Processo lento e subjetivo.	Processamento do histórico de interação, cargos, etc., com LLMs via Python para gerar um perfil de interesse. Geração de embeddings para representar o usuário.
Lógica de Recomendação	Regras simples "se-então". Dificuldade em escalar. Recomendação genérica ou muito limitada.	Algoritmos de filtragem colaborativa (SVD, KNN) em Python. Comparação de embeddings (similaridade de cosseno). Modelos híbridos.
Tratamento de Cold Start (Novos Usuários/Itens)	Nenhuma recomendação até ter histórico. Usuário/item "invisível" por um tempo.	LLMs criam perfis iniciais para itens e usuários com base em descrições textuais, mesmo sem interações.
Escalabilidade	Muito difícil. Aumentar usuários/itens significa exponencialmente mais trabalho manual/lento.	Escala bem com a infraestrutura certa (Cloud Functions, servidores Python). As chamadas de API são o gargalo, mas gerenciáveis.
Qualidade/Relevância das Recomendações	Baixa a média. Muito dependente da qualidade das regras e da atenção manual.	Alta. A IA entende nuances e padrões, gerando recomendações mais personalizadas e precisas.
Explicação das Recomendações	"Porque sim", ou uma explicação vaga.	LLMs podem gerar explicações concisas e contextuais sobre o porquê da recomendação, aumentando a confiança.
Automação e Integração	Praticamente zero. Depende de intervenção humana constante.	Google Sheets como interface, Apps Script para orquestração/UI, Python para lógica pesada, APIs para LLMs e dados. Fluxo automatizado de ponta a ponta.

O Que Dá Errado (e Como Tentar Não Surpreender)

Ah, meu amigo, essa é a parte que a gente aprende. Sistemas de recomendação, especialmente os que usam IA e dependem de várias integrações, são como crianças: exigem atenção constante e vivem te dando sustos.

1. A Qualidade dos Dados é Tudo (e é Rara): Parece óbvio, mas não é. Se o seu Google Sheet com os documentos tem textos mal formatados, incompletos ou tags inconsistentes, o LLM vai ter dificuldade de gerar perfis bons. E se o registro de interações (quem leu o quê) falha por um dia, suas recomendações colaborativas ficam com um "buraco". Passei horas depurando scripts de coleta de dados que davam problema sem eu perceber, até as recomendações começarem a ficar sem sentido. A limpeza e validação de dados é 80% do trabalho, e 100% da dor de cabeça.
2. Custos de API Inesperados: Quando você começa a usar LLMs para gerar embeddings, resumos e tags para milhares de itens, as chamadas de API viram uma bola de neve. Já tive "surpresas" na fatura porque esqueci de otimizar a frequência de atualização ou porque um loop infinito consumiu créditos em algumas horas. Sempre fique de olho nos limites e crie mecanismos de cache para não processar a mesma coisa várias vezes.
3. O Problema do "Filtro Bolha": Recomendações são boas, mas se você só recomendar o que o usuário já gosta, ele nunca vai descobrir nada novo. O sistema fica previsível. Eu tentei resolver isso injetando um pouco de aleatoriedade nas recomendações ou dando um "boost" em itens menos populares, mas ainda relevantes. Balancear a "exploração" com a "explotação" é um desafio constante.
4. "Explicações" da IA que Não Fazem Sentido: Às vezes, o LLM gerava uma explicação de recomendação que era totalmente sem nexo. Ou a recomendação era boa, mas a explicação era ruim. Isso mina a confiança do usuário. Descobri que refinar os prompts para a geração de explicações era fundamental. Às vezes, eu pedia: "Explique esta recomendação em uma frase curta, usando apenas o título e duas palavras-chave do documento, e o tópico de interesse do usuário." Menos é mais aqui.
5. Latência e Limites de API: Rodar um script Python que chama um LLM, processa dados e volta pro Sheets pode ser lento. Se você tem muitos usuários e precisa de recomendações "quase em tempo real", isso pode ser um gargalo. Já tive problemas com limites de taxa (rate limits) de APIs, que me forçaram a implementar exponential backoff e filas de processamento. Parece simples, mas na prática é um inferno de tratar.
6. A Expectativa Vs. A Realidade do Usuário: Por mais que você explique, as pessoas esperam que a IA seja mágica. Se o sistema erra algumas vezes, a confiança despenca. É importante gerenciar as expectativas e, se possível, permitir que o usuário dê feedback direto sobre a recomendação ("Gostei", "Não Gostei") para que o modelo possa aprender. Essa é uma das partes mais difíceis de implementar de forma simples e útil para o feedback ser capturado e usado.

FAQ Técnico e Pragmático

Algumas perguntas que me fazem ou que eu mesmo já me fiz na hora de montar essas coisas:

1. Como eu armazeno os embeddings gerados por LLMs de forma eficiente no Google Sheets?

Olha, no Sheets, é meio gambiarra. Você pode ter uma coluna para cada dimensão do embedding (se for 1536 dimensões, são 1536 colunas, o que é inviável), ou colocar o vetor inteiro como uma string JSON em uma única célula. Para pouca coisa (centenas de itens), funciona. Mas o ideal é mandar esses embeddings para um banco de dados vetorial (tipo Pinecone, Weaviate ou até o pgvector no PostgreSQL) e usar o ID do item no Sheet para consultar o embedding lá. Se o volume é baixo e a performance não é crítica, a string JSON funciona, mas não é o ideal para fazer buscas de similaridade no Sheet.

2. É viável rodar um modelo de recomendação complexo (tipo deep learning) só com Apps Script e Google Sheets?

Não, nem a pau. Apps Script e Google Sheets não foram feitos para isso. O Apps Script é ótimo para automação e integração leves, manipulação de dados em Sheets, e pequenas interfaces. Mas para a lógica pesada de um modelo de recomendação (treinamento, inferência de grandes datasets, cálculos de similaridade complexos), você precisa do Python, seja rodando localmente, em um servidor na nuvem (Cloud Functions, EC2) ou até mesmo usando serviços de ML (como Vertex AI ou SageMaker). O Apps Script seria a ponte, o "cérebro" para disparar essas operações e mover os dados, mas não o "músculo" computacional.

3. Como faço para o sistema de recomendação aprender com o feedback do usuário (tipo "gostei/não gostei")?

Isso é crucial! Você precisa de um mecanismo para coletar esse feedback. No meu caso, eu adicionava botões "Gostei" / "Não Gostei" nas recomendações exibidas via Apps Script (HtmlService). Quando o usuário clicava, um Apps Script gravava essa interação (Usuário X, Documento Y, Feedback Positivo/Negativo) em uma aba 'Feedback' no Sheets. Meu script Python de recomendação lia essa aba e usava esses dados para retreinar o modelo periodicamente (por exemplo, uma vez por dia ou por semana). Esse retreinamento ajusta os pesos do modelo para que ele aprenda com os acertos e erros passados, tornando as futuras recomendações mais precisas. É um ciclo contínuo de dados -> modelo -> recomendação -> feedback -> dados.

Conclusão

Construir um sistema de recomendação baseado em IA no dia a dia, com as ferramentas que a gente tem (Google Sheets, Apps Script, Python e APIs), não é glamoroso. É um monte de integração chata, depuração de erros em APIs, otimização de prompts e, principalmente, lidar com dados que nunca estão perfeitos. Mas no final das contas, quando você vê o pessoal usando e achando valor nas recomendações, a sensação de que você resolveu um problema real compensa todo o perrengue.

Não espere criar o próximo algoritmo da Netflix do dia para a noite. Comece pequeno, resolva uma dor de cabeça específica, use a IA como uma ferramenta para potencializar o que você já faz. E esteja preparado para ajustar, quebrar e refazer muitas vezes. É assim que a gente aprende e entrega coisas que realmente funcionam.