A Arqueologia Digital de Duas Décadas de Conversas

Foto por Innovalabs via Pixabay

Como desenvolvedores, nós frequentemente acumulamos gigabytes de dados pessoais sem perceber. Logs de servidores, históricos de commits, backups antigos e, o mais fascinante de tudo: históricos de conversas. Recentemente, um experimento de engenharia de dados chamou a atenção da comunidade de código aberto. O autor decidiu responder a uma pergunta existencial profunda — “Será que sou um amigo ruim?” — analisando sistematicamente 20 anos de suas próprias mensagens de chat.

Essa jornada de arqueologia digital atravessa a evolução da própria internet comercial. Estamos falando de extrair dados de plataformas mortas como ICQ e MSN Messenger, passando por Skype e Facebook Messenger, até chegar nos modernos WhatsApp e Telegram. O resultado não é apenas uma reflexão filosófica sobre relacionamentos humanos, mas um excelente estudo de caso de ETL (Extract, Transform, Load), normalização de dados heterogêneos e Processamento de Linguagem Natural (NLP).

Se você tem interesse em criar ferramentas analíticas ou quer entender como transformar dados brutos e caóticos em insights comportamentais valiosos, este guia técnico detalhado demonstrará como estruturar esse pipeline do zero.

O Desafio da Engenharia de Dados: Unificando Protocolos Heterogêneos

O primeiro e maior obstáculo em um projeto de análise histórica de 20 anos é a ingestão de dados. Cada plataforma de chat que existiu nas últimas duas décadas utilizou um formato de armazenamento proprietário ou semi-estruturado diferente:

• ICQ/MSN: Arquivos XML locais ou bancos de dados locais em formatos obscuros.
• Skype: Bancos de dados SQLite locais (geralmente no arquivo main.db).
• Facebook Messenger/Instagram: Exports em JSON ou HTML fornecidos pelas ferramentas de privacidade da Meta.
• Telegram: Exportação nativa em JSON estruturado via cliente Desktop.
• WhatsApp: Arquivos de texto plano (TXT) exportados diretamente do aplicativo móvel, altamente dependentes da localização do sistema operacional (formatos de data variados).

Para realizar qualquer análise estatística séria, precisamos definir um Schema Unificado. Cada mensagem, independentemente da plataforma de origem, deve ser mapeada para uma estrutura comum antes de ser persistida em nosso data lake local.

Definindo o Schema Unificado em Python

Abaixo, apresentamos uma implementação de referência usando Python e Pydantic para garantir a tipagem e a validação dos dados durante a fase de ingestão:

from pydantic import BaseModel, Field
from datetime import datetime
from typing import Optional

class UnifiedMessage(BaseModel):
    platform: str = Field(..., description="A plataforma de origem: 'msn', 'skype', 'whatsapp', etc.")
    timestamp: datetime = Field(..., description="Timestamp normalizado em UTC")
    sender: str = Field(..., description="Identificador único do remetente")
    recipient: str = Field(..., description="Identificador único do destinatário ou grupo")
    message_text: Optional[str] = Field(None, description="O conteúdo textual da mensagem")
    char_count: int = Field(0, description="Quantidade de caracteres na mensagem")
    word_count: int = Field(0, description="Quantidade de palavras na mensagem")
    is_group_chat: bool = Field(default=False, description="Flag indicando se é um chat em grupo")

# Exemplo de normalização de uma linha de log do WhatsApp
def parse_whatsapp_line(line: str, platform: str = "whatsapp") -> Optional[UnifiedMessage]:
    # Exemplo de linha: "[12/10/2014 14:32:10] John Doe: Olá, tudo bem?"
    try:
        if not line.startswith("["):
            return None
        end_timestamp = line.find("]")
        ts_str = line[1:end_timestamp]
        
        rest = line[end_timestamp + 2:]
        sender_end = rest.find(":")
        sender = rest[:sender_end].strip()
        message_text = rest[sender_end + 1:].strip()
        
        timestamp = datetime.strptime(ts_str, "%d/%m/%Y %H:%M:%S")
        
        return UnifiedMessage(
            platform=platform,
            timestamp=timestamp,
            sender=sender,
            recipient="me",  # Simplificado para o escopo do parser
            message_text=message_text,
            char_count=len(message_text),
            word_count=len(message_text.split()),
            is_group_chat=False
        )
    except Exception as e:
        # Ignora linhas malformadas ou mídias omitidas
        return None

Métricas de Amizade: O que os Dados Revelam sobre Nós?

Foto por Pexels via Pixabay

Uma vez que os dados estejam limpos e normalizados em um DataFrame do Pandas ou em um banco de dados SQLite, podemos começar a extrair as métricas comportamentais. Para responder à pergunta se somos ou não bons amigos, precisamos analisar indicadores quantitativos de reciprocidade e engajamento.

As principais métricas de engajamento social digital incluem:

1. Taxa de Iniciação (Initiation Rate): Quem inicia a conversa após um período de silêncio (ex: mais de 24 horas de inatividade)?
2. Latência de Resposta (Response Latency): Quanto tempo, em média, cada participante leva para responder a uma mensagem recebida?
3. Proporção de Volume (Volume Ratio): Quem envia mais caracteres ou palavras no total?
4. Double Texting: Com que frequência uma pessoa envia múltiplas mensagens consecutivas sem obter resposta?

Script de Análise de Latência e Iniciação

O script a seguir demonstra como calcular a latência de resposta e identificar quem iniciou cada sessão de conversa usando Pandas:

import pandas as pd
import numpy as np

def analyze_conversation_flow(df: pd.DataFrame, session_threshold_hours: int = 24) -> pd.DataFrame:
    # Garante que os dados estão ordenados cronologicamente
    df = df.sort_values(by="timestamp").copy()
    
    # Calcula a diferença de tempo entre mensagens consecutivas
    df["time_diff"] = df["timestamp"].diff()
    
    # Define uma nova sessão de conversa se o tempo sem mensagens for maior que o threshold
    df["new_session"] = (df["time_diff"] > pd.Timedelta(hours=session_threshold_hours)) | df["time_diff"].isna()
    df["session_id"] = df["new_session"].cumsum()
    
    # Identifica o iniciador de cada sessão
    session_initiators = df.groupby("session_id").first()["sender"].rename("session_initiator")
    df = df.join(session_initiators, on="session_id")
    
    # Calcula a latência de resposta (tempo decorrido quando o remetente muda)
    df["sender_changed"] = df["sender"] != df["sender"].shift(1)
    df["response_latency"] = np.where(
        df["sender_changed"] & ~df["new_session"],
        df["time_diff"].dt.total_seconds(),
        np.nan
    )
    
    return df

Ao rodar esse tipo de análise em um dataset de 20 anos, padrões fascinantes emergem. É comum descobrir que, na juventude (época de MSN e ICQ), nossa latência de resposta era medida em segundos ou minutos. Com o envelhecimento e a transição para plataformas assíncronas como o WhatsApp, a latência média sobe para horas, refletindo as demandas da vida adulta e profissional.

Processamento de Linguagem Natural (NLP) e Análise de Sentimento

Métricas quantitativas contam apenas metade da história. Para entender a qualidade de uma amizade, precisamos analisar o tom emocional das interações. É aqui que entra o Processamento de Linguagem Natural (NLP).

Utilizando bibliotecas modernas de IA, podemos extrair o sentimento predominante das mensagens ao longo do tempo. Isso nos permite mapear se as conversas com determinados amigos tornaram-se mais negativas, neutras ou positivas ao longo dos anos, e se nós mesmos fomos agentes de suporte emocional ou de toxicidade.

Para o português e outros idiomas latinos, modelos baseados em BERT (como os disponíveis no Hugging Face) oferecem excelente precisão para análise de sentimentos e detecção de emoções.

Implementando Análise de Sentimento com Transformers

from transformers import pipeline

def analyze_sentiment_batch(messages: list[str]) -> list[dict]:
    # Carrega um pipeline de análise de sentimento otimizado para múltiplos idiomas ou português
    classifier = pipeline(
        "sentiment-analysis",
        model="nlptown/bert-base-multilingual-uncased-sentiment"
    )
    
    # O modelo retorna classificações de 1 a 5 estrelas
    results = classifier(messages)
    return results

Com esses dados estruturados, você pode plotar gráficos de linha temporal mostrando a evolução do sentimento médio por ano para cada um de seus contatos mais frequentes. Quedas abruptas no sentimento podem correlacionar-se com períodos de crise pessoal, enquanto picos positivos marcam momentos de celebração mútua.

Oportunidades de Micro-SaaS: Monetizando a Nostalgia e a Autoanálise

Para desenvolvedores focados em criar produtos independentes, este experimento revela um nicho de mercado inexplorado e altamente lucrativo: o Personal Analytics de Privacidade Centrada. As pessoas são inerentemente curiosas sobre si mesmas e suas relações históricas, mas têm extremo receio de enviar seus históricos de chat privados para servidores de terceiros.

Existe um espaço claro para o desenvolvimento de ferramentas de Automações e Micro-SaaS que rodem localmente (utilizando WebAssembly ou Electron) ou que garantam criptografia ponta a ponta com processamento local via modelos de linguagem de código aberto (como Llama 3 ou Mistral rodando via Ollama).

Abaixo, estruturamos uma análise de viabilidade de mercado para um Micro-SaaS focado em análise histórica de chats:

Funcionalidade Core	Stack Tecnológica Recomendada	Estratégia de Monetização	Diferencial Competitivo
Parser Universal Local (Drag & Drop de exports do WhatsApp/Telegram)	React + WebAssembly (Rust/Python compilado)	Freemium (Relatório básico gratuito)	Zero vazamento de dados (100% client-side)
Dashboard de Métricas de Relacionamento (Latência, Iniciação, Gráficos de Rede)	TailwindCSS + Tremor / Chart.js	Licença Única (Pay-once-use-forever)	Visualizações interativas e exportáveis para redes sociais
Análise de Sentimento e Resumos de IA (Ollama / Local LLM integration)	Ollama API local ou Transformers.js no browser	Plano Premium (Geração de livro digital em PDF da amizade)	Insights profundos sem expor dados a APIs de terceiros

Conclusão: O que os Dados Não Conseguem Mensurar

Ao final de um projeto de análise de dados tão pessoal, a maior lição para um engenheiro de software é entender os limites da própria tecnologia. Os dados brutos podem nos dizer quem demorou mais para responder ou quem enviou mais caracteres, mas eles são incapazes de capturar o contexto da vida real. Uma resposta rápida de uma palavra pode ser mais valiosa do que um parágrafo longo e vazio de significado.

A análise de dados históricos serve como um espelho técnico do nosso comportamento digital, mas a verdadeira amizade reside na empatia e na presença contínua — fatores que nenhum algoritmo de NLP ou banco de dados relacional conseguirá quantificar perfeitamente.

As informações originais e as reflexões existenciais completas sobre este experimento de duas décadas de dados pessoais foram detalhadas no excelente Artigo de Origem escrito por Dmitry Robinin. Se você deseja construir suas próprias ferramentas de análise ou explorar o mercado de automação de dados pessoais, comece estruturando seus próprios parsers locais e explorando a riqueza histórica oculta em seus backups.