CRM 的 Agent 化重构：从记录系统到智能员工

class LeadScoringAgent:
    """
    智能线索评分 Agent
    """
    
    def score_and_route(self, lead: Lead) -> RoutingDecision:
        # 多维度评分
        scores = {
            "firmographic": self.score_company(lead.company),
            "behavioral": self.score_engagement(lead.activities),
            "intent": self.score_intent(lead.signals),
            "fit": self.score_product_fit(lead.needs)
        }
        
        # 综合评分
        total_score = self.weighted_sum(scores)
        
        # 自动分配
        if total_score > 80:
            # 高分线索：分配给资深销售，立即跟进
            rep = self.find_best_sr(lead)
            priority = "HOT"
            action = "CALL_WITHIN_1HOUR"
        elif total_score > 50:
            # 中分线索：分配给普通销售，当天跟进
            rep = self.find_available_rep(lead.territory)
            priority = "WARM"
            action = "FOLLOW_UP_TODAY"
        else:
            # 低分线索：进入培育序列
            rep = None
            priority = "COLD"
            action = "NURTURE_SEQUENCE"
        
        return RoutingDecision(
            lead=lead,
            score=total_score,
            breakdown=scores,
            assigned_rep=rep,
            priority=priority,
            recommended_action=action
        )

class FollowUpAgent:
    """
    智能跟进 Agent
    """
    
    def monitor_and_trigger(self):
        """监控所有客户，自动触发跟进"""
        
        for customer in self.crm.get_active_customers():
            # 计算跟进紧迫度
            urgency = self.calculate_urgency(customer)
            
            if urgency > self.threshold:
                # 生成跟进建议
                recommendation = self.generate_follow_up(customer)
                
                # 自动或半自动执行
                if recommendation.auto_executable:
                    self.execute_automatically(recommendation)
                else:
                    self.notify_sales_rep(customer.owner, recommendation)
    
    def calculate_urgency(self, customer: Customer) -> float:
        """基于多信号计算跟进紧迫度"""
        
        signals = {
            # 时间信号
            "days_since_last_contact": self.days_since_contact(customer),
            "days_in_current_stage": self.days_in_stage(customer.opportunity),
            
            # 行为信号
            "email_opened": self.email_engagement(customer),
            "website_visits": self.web_activity(customer),
            "content_downloaded": self.content_engagement(customer),
            
            # 外部信号
            "company_news": self.company_signals(customer.company),
            "decision_maker_activity": self.linkedin_activity(customer.contacts),
            
            # 风险信号
            "competitor_mentioned": self.detect_competitor_risk(customer),
            "budget_cycle": self.budget_timing(customer)
        }
        
        return self.urgency_model.predict(signals)
    
    def generate_follow_up(self, customer: Customer) -> FollowUpRecommendation:
        """生成个性化跟进建议"""
        
        # 选择渠道
        channel = self.select_channel(customer.preferences, urgency)
        
        # 生成内容
        content = self.draft_message(
            customer=customer,
            context=self.get_context(customer),
            objective=self.determine_objective(customer),
            tone=self.match_tone(customer)
        )
        
        # 选择时机
        timing = self.optimize_timing(customer.timezone, customer.availability)
        
        return FollowUpRecommendation(
            customer=customer,
            channel=channel,
            content=content,
            timing=timing,
            auto_executable=(urgency < 0.9)  # 高紧迫度需要人工介入
        )

class OpportunityIntelligenceAgent:
    """
    商机智能分析 Agent
    """
    
    def analyze_pipeline(self, opportunities: List[Opportunity]) -> PipelineInsights:
        insights = PipelineInsights()
        
        for opp in opportunities:
            # 预测成交概率
            win_probability = self.predict_win_probability(opp)
            opp.win_probability = win_probability
            
            # 识别风险因素
            risks = self.identify_risks(opp)
            
            # 预测成交时间和金额
            expected_close = self.predict_close_date(opp)
            expected_amount = self.predict_amount(opp)
            
            # 生成干预建议
            if win_probability < 0.3:
                insights.add_at_risk(opp, risks)
            elif win_probability > 0.7 and not opp.close_date_near:
                insights.add_pull_forward_opportunity(opp)
            
            if risks:
                insights.add_recommendation(opp, self.generate_action_plan(opp, risks))
        
        # 汇总分析
        insights.forecast = self.aggregate_forecast(opportunities)
        insights.gap_analysis = self.calculate_gap(insights.forecast, self.quota)
        
        return insights
    
    def identify_risks(self, opp: Opportunity) -> List[RiskFactor]:
        """识别商机风险因素"""
        
        risks = []
        
        # 参与度风险
        if opp.customer_engagement_score < 0.3:
            risks.append(RiskFactor(
                type="LOW_ENGAGEMENT",
                severity="HIGH",
                description="客户最近 2 周没有打开邮件或访问网站"
            ))
        
        # 竞争风险
        if self.detect_competitor_activity(opp):
            risks.append(RiskFactor(
                type="COMPETITOR_THREAT",
                severity="MEDIUM",
                description="客户正在评估竞品 XYZ"
            ))
        
        # 决策链风险
        if not opp.has_champion_identified:
            risks.append(RiskFactor(
                type="NO_CHAMPION",
                severity="HIGH",
                description="尚未确定内部支持者"
            ))
        
        # 预算风险
        if opp.budget_status == "UNCONFIRMED":
            risks.append(RiskFactor(
                type="BUDGET_UNCERTAIN",
                severity="MEDIUM",
                description="预算尚未正式获批"
            ))
        
        return risks

class ProposalGenerationAgent:
    """
    智能提案生成 Agent
    """
    
    def generate_proposal(self, opportunity: Opportunity) -> Proposal:
        # 并行收集信息
        info = asyncio.gather(
            self.get_customer_context(opportunity.customer),
            self.get_product_solution(opportunity.requirements),
            self.get_pricing(opportunity.products, opportunity.volume),
            self.get_legal_terms(opportunity.deal_type, opportunity.risk_level),
            self.get_case_studies(opportunity.industry, opportunity.use_case)
        )
        
        # 生成提案结构
        proposal = Proposal()
        proposal.executive_summary = self.generate_summary(info)
        proposal.customer_challenges = self.identify_challenges(info.customer_context)
        proposal.proposed_solution = self.describe_solution(info.product_solution)
        proposal.implementation_plan = self.create_timeline(info.solution)
        proposal.investment = self.format_pricing(info.pricing)
        proposal.terms_conditions = info.legal_terms
        proposal.case_studies = self.select_relevant_cases(info.case_studies)
        proposal.next_steps = self.suggest_next_steps(opportunity)
        
        # 个性化定制
        proposal = self.personalize(proposal, opportunity.customer.decision_makers)
        
        return proposal
    
    def personalize(self, proposal: Proposal, decision_makers: List[Contact]) -> Proposal:
        """根据决策人的偏好个性化提案"""
        
        for dm in decision_makers:
            if dm.role == "CFO":
                # CFO 关注 ROI 和成本
                proposal.add_section("Financial Impact Analysis")
                proposal.highlight("cost_savings")
                proposal.highlight("roi_calculation")
            
            elif dm.role == "CTO":
                # CTO 关注技术架构
                proposal.add_section("Technical Architecture")
                proposal.highlight("security_compliance")
                proposal.highlight("scalability")
            
            elif dm.role == "CEO":
                # CEO 关注战略价值
                proposal.add_section("Strategic Value")
                proposal.highlight("competitive_advantage")
                proposal.highlight("market_expansion")
        
        return proposal

class DataCaptureEngine:
    """自动捕获客户互动数据"""
    
    def capture_email_interaction(self, email: Email):
        """分析邮件并更新 CRM"""
        
        # 提取信息
        extracted = {
            "sentiment": self.analyze_sentiment(email.body),
            "key_topics": self.extract_topics(email.body),
            "action_items": self.extract_action_items(email.body),
            "next_steps": self.identify_commitments(email.body)
        }
        
        # 自动更新 CRM
        self.crm.update_contact(email.sender, {
            "last_contact": email.date,
            "sentiment": extracted["sentiment"],
            "topics": extracted["key_topics"]
        })
        
        # 创建活动记录
        self.crm.create_activity({
            "type": "Email",
            "contact": email.sender,
            "summary": self.summarize(email.body),
            "action_items": extracted["action_items"],
            "follow_up_required": extracted["next_steps"] is not None
        })

class RecommendationEngine:
    """智能推荐引擎"""
    
    def recommend_next_actions(self, customer: Customer) -> List[Recommendation]:
        recommendations = []
        
        # 基于客户状态的推荐
        if customer.days_since_last_contact > 7:
            recommendations.append({
                "action": "send_follow_up_email",
                "priority": "HIGH",
                "reason": "7 天未联系",
                "template": self.select_template(customer),
                "timing": self.optimize_timing(customer)
            })
        
        # 基于商机的推荐
        for opp in customer.opportunities:
            if opp.stage == "PROPOSAL_SENT" and opp.days_in_stage > 7:
                recommendations.append({
                    "action": "schedule_proposal_review_call",
                    "priority": "HIGH",
                    "reason": f"提案已发送 {opp.days_in_stage} 天，需要跟进",
                    "talking_points": self.generate_talking_points(opp)
                })
        
        # 基于客户信号的推荐
        signals = self.monitor_signals(customer)
        for signal in signals:
            recommendations.append(self.recommend_based_on_signal(signal))
        
        # 排序
        return sorted(recommendations, key=lambda x: x["priority"])