reply-prediction

For any given message, predict likelihood of:

Positive responses:
- "Yes, I'm interested"
- "Tell me more"
- "Let's schedule a call"

Neutral responses:
- "What exactly do you do?"
- "How is this different from X?"
- "I need to check with my team"

Negative responses:
- "Not interested"
- "We already have a solution"
- "Bad timing"

No response:
- Probability of no reply

Predict specific content:

Questions likely to be asked:
- Pricing questions
- Feature questions
- Comparison questions
- Implementation questions

Objections likely to be raised:
- Budget concerns
- Timing concerns
- Authority concerns
- Competitor mentions

Information likely to be shared:
- Company details
- Pain point specifics
- Timeline information

class ReplyPredictor:
    def __init__(self, model):
        self.model = model
        self.predictions = {}
 
    def predict_responses(self, context):
        """Generate probability distribution of likely responses"""
 
        features = extract_features(context)
 
        predictions = {
            "positive_interest": 0,
            "question_pricing": 0,
            "question_features": 0,
            "question_comparison": 0,
            "objection_timing": 0,
            "objection_budget": 0,
            "objection_competitor": 0,
            "not_interested": 0,
            "no_response": 0
        }
 
        # Use model to predict probabilities
        probabilities = self.model.predict_proba(features)
 
        for response_type, prob in zip(self.model.classes_, probabilities):
            predictions[response_type] = prob
 
        return predictions
 
    def get_top_predictions(self, context, n=3):
        all_predictions = self.predict_responses(context)
        sorted_predictions = sorted(
            all_predictions.items(),
            key=lambda x: x[1],
            reverse=True
        )
        return sorted_predictions[:n]

def predict_from_history(message_template, prospect_segment):
    """Predict based on historical response patterns"""
 
    # Get historical responses to this template
    historical = get_historical_responses(
        template_id=message_template.id,
        segment=prospect_segment
    )
 
    # Calculate response distribution
    response_counts = Counter([r.response_type for r in historical])
    total = len(historical)
 
    predictions = {}
    for response_type, count in response_counts.items():
        predictions[response_type] = count / total
 
    # Get common response content
    content_patterns = extract_common_content(historical)
 
    return {
        "type_probabilities": predictions,
        "content_patterns": content_patterns,
        "sample_size": total
    }

def predict_with_context(context):
    """Adjust predictions based on conversation context"""
 
    base_predictions = predict_from_history(
        context.last_message.template,
        context.prospect.segment
    )
 
    # Adjust for conversation stage
    stage_adjustments = {
        "discovery": {"question_features": 0.2, "not_interested": -0.1},
        "evaluation": {"question_pricing": 0.3, "question_comparison": 0.2},
        "proposal": {"objection_budget": 0.2, "positive_interest": 0.1},
        "negotiation": {"objection_budget": 0.3, "positive_interest": 0.2}
    }
 
    adjustments = stage_adjustments.get(context.stage, {})
    adjusted = apply_adjustments(base_predictions, adjustments)
 
    # Adjust for prospect engagement
    if context.prospect.engagement_score > 70:
        adjusted["positive_interest"] *= 1.3
        adjusted["not_interested"] *= 0.5
 
    # Adjust for recent behavior
    if context.prospect.asked_pricing_before:
        adjusted["question_pricing"] *= 1.5
 
    return adjusted

PREDICTED_REPLY_TEMPLATES = {
    "positive_interest": {
        "replies": [
            "Great! What specifically caught your attention?",
            "Glad to hear it. Would a quick call or more info be more helpful right now?"
        ],
        "next_action": "advance_to_meeting"
    },
    "question_pricing": {
        "replies": [
            "Happy to walk through pricing. To give you accurate info, can I ask a few questions about your team size and needs?",
            "Pricing depends on a few factors. What's your team size, and what's most important to you in a solution?"
        ],
        "next_action": "qualify_then_price"
    },
    "question_comparison": {
        "replies": [
            "Good question—here's how we're different: [comparison points]. What matters most to you?",
            "We get asked that a lot. The main difference is [key differentiator]. What's driving the comparison?"
        ],
        "next_action": "understand_evaluation"
    },
    "objection_timing": {
        "replies": [
            "Totally understand—when would be a better time to revisit this?",
            "Makes sense. If I check back in [timeframe], would that work better?"
        ],
        "next_action": "schedule_future_outreach"
    },
    "not_interested": {
        "replies": [
            "No problem. Mind if I ask what's not a fit? Helps me know if I should reach out again in the future.",
            "Understood. If anything changes, feel free to reach out. Best of luck!"
        ],
        "next_action": "disqualify_or_nurture"
    }
}

def select_preloaded_reply(actual_response, predictions, context):
    """Match actual response to predictions and select reply"""
 
    # Classify actual response
    response_type = classify_response(actual_response)
 
    # Check if we predicted this
    if response_type in predictions and predictions[response_type] > 0.1:
        # Use preloaded reply
        template = PREDICTED_REPLY_TEMPLATES.get(response_type)
        if template:
            reply = select_best_reply(template["replies"], context)
            return {
                "reply": reply,
                "source": "predicted",
                "confidence": predictions[response_type]
            }
 
    # Fall back to real-time generation
    return {
        "reply": generate_reply_realtime(actual_response, context),
        "source": "generated",
        "confidence": None
    }

def precompute_replies(conversation):
    """Precompute replies before response arrives"""
 
    # Get predictions
    predictions = predict_responses(conversation.context)
    top_predictions = get_top_predictions(predictions, n=5)
 
    # Generate and cache replies
    cached_replies = {}
    for response_type, probability in top_predictions:
        if probability > 0.05:  # Only cache if >5% probability
            template = PREDICTED_REPLY_TEMPLATES.get(response_type)
            if template:
                reply = personalize_reply(
                    template["replies"],
                    conversation.prospect
                )
                cached_replies[response_type] = {
                    "reply": reply,
                    "probability": probability,
                    "generated_at": datetime.now()
                }
 
    # Store in cache
    cache_key = f"replies:{conversation.id}"
    cache.set(cache_key, cached_replies, ttl=3600)
 
    return cached_replies

def get_reply_for_response(conversation_id, actual_response):
    """Retrieve cached reply if available"""
 
    cache_key = f"replies:{conversation_id}"
    cached = cache.get(cache_key)
 
    if not cached:
        return None
 
    # Match response to cached predictions
    response_type = classify_response(actual_response)
 
    if response_type in cached:
        return cached[response_type]
 
    return None

def track_prediction_accuracy(conversation_id, predicted, actual):
    """Track how accurate predictions were"""
 
    log_prediction_result(
        conversation_id=conversation_id,
        predicted_type=max(predicted, key=predicted.get),
        predicted_probability=max(predicted.values()),
        actual_type=actual,
        correct=actual == max(predicted, key=predicted.get)
    )
 
    # Update model if enough data
    if should_retrain_model():
        retrain_prediction_model()

def improve_predictions(results):
    """Use outcomes to improve prediction model"""
 
    for result in results:
        # Was predicted reply effective?
        if result["source"] == "predicted":
            effectiveness = measure_reply_effectiveness(result)
 
            if effectiveness < THRESHOLD:
                # Flag reply for review
                flag_for_review(
                    response_type=result["response_type"],
                    reply=result["reply"],
                    effectiveness=effectiveness
                )
 
    # Aggregate learnings
    improvement_suggestions = analyze_prediction_patterns(results)
    return improvement_suggestions

Track:
- Prediction accuracy (did we predict right type?)
- Reply match rate (how often was cached reply used?)
- Response time improvement
- Reply effectiveness by source (predicted vs generated)

Optimize:
- Which responses are predictable?
- Where do we need better predictions?
- Which templates perform best?