Habilidade de Pesquisa de Vendas: Metodologia de Pesquisa de Prospects

--- name: sales-research description: Esta habilidade fornece metodologia e melhores práticas para pesquisar prospects de vendas. --- # Pesquisa de Vendas ## Visão Geral Esta habilidade fornece metodologia e melhores práticas para pesquisar prospects de vendas. Ela cobre pesquisa de empresas, criação de perfis de contatos e detecção de sinais para gerar inteligência acionável. ## Uso Os sub-agentes company-researcher e contact-researcher referenciam esta habilidade quando: - Pesquisando novos prospects - Encontrando informações sobre empresas - Criando perfis de contatos individuais - Detectando sinais de compra ## Metodologia de Pesquisa ### Checklist de Pesquisa de Empresa 1. **Perfil Básico** - Nome da empresa, setor, porte (funcionários, receita) - Sede e principais localizações - Data de fundação, estágio de crescimento 2. **Desenvolvimentos Recentes** - Anúncios de financiamento (últimos 12 meses) - Atividade de fusões e aquisições - Mudanças de liderança - Lançamentos de produtos 3. **Stack de Tecnologia** - Tecnologias conhecidas (BuiltWith, StackShare) - Vagas de emprego mencionando ferramentas - Parcerias de integração 4. **Sinais** - Vagas de emprego (expansão = oportunidade) - Avaliações no Glassdoor (pontos de dor) - Menções na imprensa (contexto) - Atividade em redes sociais ### Checklist de Pesquisa de Contato 1. **Histórico Profissional** - Cargo atual e tempo no cargo - Empresas e cargos anteriores - Educação 2. **Indicadores de Influência** - Estrutura hierárquica - Autoridade de decisão - Responsabilidade sobre orçamento 3. **Ganchos de Engajamento** - Posts recentes no LinkedIn - Artigos publicados - Participações em eventos - Conexões em comum ## Recursos - `resources/signal-indicators.md` - Taxonomia de sinais de compra - `resources/research-checklist.md` - Checklist completo de pesquisa ## Scripts - `scripts/company-enricher.py` - Agrega dados de empresas de múltiplas fontes - `scripts/linkedin-parser.py` - Estrutura dados de perfil do LinkedIn FILE:company-enricher.py #!/usr/bin/env python3 """ company-enricher.py - Agrega dados de empresas de múltiplas fontes Entradas: - company_name: string - domain: string (opcional) Saídas: - profile: name: string industry: string size: string funding: string tech_stack: [string] recent_news: [itens de notícias] Dependências: - requests, beautifulsoup4 """ # Requisitos: requests, beautifulsoup4 import json from typing import Any from dataclasses import dataclass, asdict from datetime import datetime @dataclass class NewsItem: title: str date: str source: str url: str summary: str @dataclass class CompanyProfile: name: str domain: str industry: str size: str location: str founded: str funding: str tech_stack: list[str] recent_news: list[dict] competitors: list[str] description: str def search_company_info(company_name: str, domain: str = None) -> dict: """ Busca informações básicas da empresa. Em produção, isso chamaria APIs como Clearbit, Crunchbase, etc. """ # TODO: Implementar chamadas reais de API # Estrutura de retorno provisória return { "name": company_name, "domain": domain or f"{company_name.lower().replace(' ', '')}.com", "industry": "Tecnologia", # Viria da API "size": "Desconhecido", "location": "Desconhecido", "founded": "Desconhecido", "description": f"Informações sobre {company_name}" } def search_funding_info(company_name: str) -> dict: """ Busca informações de financiamento. Em produção, chamaria Crunchbase, PitchBook, etc. """ # TODO: Implementar chamadas reais de API return { "total_funding": "Desconhecido", "last_round": "Desconhecido", "last_round_date": "Desconhecido", "investors": [] } def search_tech_stack(domain: str) -> list[str]: """ Detecta stack de tecnologia. Em produção, chamaria BuiltWith, Wappalyzer, etc. """ # TODO: Implementar chamadas reais de API return [] def search_recent_news(company_name: str, days: int = 90) -> list[dict]: """ Busca notícias recentes sobre a empresa. Em produção, chamaria APIs de notícias. """ # TODO: Implementar chamadas reais de API return [] def main( company_name: str, domain: str = None ) -> dict[str, Any]: """ Agrega dados de empresas de múltiplas fontes. Args: company_name: Nome da empresa a pesquisar domain: Domínio da empresa (opcional, será inferido) Returns: dict com perfil da empresa incluindo setor, porte, financiamento, stack de tecnologia, notícias """ # Obter informações básicas da empresa basic_info = search_company_info(company_name, domain) # Obter informações de financiamento funding_info = search_funding_info(company_name) # Detectar stack de tecnologia company_domain = basic_info.get("domain", domain) tech_stack = search_tech_stack(company_domain) if company_domain else [] # Obter notícias recentes news = search_recent_news(company_name) # Compilar perfil profile = CompanyProfile( name=basic_info["name"], domain=basic_info["domain"], industry=basic_info["industry"], size=basic_info["size"], location=basic_info["location"], founded=basic_info["founded"], funding=funding_info.get("total_funding", "Desconhecido"), tech_stack=tech_stack, recent_news=news, competitors=[], # Seria enriquecido com análise do setor description=basic_info["description"] ) return { "profile": asdict(profile), "funding_details": funding_info, "enriched_at": datetime.now().isoformat(), "sources_checked": ["company_info", "funding", "tech_stack", "news"] } if __name__ == "__main__": import sys # Exemplo de uso result = main( company_name="DataFlow Systems", domain="dataflow.io" ) print(json.dumps(result, indent=2)) FILE:linkedin-parser.py #!/usr/bin/env python3 """ linkedin-parser.py - Estrutura dados de perfil do LinkedIn Entradas: - profile_url: string - ou nome + empresa: strings Saídas: - contact: name: string title: string tenure: string previous_roles: [objetos de cargo] mutual_connections: [string] recent_activity: [resumos de posts] Dependências: - requests """ # Requisitos: requests import json from typing import Any from dataclasses import dataclass, asdict from datetime import datetime @dataclass class PreviousRole: title: str company: str duration: str description: str @dataclass class RecentPost: date: str content_preview: str engagement: int topic: str @dataclass class ContactProfile: name: str title: str company: str location: str tenure: str previous_roles: list[dict] education: list[str] mutual_connections: list[str] recent_activity: list[dict] profile_url: str headline: str def search_linkedin_profile(name: str = None, company: str = None, profile_url: str = None) -> dict: """ Busca informações de perfil no LinkedIn. Em produção, usaria a API do LinkedIn ou Sales Navigator. """ # TODO: Implementar integração real com a API do LinkedIn # Nota: A API do LinkedIn tem termos de serviço estritos return { "found": False, "name": name or "Desconhecido", "title": "Desconhecido", "company": company or "Desconhecido", "location": "Desconhecido", "headline": "", "tenure": "Desconhecido", "profile_url": profile_url or "" } def get_career_history(profile_data: dict) -> list[dict]: """ Extrai histórico de carreira do perfil. """ # TODO: Implementar extração de carreira return [] def get_mutual_connections(profile_data: dict, user_network: list = None) -> list[str]: """ Encontra conexões em comum. """ # TODO: Implementar detecção de conexões em comum return [] def get_recent_activity(profile_data: dict, days: int = 30) -> list[dict]: """ Obtém posts e atividades recentes. """ # TODO: Implementar extração de atividade return [] def main( name: str = None, company: str = None, profile_url: str = None ) -> dict[str, Any]: """ Estrutura dados de perfil do LinkedIn para preparação de vendas. Args: name: Nome da pessoa company: Empresa onde trabalha profile_url: URL direta do perfil no LinkedIn Returns: dict com perfil de contato estruturado """ if not profile_url and not (name and company): return {"error": "Forneça profile_url ou nome + empresa"} # Buscar perfil profile_data = search_linkedin_profile( name=name, company=company, profile_url=profile_url ) if not profile_data.get("found"): return { "found": False, "name": name or "Desconhecido", "company": company or "Desconhecido", "message": "Perfil não encontrado ou acesso limitado", "suggestions": [ "Tente buscar diretamente no LinkedIn", "Verifique grafias alternativas", "Confirme se a pessoa ainda trabalha nesta empresa" ] } # Obter histórico de carreira previous_roles = get_career_history(profile_data) # Encontrar conexões em comum mutual_connections = get_mutual_connections(profile_data) # Obter atividade recente recent_activity = get_recent_activity(profile_data) # Compilar perfil de contato contact = ContactProfile( name=profile_data["name"], title=profile_data["title"], company=profile_data["company"], location=profile_data["location"], tenure=profile_data["tenure"], previous_roles=previous_roles, education=[], # Seria extraído do perfil mutual_connections=mutual_connections, recent_activity=recent_activity, profile_url=profile_data["profile_url"], headline=profile_data["headline"] ) return { "found": True, "contact": asdict(contact), "research_date": datetime.now().isoformat(), "data_completeness": calculate_completeness(contact) } def calculate_completeness(contact: ContactProfile) -> dict: """Calcula o quão completo estão os dados do perfil.""" fields = { "basic_info": bool(contact.name and contact.title and contact.company), "career_history": len(contact.previous_roles) > 0, "mutual_connections": len(contact.mutual_connections) > 0, "recent_activity": len(contact.recent_activity) > 0, "education": len(contact.education) > 0 } complete_count = sum(fields.values()) return { "fields": fields, "score": f"{complete_count}/{len(fields)}", "percentage": int((complete_count / len(fields)) * 100) } if __name__ == "__main__": import sys # Exemplo de uso result = main( name="Sarah Chen", company="DataFlow Systems" ) print(json.dumps(result, indent=2)) FILE:priority-scorer.py #!/usr/bin/env python3 """ priority-scorer.py - Calcula e classifica prioridades de prospects Entradas: - prospects: [objetos de prospect com sinais] - weights: {deal_size, timing, warmth, signals} Saídas: - ranked: [prospects com pontuações e justificativas] Dependências: - (nenhuma - Python puro) """ import json from typing import Any from dataclasses import dataclass # Pesos padrão de pontuação DEFAULT_WEIGHTS = { "deal_size": 0.25, "timing": 0.30, "warmth": 0.20, "signals": 0.25 } # Mapeamento de pontuação de sinais SIGNAL_SCORES = { # Sinais de alta intenção "recent_funding": 10, "leadership_change": 8, "job_postings_relevant": 9, "expansion_news": 7, "competitor_mention": 6, # Sinais de média intenção "general_hiring": 4, "industry_event": 3, "content_engagement": 3, # Sinais de relacionamento "mutual_connection": 5, "previous_contact": 6, "referred_lead": 8, # Sinais negativos "recent_layoffs": -3, "budget_freeze_mentioned": -5, "competitor_selected": -7, } @dataclass class ScoredProspect: company: str contact: str call_time: str raw_score: float normalized_score: int priority_rank: int score_breakdown: dict reasoning: str is_followup: bool def score_deal_size(prospect: dict) -> tuple[float, str]: """Pontua com base no tamanho estimado do negócio.""" size_indicators = prospect.get("size_indicators", {}) employee_count = size_indicators.get("employees", 0) revenue_estimate = size_indicators.get("revenue", 0) # Pontuação simples baseada no porte da empresa if employee_count > 1000 or revenue_estimate > 100_000_000: return 10.0, "Oportunidade de nível enterprise" elif employee_count > 200 or revenue_estimate > 20_000_000: return 7.0, "Oportunidade de mid-market" elif employee_count > 50: return 5.0, "Oportunidade de SMB" else: return 3.0, "Pequena empresa" def score_timing(prospect: dict) -> tuple[float, str]: """Pontua com base em sinais de timing.""" timing_signals = prospect.get("timing_signals", []) score = 5.0 # Pontuação base reasons = [] for signal in timing_signals: if signal == "budget_cycle_q4": score += 3 reasons.append("Planejamento orçamentário do Q4") elif signal == "contract_expiring": score += 4 reasons.append("Contrato expirando em breve") elif signal == "active_evaluation": score += 5 reasons.append("Avaliando ativamente") elif signal == "just_funded": score += 3 reasons.append("Financiamento recente") return min(score, 10.0), "; ".join(reasons) if reasons else "Timing padrão" def score_warmth(prospect: dict) -> tuple[float, str]: """Pontua com base no calor do relacionamento.""" relationship = prospect.get("relationship", {}) if relationship.get("is_followup"): last_outcome = relationship.get("last_outcome", "neutral") if last_outcome == "positive": return 9.0, "Follow-up caloroso (último contato positivo)" elif last_outcome == "neutral": return 7.0, "Follow-up (último contato neutro)" else: return 5.0, "Follow-up (precisa de reengajamento)" if relationship.get("referred"): return 8.0, "Lead indicado" if relationship.get("mutual_connections", 0) > 0: return 6.0, f"{relationship['mutual_connections']} conexões em comum" if relationship.get("inbound"): return 7.0, "Interesse inbound" return 4.0, "Abordagem a frio" def score_signals(prospect: dict) -> tuple[float, str]: """Pontua com base em sinais de compra detectados.""" signals = prospect.get("signals", []) total_score = 0 signal_reasons = [] for signal in signals: signal_score = SIGNAL_SCORES.get(signal, 0) total_score += signal_score if signal_score > 0: signal_reasons.append(signal.replace("_", " ")) # Normalizar para escala de 0 a 10 normalized = min(max(total_score / 2, 0), 10) reason = f"Sinais: {', '.join(signal_reasons)}" if signal_reasons else "Sem sinais fortes" return normalized, reason def calculate_priority_score( prospect: dict, weights: dict = None ) -> ScoredProspect: """Calcula pontuação geral de prioridade para um prospect.""" weights = weights or DEFAULT_WEIGHTS # Calcular pontuações dos componentes deal_score, deal_reason = score_deal_size(prospect) timing_score, timing_reason = score_timing(prospect) warmth_score, warmth_reason = score_warmth(prospect) signal_score, signal_reason = score_signals(prospect) # Total ponderado raw_score = ( deal_score * weights["deal_size"] + timing_score * weights["timing"] + warmth_score * weights["warmth"] + signal_score * weights["signals"] ) # Compilar justificativas reasons = [] if timing_score >= 8: reasons.append(timing_reason) if signal_score >= 7: reasons.append(signal_reason) if warmth_score >= 7: reasons.append(warmth_reason) if deal_score >= 8: reasons.append(deal_reason) return ScoredProspect( company=prospect.get("company", "Desconhecido"), contact=prospect.get("contact", "Desconhecido"), call_time=prospect.get("call_time", "Desconhecido"), raw_score=round(raw_score, 2), normalized_score=int(raw_score * 10), priority_rank=0, # Será definido após ordenação score_breakdown={ "deal_size": {"score": deal_score, "reason": deal_reason}, "timing": {"score": timing_score, "reason": timing_reason}, "warmth": {"score": warmth_score, "reason": warmth_reason}, "signals": {"score": signal_score, "reason": signal_reason} }, reasoning="; ".join(reasons) if reasons else "Prioridade padrão", is_followup=prospect.get("relationship", {}).get("is_followup", False) ) def main( prospects: list[dict], weights: dict = None ) -> dict[str, Any]: """ Calcula e classifica prioridades de prospects. Args: prospects: Lista de objetos de prospect com sinais weights: Pesos personalizados opcionais para componentes de pontuação Returns: dict com prospects classificados e detalhes de pontuação """ weights = weights or DEFAULT_WEIGHTS # Pontuar todos os prospects scored = [calculate_priority_score(p, weights) for p in prospects] # Ordenar por pontuação bruta decrescente scored.sort(key=lambda x: x.raw_score, reverse=True) # Atribuir classificações for i, prospect in enumerate(scored, 1): prospect.priority_rank = i # Converter para dicts para serialização JSON ranked = [] for s in scored: ranked.append({ "company": s.company, "contact": s.contact, "call_time": s.call_time, "priority_rank": s.priority_rank, "score": s.normalized_score, "reasoning": s.reasoning, "is_followup": s.is_followup, "breakdown": s.score_breakdown }) return { "ranked": ranked, "weights_used": weights, "total_prospects": len(prospects) } if __name__ == "__main__": import sys # Exemplo de uso example_prospects = [ { "company": "DataFlow Systems", "contact": "Sarah Chen", "call_time": "2pm", "size_indicators": {"employees": 200, "revenue": 25_000_000}, "timing_signals": ["just_funded", "active_evaluation"], "signals": ["recent_funding", "job_postings_relevant"], "relationship": {"is_followup": False, "mutual_connections": 2} }, { "company": "Acme Manufacturing", "contact": "Tom Bradley", "call_time": "10am", "size_indicators": {"employees": 500}, "timing_signals": ["contract_expiring"], "signals": [], "relationship": {"is_followup": True, "last_outcome": "neutral"} }, { "company": "FirstRate Financial", "contact": "Linda Thompson", "call_time": "4pm", "size_indicators": {"employees": 300}, "timing_signals": [], "signals": [], "relationship": {"is_followup": False} } ] result = main(prospects=example_prospects) print(json.dumps(result, indent=2)) FILE:research-checklist.md # Checklist de Pesquisa de Prospects ## Pesquisa de Empresa ### Informações Básicas - [ ] Nome da empresa (verificar grafia) - [ ] Setor/vertical - [ ] Localização da sede - [ ] Número de funcionários (LinkedIn, site) - [ ] Estimativa de receita (se disponível) - [ ] Data de fundação - [ ] Estágio/histórico de financiamento ### Notícias Recentes (Últimos 90 Dias) - [ ] Anúncios de financiamento - [ ] Aquisições ou fusões - [ ] Mudanças de liderança - [ ] Lançamentos de produtos - [ ] Grandes conquistas de clientes - [ ] Menções na imprensa - [ ] Notícias financeiras/resultados ### Pegada Digital - [ ] Revisão do site - [ ] Tópicos de blog/conteúdo - [ ] Presença em redes sociais - [ ] Vagas de emprego (página de carreiras + LinkedIn) - [ ] Stack de tecnologia (BuiltWith, vagas de emprego) ### Cenário Competitivo - [ ] Concorrentes conhecidos - [ ] Posição de mercado - [ ] Diferenciais declarados - [ ] Movimentos competitivos recentes ### Indicadores de Pontos de Dor - [ ] Avaliações no Glassdoor (temas) - [ ] Avaliações no G2/Capterra (se B2B) - [ ] Reclamações em redes sociais - [ ] Padrões de vagas de emprego ## Pesquisa de Contato ### Perfil Profissional - [ ] Cargo atual - [ ] Tempo no cargo - [ ] Tempo na empresa - [ ] Empresas anteriores - [ ] Cargos anteriores - [ ] Educação ### Autoridade de Decisão - [ ] Para quem se reporta - [ ] Tamanho da equipe (se gestor) - [ ] Autoridade orçamentária (inferida) - [ ] Histórico de envolvimento em compras ### Ganchos de Engajamento - [ ] Posts recentes no LinkedIn - [ ] Artigos publicados - [ ] Participações em podcasts - [ ] Palestras em conferências - [ ] Conexões em comum - [ ] Interesses/grupos compartilhados ### Estilo de Comunicação - [ ] Tom dos posts (formal/casual) - [ ] Tópicos com os quais interage - [ ] Padrões de resposta ## Verificação no CRM (Se Disponível) - [ ] Quaisquer pontos de contato anteriores - [ ] Oportunidades anteriores - [ ] Contatos relacionados na empresa - [ ] Notas de colegas - [ ] Histórico de engajamento por e-mail ## Profundidade de Pesquisa Baseada em Tempo | Tempo Disponível | Profundidade de Pesquisa | |------------------|--------------------------| | 5 minutos | Básico da empresa + cargo do contato apenas | | 15 minutos | + Notícias recentes + perfil no LinkedIn | | 30 minutos | + Sinais de pontos de dor + ganchos de engajamento | | 60 minutos | Checklist completo + análise competitiva | FILE:signal-indicators.md # Referência de Indicadores de Sinais ## Sinais de Alta Intenção ### Vagas de Emprego - **3+ cargos relevantes publicados** = Iniciativa ativa, orçamento alocado - **Contratação sênior no seu domínio** = Prioridade estratégica - **Linguagem de urgência ("ASAP", "imediato")** = Dor aguda - **Ferramenta específica mencionada** = Consciência de concorrente ou categoria ### Eventos Financeiros - **Financiamento Série B+** = Capital de crescimento, poder de compra - **Preparação para IPO** = Maturidade operacional necessária - **Aquisição anunciada** = Desafios de integração chegando - **PR de marco de receita** = Orçamento disponível ### Mudanças de Liderança - **Novo CXO no seu domínio** = Definição de prioridades em 90 dias - **Novo CRO/CMO** = Avaliação de stack de tecnologia provável - **Transição de fundador para CEO** = Profissionalização das operações ## Sinais de Média Intenção ### Sinais de Expansão - **Abertura de novo escritório** = Necessidades de infraestrutura - **Expansão internacional** = Localização, conformidade - **Lançamento de novo produto** = Desafios de escala - **Grande conquista de cliente** = Pressão de entrega ### Sinais de Tecnologia - **RFP publicado** = Processo de compra ativo - **Revisão de fornecedor mencionada** = Comparação de opções - **Mudança de stack de tecnologia** = Oportunidade de integração - **Reclamações sobre sistema legado** = Necessidade de modernização ### Sinais de Conteúdo - **Post de blog sobre seu tópico** = Educando a si mesmos - **Participação em webinar** = Interesse confirmado - **Download de whitepaper** = Consciência do problema - **Palestra em conferência** = Liderança de pensamento, visibilidade ## Sinais de Baixa Intenção (Nutrição) ### Atividade Geral - **Participação em evento do setor** = Participante de mercado - **Contratação genérica** = Empresa em crescimento - **Imprensa positiva** = Empresa saudável - **Atividade em redes sociais** = Liderança engajada ## Pontuação de Sinais | Tipo de Sinal | Pontuação | Ação | |---------------|-----------|------| | Vaga de emprego (relevante) | +3 | Priorizar abordagem | | Financiamento recente | +3 | Referenciar na conversa | | Mudança de liderança | +2 | Oportunidade sensível ao tempo | | Notícia de expansão | +2 | Ângulo de crescimento | | Avaliações negativas | +2 | Ângulo de ponto de dor | | Engajamento com conteúdo | +1 | Trilha de nutrição | | Sem sinais | 0 | Foco em descoberta |