Compétence de recherche commerciale : Méthodologie de recherche de prospects

--- name: sales-research description: Cette compétence fournit une méthodologie et des bonnes pratiques pour la recherche de prospects commerciaux. --- # Recherche Commerciale ## Vue d'ensemble Cette compétence fournit une méthodologie et des bonnes pratiques pour la recherche de prospects commerciaux. Elle couvre la recherche d'entreprise, le profilage des contacts et la détection de signaux pour mettre en évidence des informations exploitables. ## Utilisation Les sous-agents company-researcher et contact-researcher se réfèrent à cette compétence lorsque : - Ils recherchent de nouveaux prospects - Ils trouvent des informations sur une entreprise - Ils profilent des contacts individuels - Ils détectent des signaux d'achat ## Méthodologie de recherche ### Liste de contrôle pour la recherche d'entreprise 1. **Profil de base** - Nom de l'entreprise, secteur, taille (employés, chiffre d'affaires) - Siège social et emplacements clés - Date de fondation, stade de croissance 2. **Développements récents** - Annonces de financement (12 derniers mois) - Activité de fusions et acquisitions - Changements de direction - Lancements de produits 3. **Pile technologique** - Technologies connues (BuiltWith, StackShare) - Offres d'emploi mentionnant des outils - Partenariats d'intégration 4. **Signaux** - Offres d'emploi (croissance = opportunité) - Avis Glassdoor (points de douleur) - Mentions dans les médias (contexte) - Activité sur les réseaux sociaux ### Liste de contrôle pour la recherche de contacts 1. **Parcours professionnel** - Poste actuel et ancienneté - Entreprises et postes précédents - Formation 2. **Indicateurs d'influence** - Structure hiérarchique - Autorité de décision - Gestion du budget 3. **Points d'accroche** - Publications LinkedIn récentes - Articles publiés - Interventions en conférence - Connaissances communes ## Ressources - `resources/signal-indicators.md` - Taxonomie des signaux d'achat - `resources/research-checklist.md` - Liste de contrôle complète de recherche ## Scripts - `scripts/company-enricher.py` - Agrégation des données d'entreprise à partir de plusieurs sources - `scripts/linkedin-parser.py` - Structuration des données de profil LinkedIn FILE:company-enricher.py #!/usr/bin/env python3 """ company-enricher.py - Agrégation des données d'entreprise à partir de plusieurs sources Entrées : - company_name : chaîne - domain : chaîne (optionnel) Sorties : - profile : name : chaîne industry : chaîne size : chaîne funding : chaîne tech_stack : [chaîne] recent_news : [éléments d'actualité] Dépendances : - requests, beautifulsoup4 """ # Exigences : 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: """ Recherche d'informations de base sur l'entreprise. En production, cela appellerait des API comme Clearbit, Crunchbase, etc. """ # TODO : Implémenter les appels API réels # Structure de retour provisoire return { "name": company_name, "domain": domain or f"{company_name.lower().replace(' ', '')}.com", "industry": "Technology", # Viendrait de l'API "size": "Unknown", "location": "Unknown", "founded": "Unknown", "description": f"Informations sur {company_name}" } def search_funding_info(company_name: str) -> dict: """ Recherche d'informations sur le financement. En production, appellerait Crunchbase, PitchBook, etc. """ # TODO : Implémenter les appels API réels return { "total_funding": "Unknown", "last_round": "Unknown", "last_round_date": "Unknown", "investors": [] } def search_tech_stack(domain: str) -> list[str]: """ Détection de la pile technologique. En production, appellerait BuiltWith, Wappalyzer, etc. """ # TODO : Implémenter les appels API réels return [] def search_recent_news(company_name: str, days: int = 90) -> list[dict]: """ Recherche d'actualités récentes sur l'entreprise. En production, appellerait des API d'actualités. """ # TODO : Implémenter les appels API réels return [] def main( company_name: str, domain: str = None ) -> dict[str, Any]: """ Agrégation des données d'entreprise à partir de plusieurs sources. Args : company_name : Nom de l'entreprise à rechercher domain : Domaine de l'entreprise (optionnel, sera déduit) Returns : dict avec profil d'entreprise incluant secteur, taille, financement, pile technologique, actualités """ # Obtenir les informations de base sur l'entreprise basic_info = search_company_info(company_name, domain) # Obtenir les informations sur le financement funding_info = search_funding_info(company_name) # Détecter la pile technologique company_domain = basic_info.get("domain", domain) tech_stack = search_tech_stack(company_domain) if company_domain else [] # Obtenir les actualités récentes news = search_recent_news(company_name) # Compiler le profil 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=[], # Serait enrichi à partir de l'analyse sectorielle 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 # Exemple d'utilisation 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 - Structuration des données de profil LinkedIn Entrées : - profile_url : chaîne - ou name + company : chaînes Sorties : - contact : name : chaîne title : chaîne tenure : chaîne previous_roles : [objets de rôle] mutual_connections : [chaîne] recent_activity : [résumés de publications] Dépendances : - requests """ # Exigences : 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: """ Recherche d'informations sur le profil LinkedIn. En production, utiliserait l'API LinkedIn ou Sales Navigator. """ # TODO : Implémenter l'intégration réelle de l'API LinkedIn # Remarque : L'API LinkedIn a des conditions d'utilisation strictes 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]: """ Extraction de l'historique de carrière à partir du profil. """ # TODO : Implémenter l'extraction de carrière return [] def get_mutual_connections(profile_data: dict, user_network: list = None) -> list[str]: """ Recherche de connaissances communes. """ # TODO : Implémenter la détection de connaissances communes return [] def get_recent_activity(profile_data: dict, days: int = 30) -> list[dict]: """ Obtention des publications et activités récentes. """ # TODO : Implémenter l'extraction d'activités return [] def main( name: str = None, company: str = None, profile_url: str = None ) -> dict[str, Any]: """ Structuration des données de profil LinkedIn pour la préparation commerciale. Args : name : Nom de la personne company : Entreprise où elle travaille profile_url : URL directe du profil LinkedIn Returns : dict avec profil de contact structuré """ if not profile_url and not (name and company): return {"error": "Fournir soit profile_url soit name + company"} # Recherche du profil 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": "Profil non trouvé ou accès limité", "suggestions": [ "Essayez de rechercher directement sur LinkedIn", "Vérifiez les orthographes alternatives", "Vérifiez que la personne travaille toujours dans cette entreprise" ] } # Obtenir l'historique de carrière previous_roles = get_career_history(profile_data) # Trouver les connaissances communes mutual_connections = get_mutual_connections(profile_data) # Obtenir l'activité récente recent_activity = get_recent_activity(profile_data) # Compiler le profil de contact 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=[], # Serait extrait du profil 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: """Calcul du degré de complétude des données du profil.""" 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 # Exemple d'utilisation 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 - Calcul et classement des priorités des prospects Entrées : - prospects : [objets prospects avec signaux] - weights : {deal_size, timing, warmth, signals} Sorties : - ranked : [prospects avec scores et justifications] Dépendances : - (aucune - Python pur) """ import json from typing import Any from dataclasses import dataclass # Poids de notation par défaut DEFAULT_WEIGHTS = { "deal_size": 0.25, "timing": 0.30, "warmth": 0.20, "signals": 0.25 } # Correspondance des scores de signaux SIGNAL_SCORES = { # Signaux à forte intention "recent_funding": 10, "leadership_change": 8, "job_postings_relevant": 9, "expansion_news": 7, "competitor_mention": 6, # Signaux à intention moyenne "general_hiring": 4, "industry_event": 3, "content_engagement": 3, # Signaux relationnels "mutual_connection": 5, "previous_contact": 6, "referred_lead": 8, # Signaux négatifs "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]: """Notation basée sur la taille estimée de la transaction.""" size_indicators = prospect.get("size_indicators", {}) employee_count = size_indicators.get("employees", 0) revenue_estimate = size_indicators.get("revenue", 0) # Notation simple basée sur la taille de l'entreprise if employee_count > 1000 or revenue_estimate > 100_000_000: return 10.0, "Opportunité de niveau entreprise" elif employee_count > 200 or revenue_estimate > 20_000_000: return 7.0, "Opportunité de niveau mid-market" elif employee_count > 50: return 5.0, "Opportunité PME" else: return 3.0, "Petite entreprise" def score_timing(prospect: dict) -> tuple[float, str]: """Notation basée sur les signaux de timing.""" timing_signals = prospect.get("timing_signals", []) score = 5.0 # Score de base reasons = [] for signal in timing_signals: if signal == "budget_cycle_q4": score += 3 reasons.append("Planification budgétaire T4") elif signal == "contract_expiring": score += 4 reasons.append("Contrat arrivant à expiration") elif signal == "active_evaluation": score += 5 reasons.append("Évaluation active en cours") elif signal == "just_funded": score += 3 reasons.append("Financement récent") return min(score, 10.0), "; ".join(reasons) if reasons else "Timing standard" def score_warmth(prospect: dict) -> tuple[float, str]: """Notation basée sur la chaleur de la relation.""" relationship = prospect.get("relationship", {}) if relationship.get("is_followup"): last_outcome = relationship.get("last_outcome", "neutral") if last_outcome == "positive": return 9.0, "Suivi chaleureux (dernier contact positif)" elif last_outcome == "neutral": return 7.0, "Suivi (dernier contact neutre)" else: return 5.0, "Suivi (nécessite un réengagement)" if relationship.get("referred"): return 8.0, "Lead référé" if relationship.get("mutual_connections", 0) > 0: return 6.0, f"{relationship['mutual_connections']} connaissances communes" if relationship.get("inbound"): return 7.0, "Intérêt entrant" return 4.0, "Prospection à froid" def score_signals(prospect: dict) -> tuple[float, str]: """Notation basée sur les signaux d'achat détectés.""" 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("_", " ")) # Normalisation sur une échelle de 0 à 10 normalized = min(max(total_score / 2, 0), 10) reason = f"Signaux : {', '.join(signal_reasons)}" if signal_reasons else "Aucun signal fort" return normalized, reason def calculate_priority_score( prospect: dict, weights: dict = None ) -> ScoredProspect: """Calcul du score de priorité global pour un prospect.""" weights = weights or DEFAULT_WEIGHTS # Calcul des scores des composants 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 pondéré raw_score = ( deal_score * weights["deal_size"] + timing_score * weights["timing"] + warmth_score * weights["warmth"] + signal_score * weights["signals"] ) # Compilation des justifications 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, # Sera défini après le tri 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 "Priorité standard", is_followup=prospect.get("relationship", {}).get("is_followup", False) ) def main( prospects: list[dict], weights: dict = None ) -> dict[str, Any]: """ Calcul et classement des priorités des prospects. Args : prospects : Liste d'objets prospects avec signaux weights : Poids personnalisés optionnels pour les composants de notation Returns : dict avec prospects classés et détails de notation """ weights = weights or DEFAULT_WEIGHTS # Notation de tous les prospects scored = [calculate_priority_score(p, weights) for p in prospects] # Tri par score brut décroissant scored.sort(key=lambda x: x.raw_score, reverse=True) # Attribution des rangs for i, prospect in enumerate(scored, 1): prospect.priority_rank = i # Conversion en dicts pour la sérialisation 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 # Exemple d'utilisation 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 # Liste de contrôle pour la recherche de prospects ## Recherche d'entreprise ### Informations de base - [ ] Nom de l'entreprise (vérifier l'orthographe) - [ ] Secteur/vertical - [ ] Emplacement du siège social - [ ] Nombre d'employés (LinkedIn, site web) - [ ] Estimation du chiffre d'affaires (si disponible) - [ ] Date de fondation - [ ] Stade/historique de financement ### Actualités récentes (90 derniers jours) - [ ] Annonces de financement - [ ] Acquisitions ou fusions - [ ] Changements de direction - [ ] Lancements de produits - [ ] Victoires clients majeures - [ ] Mentions dans la presse - [ ] Actualités financières/résultats ### Empreinte numérique - [ ] Revue du site web - [ ] Sujets du blog/contenus - [ ] Présence sur les réseaux sociaux - [ ] Offres d'emploi (page carrières + LinkedIn) - [ ] Pile technologique (BuiltWith, offres d'emploi) ### Paysage concurrentiel - [ ] Concurrents connus - [ ] Position sur le marché - [ ] Différenciateurs revendiqués - [ ] Mouvements concurrentiels récents ### Indicateurs de points de douleur - [ ] Avis Glassdoor (thèmes) - [ ] Avis G2/Capterra (si B2B) - [ ] Plaintes sur les réseaux sociaux - [ ] Modèles d'offres d'emploi ## Recherche de contacts ### Profil professionnel - [ ] Poste actuel - [ ] Temps dans le poste - [ ] Temps dans l'entreprise - [ ] Entreprises précédentes - [ ] Postes précédents - [ ] Formation ### Autorité de décision - [ ] Rend compte à qui - [ ] Taille de l'équipe (si manager) - [ ] Autorité budgétaire (déduite) - [ ] Historique d'implication dans les achats ### Points d'accroche - [ ] Publications LinkedIn récentes - [ ] Articles publiés - [ ] Apparitions dans des podcasts - [ ] Interventions en conférence - [ ] Connaissances communes - [ ] Centres d'intérêt/groupes partagés ### Style de communication - [ ] Ton des publications (formel/informel) - [ ] Sujets avec lesquels ils interagissent - [ ] Modèles de réponse ## Vérification CRM (si disponible) - [ ] Points de contact antérieurs - [ ] Opportunités précédentes - [ ] Contacts liés dans l'entreprise - [ ] Notes de collègues - [ ] Historique d'engagement par e-mail ## Profondeur de recherche basée sur le temps | Temps disponible | Profondeur de recherche | |------------------|-------------------------| | 5 minutes | Informations de base sur l'entreprise + poste du contact uniquement | | 15 minutes | + Actualités récentes + profil LinkedIn | | 30 minutes | + Signaux de points de douleur + points d'accroche | | 60 minutes | Liste de contrôle complète + analyse concurrentielle | FILE:signal-indicators.md # Référence des indicateurs de signaux ## Signaux à forte intention ### Offres d'emploi - **3+ postes pertinents publiés** = Initiative active, budget alloué - **Recrutement senior dans votre domaine** = Priorité stratégique - **Langage d'urgence ("ASAP", "immediate")** = Douleur aiguë - **Outil spécifique mentionné** = Sensibilisation au concurrent ou à la catégorie ### Événements financiers - **Financement série B+** = Capital de croissance, pouvoir d'achat - **Préparation à l'introduction en bourse** = Maturité opérationnelle requise - **Acquisition annoncée** = Défis d'intégration à venir - **PR sur un jalon de revenus** = Budget disponible ### Changements de direction - **Nouveau CXO dans votre domaine** = Définition des priorités sur 90 jours - **Nouveau CRO/CMO** = Évaluation probable de la pile technologique - **Transition du fondateur vers le poste de CEO** = Professionnalisation des opérations ## Signaux à intention moyenne ### Signaux d'expansion - **Ouverture d'un nouveau bureau** = Besoins en infrastructure - **Expansion internationale** = Localisation, conformité - **Lancement d'un nouveau produit** = Défis de mise à l'échelle - **Victoire client majeure** = Pression de livraison ### Signaux technologiques - **RFP publié** = Processus d'achat actif - **Revue de fournisseur mentionnée** = Comparaison de concurrents - **Changement de pile technologique** = Opportunité d'intégration - **Plaintes sur les systèmes hérités** = Besoin de modernisation ### Signaux de contenu - **Article de blog sur votre sujet** = Auto-éducation - **Participation à un webinaire** = Intérêt confirmé - **Téléchargement de livre blanc** = Sensibilisation au problème - **Intervention en conférence** = Leadership éclairé, visibilité ## Signaux à faible intention (Nurture) ### Activité générale - **Participation à un événement sectoriel** = Participant au marché - **Recrutement générique** = Entreprise en croissance - **Presse positive** = Entreprise saine - **Activité sur les réseaux sociaux** = Leadership engagé ## Notation des signaux | Type de signal | Score | Action | |----------------|-------|--------| | Offre d'emploi (pertinente) | +3 | Prioriser la sensibilisation | | Financement récent | +3 | Référencer dans la conversation | | Changement de direction | +2 | Opportunité sensible au temps | | Actualité d'expansion | +2 | Angle de croissance | | Avis négatifs | +2 | Angle de point de douleur | | Engagement de contenu | +1 | Parcours de nurture | | Aucun signal | 0 | Focus sur la découverte |