Habilidad de Investigación de Ventas: Metodología de Investigación de Prospectos

--- name: sales-research description: Esta habilidad proporciona metodología y mejores prácticas para investigar prospectos de ventas. --- # Investigación de Ventas ## Descripción General Esta habilidad proporciona metodología y mejores prácticas para investigar prospectos de ventas. Cubre investigación de empresas, perfilado de contactos y detección de señales para generar inteligencia accionable. ## Uso Los subagentes company-researcher y contact-researcher hacen referencia a esta habilidad cuando: - Investigan nuevos prospectos - Buscan información de empresas - Perfilan contactos individuales - Detectan señales de compra ## Metodología de Investigación ### Lista de Verificación de Investigación de Empresas 1. **Perfil Básico** - Nombre de la empresa, industria, tamaño (empleados, ingresos) - Sede central y ubicaciones clave - Fecha de fundación, etapa de crecimiento 2. **Desarrollos Recientes** - Anuncios de financiación (últimos 12 meses) - Actividad de fusiones y adquisiciones - Cambios de liderazgo - Lanzamientos de productos 3. **Stack Tecnológico** - Tecnologías conocidas (BuiltWith, StackShare) - Ofertas de empleo que mencionan herramientas - Asociaciones de integración 4. **Señales** - Ofertas de empleo (escalamiento = oportunidad) - Reseñas de Glassdoor (puntos de dolor) - Menciones en noticias (contexto) - Actividad en redes sociales ### Lista de Verificación de Investigación de Contactos 1. **Antecedentes Profesionales** - Rol actual y antigüedad - Empresas y roles anteriores - Educación 2. **Indicadores de Influencia** - Estructura de reporte - Autoridad para tomar decisiones - Propiedad del presupuesto 3. **Ganchos de Engagement** - Publicaciones recientes en LinkedIn - Artículos publicados - Participaciones como ponente - Conexiones mutuas ## Recursos - `resources/signal-indicators.md` - Taxonomía de señales de compra - `resources/research-checklist.md` - Lista de verificación completa de investigación ## Scripts - `scripts/company-enricher.py` - Agregar datos de empresa desde múltiples fuentes - `scripts/linkedin-parser.py` - Estructurar datos de perfil de LinkedIn FILE:company-enricher.py #!/usr/bin/env python3 """ company-enricher.py - Agregar datos de empresa desde múltiples fuentes Entradas: - company_name: string - domain: string (opcional) Salidas: - profile: name: string industry: string size: string funding: string tech_stack: [string] recent_news: [elementos de noticias] Dependencias: - 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: """ Buscar información básica de la empresa. En producción, esto llamaría APIs como Clearbit, Crunchbase, etc. """ # TODO: Implementar llamadas API reales # Estructura de retorno provisional return { "name": company_name, "domain": domain or f"{company_name.lower().replace(' ', '')}.com", "industry": "Technology", # Vendría de la API "size": "Unknown", "location": "Unknown", "founded": "Unknown", "description": f"Información sobre {company_name}" } def search_funding_info(company_name: str) -> dict: """ Buscar información de financiación. En producción, llamaría a Crunchbase, PitchBook, etc. """ # TODO: Implementar llamadas API reales return { "total_funding": "Unknown", "last_round": "Unknown", "last_round_date": "Unknown", "investors": [] } def search_tech_stack(domain: str) -> list[str]: """ Detectar stack tecnológico. En producción, llamaría a BuiltWith, Wappalyzer, etc. """ # TODO: Implementar llamadas API reales return [] def search_recent_news(company_name: str, days: int = 90) -> list[dict]: """ Buscar noticias recientes sobre la empresa. En producción, llamaría a APIs de noticias. """ # TODO: Implementar llamadas API reales return [] def main( company_name: str, domain: str = None ) -> dict[str, Any]: """ Agregar datos de empresa desde múltiples fuentes. Args: company_name: Nombre de la empresa a investigar domain: Dominio de la empresa (opcional, se inferirá) Returns: dict con perfil de empresa incluyendo industria, tamaño, financiación, stack tecnológico, noticias """ # Obtener información básica de la empresa basic_info = search_company_info(company_name, domain) # Obtener información de financiación funding_info = search_funding_info(company_name) # Detectar stack tecnológico company_domain = basic_info.get("domain", domain) tech_stack = search_tech_stack(company_domain) if company_domain else [] # Obtener noticias recientes 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", "Unknown"), tech_stack=tech_stack, recent_news=news, competitors=[], # Se enriquecería con análisis de industria 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 # Ejemplo 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 - Estructurar datos de perfil de LinkedIn Entradas: - profile_url: string - o name + company: strings Salidas: - contact: name: string title: string tenure: string previous_roles: [objetos de rol] mutual_connections: [string] recent_activity: [resúmenes de publicaciones] Dependencias: - 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: """ Buscar información de perfil de LinkedIn. En producción, usaría la API de LinkedIn o Sales Navigator. """ # TODO: Implementar integración real con la API de LinkedIn # Nota: La API de LinkedIn tiene términos de servicio estrictos return { "found": False, "name": name or "Unknown", "title": "Unknown", "company": company or "Unknown", "location": "Unknown", "headline": "", "tenure": "Unknown", "profile_url": profile_url or "" } def get_career_history(profile_data: dict) -> list[dict]: """ Extraer historial profesional del perfil. """ # TODO: Implementar extracción de carrera return [] def get_mutual_connections(profile_data: dict, user_network: list = None) -> list[str]: """ Encontrar conexiones mutuas. """ # TODO: Implementar detección de conexiones mutuas return [] def get_recent_activity(profile_data: dict, days: int = 30) -> list[dict]: """ Obtener publicaciones y actividad recientes. """ # TODO: Implementar extracción de actividad return [] def main( name: str = None, company: str = None, profile_url: str = None ) -> dict[str, Any]: """ Estructurar datos de perfil de LinkedIn para preparación de ventas. Args: name: Nombre de la persona company: Empresa donde trabaja profile_url: URL directa del perfil de LinkedIn Returns: dict con perfil de contacto estructurado """ if not profile_url and not (name and company): return {"error": "Proporcione profile_url o name + company"} # 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 "Unknown", "company": company or "Unknown", "message": "Perfil no encontrado o acceso limitado", "suggestions": [ "Intente buscar directamente en LinkedIn", "Verifique ortografías alternativas", "Confirme que la persona aún trabaja en esta empresa" ] } # Obtener historial profesional previous_roles = get_career_history(profile_data) # Encontrar conexiones mutuas mutual_connections = get_mutual_connections(profile_data) # Obtener actividad reciente recent_activity = get_recent_activity(profile_data) # Compilar perfil de contacto 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=[], # Se extraería del 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: """Calcular qué tan completo está el perfil de datos.""" 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 # Ejemplo 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 - Calcular y clasificar prioridades de prospectos Entradas: - prospects: [objetos de prospecto con señales] - weights: {deal_size, timing, warmth, signals} Salidas: - ranked: [prospectos con puntuaciones y razonamiento] Dependencias: - (ninguna - Python puro) """ import json from typing import Any from dataclasses import dataclass # Pesos de puntuación predeterminados DEFAULT_WEIGHTS = { "deal_size": 0.25, "timing": 0.30, "warmth": 0.20, "signals": 0.25 } # Mapeo de puntuación de señales SIGNAL_SCORES = { # Señales de alta intención "recent_funding": 10, "leadership_change": 8, "job_postings_relevant": 9, "expansion_news": 7, "competitor_mention": 6, # Señales de intención media "general_hiring": 4, "industry_event": 3, "content_engagement": 3, # Señales de relación "mutual_connection": 5, "previous_contact": 6, "referred_lead": 8, # Señales negativas "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]: """Puntuar según el tamaño estimado del trato.""" size_indicators = prospect.get("size_indicators", {}) employee_count = size_indicators.get("employees", 0) revenue_estimate = size_indicators.get("revenue", 0) # Puntuación simple según el tamaño de la empresa if employee_count > 1000 or revenue_estimate > 100_000_000: return 10.0, "Oportunidad a nivel empresarial" elif employee_count > 200 or revenue_estimate > 20_000_000: return 7.0, "Oportunidad de mercado medio" elif employee_count > 50: return 5.0, "Oportunidad SMB" else: return 3.0, "Pequeña empresa" def score_timing(prospect: dict) -> tuple[float, str]: """Puntuar según señales de timing.""" timing_signals = prospect.get("timing_signals", []) score = 5.0 # Puntuación base reasons = [] for signal in timing_signals: if signal == "budget_cycle_q4": score += 3 reasons.append("Planificación de presupuesto Q4") elif signal == "contract_expiring": score += 4 reasons.append("Contrato expira pronto") elif signal == "active_evaluation": score += 5 reasons.append("Evaluando activamente") elif signal == "just_funded": score += 3 reasons.append("Financiado recientemente") return min(score, 10.0), "; ".join(reasons) if reasons else "Timing estándar" def score_warmth(prospect: dict) -> tuple[float, str]: """Puntuar según la calidez de la relación.""" relationship = prospect.get("relationship", {}) if relationship.get("is_followup"): last_outcome = relationship.get("last_outcome", "neutral") if last_outcome == "positive": return 9.0, "Seguimiento cálido (último contacto positivo)" elif last_outcome == "neutral": return 7.0, "Seguimiento (último contacto neutral)" else: return 5.0, "Seguimiento (necesita re-engagement)" if relationship.get("referred"): return 8.0, "Lead referido" if relationship.get("mutual_connections", 0) > 0: return 6.0, f"{relationship['mutual_connections']} conexiones mutuas" if relationship.get("inbound"): return 7.0, "Interés inbound" return 4.0, "Outreach en frío" def score_signals(prospect: dict) -> tuple[float, str]: """Puntuar según señales de compra detectadas.""" 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 a escala 0-10 normalized = min(max(total_score / 2, 0), 10) reason = f"Señales: {', '.join(signal_reasons)}" if signal_reasons else "Sin señales fuertes" return normalized, reason def calculate_priority_score( prospect: dict, weights: dict = None ) -> ScoredProspect: """Calcular puntuación de prioridad general para un prospecto.""" weights = weights or DEFAULT_WEIGHTS # Calcular puntuaciones de 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 razonamiento 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", "Unknown"), contact=prospect.get("contact", "Unknown"), call_time=prospect.get("call_time", "Unknown"), raw_score=round(raw_score, 2), normalized_score=int(raw_score * 10), priority_rank=0, # Se asignará después de ordenar 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 "Prioridad estándar", is_followup=prospect.get("relationship", {}).get("is_followup", False) ) def main( prospects: list[dict], weights: dict = None ) -> dict[str, Any]: """ Calcular y clasificar prioridades de prospectos. Args: prospects: Lista de objetos de prospecto con señales weights: Pesos personalizados opcionales para componentes de puntuación Returns: dict con prospectos clasificados y detalles de puntuación """ weights = weights or DEFAULT_WEIGHTS # Puntuar todos los prospectos scored = [calculate_priority_score(p, weights) for p in prospects] # Ordenar por puntuación bruta descendente scored.sort(key=lambda x: x.raw_score, reverse=True) # Asignar rangos for i, prospect in enumerate(scored, 1): prospect.priority_rank = i # Convertir a dicts para serialización 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 # Ejemplo 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 # Lista de Verificación de Investigación de Prospectos ## Investigación de Empresas ### Información Básica - [ ] Nombre de la empresa (verificar ortografía) - [ ] Industria/vertical - [ ] Ubicación de la sede central - [ ] Número de empleados (LinkedIn, sitio web) - [ ] Estimación de ingresos (si está disponible) - [ ] Fecha de fundación - [ ] Etapa/historial de financiación ### Noticias Recientes (Últimos 90 Días) - [ ] Anuncios de financiación - [ ] Adquisiciones o fusiones - [ ] Cambios de liderazgo - [ ] Lanzamientos de productos - [ ] Grandes victorias de clientes - [ ] Menciones en prensa - [ ] Noticias financieras/resultados ### Huella Digital - [ ] Revisión del sitio web - [ ] Temas del blog/contenido - [ ] Presencia en redes sociales - [ ] Ofertas de empleo (página de carreras + LinkedIn) - [ ] Stack tecnológico (BuiltWith, ofertas de empleo) ### Panorama Competitivo - [ ] Competidores conocidos - [ ] Posición en el mercado - [ ] Diferenciadores declarados - [ ] Movimientos competitivos recientes ### Indicadores de Puntos de Dolor - [ ] Reseñas de Glassdoor (temas) - [ ] Reseñas de G2/Capterra (si es B2B) - [ ] Quejas en redes sociales - [ ] Patrones en ofertas de empleo ## Investigación de Contactos ### Perfil Profesional - [ ] Título actual - [ ] Tiempo en el rol - [ ] Tiempo en la empresa - [ ] Empresas anteriores - [ ] Roles anteriores - [ ] Educación ### Autoridad de Decisión - [ ] A quién reporta - [ ] Tamaño del equipo (si es gerente) - [ ] Autoridad de presupuesto (inferida) - [ ] Historial de participación en compras ### Ganchos de Engagement - [ ] Publicaciones recientes en LinkedIn - [ ] Artículos publicados - [ ] Apariciones en podcasts - [ ] Charlas en conferencias - [ ] Conexiones mutuas - [ ] Intereses/grupos compartidos ### Estilo de Comunicación - [ ] Tono de publicaciones (formal/informal) - [ ] Temas con los que interactúa - [ ] Patrones de respuesta ## Verificación de CRM (Si Está Disponible) - [ ] Cualquier punto de contacto previo - [ ] Oportunidades anteriores - [ ] Contactos relacionados en la empresa - [ ] Notas de colegas - [ ] Historial de engagement por correo electrónico ## Profundidad de Investigación Basada en Tiempo | Tiempo Disponible | Profundidad de Investigación | |-------------------|------------------------------| | 5 minutos | Conceptos básicos de empresa + solo título del contacto | | 15 minutos | + Noticias recientes + perfil de LinkedIn | | 30 minutos | + Señales de puntos de dolor + ganchos de engagement | | 60 minutos | Lista de verificación completa + análisis competitivo | FILE:signal-indicators.md # Referencia de Indicadores de Señales ## Señales de Alta Intención ### Ofertas de Empleo - **3+ roles relevantes publicados** = Iniciativa activa, presupuesto asignado - **Contratación senior en tu dominio** = Prioridad estratégica - **Lenguaje de urgencia ("ASAP", "immediate")** = El dolor es agudo - **Herramienta específica mencionada** = Conciencia de competidor o categoría ### Eventos Financieros - **Financiación Serie B+** = Capital de crecimiento, poder de compra - **Preparación para IPO** = Madurez operativa necesaria - **Adquisición anunciada** = Desafíos de integración próximos - **PR de hito de ingresos** = Presupuesto disponible ### Cambios de Liderazgo - **Nuevo CXO en tu dominio** = Establecimiento de prioridades a 90 días - **Nuevo CRO/CMO** = Evaluación de stack tecnológico probable - **Transición de fundador a CEO** = Profesionalización de operaciones ## Señales de Intención Media ### Señales de Expansión - **Apertura de nueva oficina** = Necesidades de infraestructura - **Expansión internacional** = Localización, cumplimiento - **Lanzamiento de nuevo producto** = Desafíos de escalamiento - **Gran victoria de cliente** = Presión de entrega ### Señales Tecnológicas - **RFP publicado** = Proceso de compra activo - **Revisión de proveedor mencionada** = Comparación de opciones - **Cambio de stack tecnológico** = Oportunidad de integración - **Quejas sobre sistemas heredados** = Necesidad de modernización ### Señales de Contenido - **Publicación de blog sobre tu tema** = Educándose a sí mismos - **Asistencia a webinar** = Interés confirmado - **Descarga de whitepaper** = Conciencia del problema - **Ponencia en conferencia** = Liderazgo de pensamiento, visibilidad ## Señales de Baja Intención (Nurture) ### Actividad General - **Asistencia a eventos de industria** = Participante del mercado - **Contratación genérica** = Empresa en crecimiento - **Prensa positiva** = Empresa saludable - **Actividad en redes sociales** = Liderazgo comprometido ## Puntuación de Señales | Tipo de Señal | Puntuación | Acción | |---------------|------------|--------| | Oferta de empleo (relevante) | +3 | Priorizar outreach | | Financiación reciente | +3 | Referenciar en conversación | | Cambio de liderazgo | +2 | Oportunidad sensible al tiempo | | Noticias de expansión | +2 | Ángulo de crecimiento | | Reseñas negativas | +2 | Ángulo de punto de dolor | | Engagement con contenido | +1 | Ruta de nurture | | Sin señales | 0 | Enfoque en descubrimiento |