Sample Page Title

!pip set up anthropic pandas scikit-learn

import os
import json
import time
import pandas as pd
import numpy as np
from anthropic import Anthropic
from IPython.show import show, Markdown
from sklearn.metrics import classification_report

ANTHROPIC_API_KEY = "{Your API KEY}"
shopper = Anthropic(api_key=ANTHROPIC_API_KEY)

customer_queries = [
   {"id": 1, "query": "What are your business hours?", "category": "General Question"},
   {"id": 2, "query": "How do I reset my password?", "category": "Technical Support"},
   {"id": 3, "query": "I want a refund for my purchase.", "category": "Refund Request"},
   {"id": 4, "query": "Where can I find your privacy policy?", "category": "General Question"},
   {"id": 5, "query": "The app keeps crashing when I try to upload photos.", "category": "Technical Support"},
   {"id": 6, "query": "I ordered the wrong size, can I get my money back?", "category": "Refund Request"},
   {"id": 7, "query": "Do you ship internationally?", "category": "General Question"},
   {"id": 8, "query": "My account is showing incorrect information.", "category": "Technical Support"},
   {"id": 9, "query": "I was charged twice for my order.", "category": "Refund Request"},
   {"id": 10, "query": "What payment methods do you accept?", "category": "General Question"}
]

df = pd.DataFrame(customer_queries)
show(df)

def route_query(question, shopper):
   """
   Route a buyer question to the suitable class utilizing Claude 3.5 Haiku.
  
   Args:
       question (str): The shopper question to categorise
       shopper: Anthropic shopper
  
   Returns:
       str: The labeled class
   """
   system_prompt = """
   You're a question classifier for a customer support system.
   Your job is to categorize buyer queries into precisely one in every of these classes:
   1. Basic Query - Fundamental inquiries in regards to the firm, merchandise, insurance policies, and so on.
   2. Refund Request - Any question associated to refunds, returns, or billing points
   3. Technical Assist - Questions on technical issues, bugs, or find out how to use merchandise
  
   Reply with ONLY the class title, nothing else.
   """
  
   strive:
       response = shopper.messages.create(
           mannequin="claude-3-7-sonnet-20250219",
           max_tokens=1024,
           system=system_prompt,
           messages=[{"role": "user", "content": query}]
       )
      
       class = response.content material[0].textual content.strip()
      
       valid_categories = ["General Question", "Refund Request", "Technical Support"]
       for valid_cat in valid_categories:
           if valid_cat.decrease() in class.decrease():
               return valid_cat
      
       return "Basic Query"
  
   besides Exception as e:
       print(f"Error in routing: {e}")
       return "Basic Query"

def handle_general_question(question, shopper):
   """Deal with basic inquiries utilizing Claude 3.5 Haiku."""
   system_prompt = """
   You're a customer support consultant answering basic questions on our firm.
   Be useful, concise, and pleasant. Present direct solutions to buyer queries.
   """
  
   strive:
       response = shopper.messages.create(
           mannequin="claude-3-7-sonnet-20250219",
           max_tokens=1024,
           system=system_prompt,
           messages=[{"role": "user", "content": query}]
       )
       return response.content material[0].textual content.strip()
   besides Exception as e:
       print(f"Error normally query handler: {e}")
       return "I apologize, however I am having hassle processing your request. Please strive once more later."

def handle_refund_request(question, shopper):
   """Deal with refund requests utilizing Claude 3.5 Sonnet for extra nuanced responses."""
   system_prompt = """
   You're a customer support consultant specializing in refunds and billing points.
   Reply to refund requests professionally and helpfully.
   For any refund request, clarify the refund coverage clearly and supply subsequent steps.
   Be empathetic however comply with firm coverage.
   """
  
   strive:
       response = shopper.messages.create(
           mannequin="claude-3-7-sonnet-20250219",
           max_tokens=1024,
           system=system_prompt,
           messages=[{"role": "user", "content": query}]
       )
       return response.content material[0].textual content.strip()
   besides Exception as e:
       print(f"Error in refund request handler: {e}")
       return "I apologize, however I am having hassle processing your refund request. Please contact our assist workforce instantly."

def handle_technical_support(question, shopper):
   """Deal with technical assist queries utilizing Claude 3.5 Sonnet for extra detailed technical responses."""
   system_prompt = """
   You're a technical assist specialist.
   Present clear, step-by-step options to technical issues.
   In case you want extra data to resolve a difficulty, specify what data you want.
   Prioritize easy options first earlier than suggesting complicated troubleshooting.
   """
  
   strive:
       response = shopper.messages.create(
          mannequin="claude-3-7-sonnet-20250219",
           max_tokens=1024,
           system=system_prompt,
           messages=[{"role": "user", "content": query}]
       )
       return response.content material[0].textual content.strip()
   besides Exception as e:
       print(f"Error in technical assist handler: {e}")
       return "I apologize, however I am having hassle processing your technical assist request. Please strive our information base or contact our assist workforce."

def process_customer_query(question, shopper):
   """
   Course of a buyer question by means of the entire routing workflow.
  
   Args:
       question (str): The shopper question
       shopper: Anthropic shopper
  
   Returns:
       dict: Details about the question processing, together with class and response
   """
   start_time = time.time()
   class = route_query(question, shopper)
   routing_time = time.time() - start_time
  
   start_time = time.time()
   if class == "Basic Query":
       response = handle_general_question(question, shopper)
       model_used = "claude-3-5-haiku-20240307"
   elif class == "Refund Request":
       response = handle_refund_request(question, shopper)
       model_used = "claude-3-5-sonnet-20240620"
   elif class == "Technical Assist":
       response = handle_technical_support(question, shopper)
       model_used = "claude-3-5-sonnet-20240620"
   else:
       response = handle_general_question(question, shopper) 
       model_used = "claude-3-5-haiku-20240307"
  
   handling_time = time.time() - start_time
   total_time = routing_time + handling_time
  
   return {
       "question": question,
       "routed_category": class,
       "response": response,
       "model_used": model_used,
       "routing_time": routing_time,
       "handling_time": handling_time,
       "total_time": total_time
   }

outcomes = []


for _, row in df.iterrows():
   question = row['query']
   outcome = process_customer_query(question, shopper)
   outcome["actual_category"] = row['category']
   outcomes.append(outcome)


results_df = pd.DataFrame(outcomes)
show(results_df[["query", "actual_category", "routed_category", "model_used", "total_time"]])


accuracy = (results_df["actual_category"] == results_df["routed_category"]).imply()
print(f"Routing Accuracy: {accuracy:.2%}")


from sklearn.metrics import classification_report
print(classification_report(results_df["actual_category"], results_df["routed_category"]))

simulated_results = []
for _, row in df.iterrows():
   question = row['query']
   actual_category = row['category']
  
   if "hours" in question.decrease() or "coverage" in question.decrease() or "ship" in question.decrease() or "fee" in question.decrease():
       routed_category = "Basic Query"
       model_used = "claude-3-5-haiku-20240307"
   elif "refund" in question.decrease() or "a refund" in question.decrease() or "charged" in question.decrease():
       routed_category = "Refund Request"
       model_used = "claude-3-5-sonnet-20240620"
   else:
       routed_category = "Technical Assist"
       model_used = "claude-3-5-sonnet-20240620"
  
   simulated_results.append({
       "question": question,
       "actual_category": actual_category,
       "routed_category": routed_category,
       "model_used": model_used,
       "routing_time": np.random.uniform(0.2, 0.5),
       "handling_time": np.random.uniform(0.5, 2.0)
   })


simulated_df = pd.DataFrame(simulated_results)
simulated_df["total_time"] = simulated_df["routing_time"] + simulated_df["handling_time"]
show(simulated_df[["query", "actual_category", "routed_category", "model_used", "total_time"]])

accuracy = (simulated_df["actual_category"] == simulated_df["routed_category"]).imply()
print(f"Simulated Routing Accuracy: {accuracy:.2%}")


print(classification_report(simulated_df["actual_category"], simulated_df["routed_category"]))

from IPython.show import HTML, show, clear_output
from ipywidgets import widgets


def create_demo_interface():
   query_input = widgets.Textarea(
       worth="",
       placeholder="Enter your customer support question right here...",
       description='Question:',
       disabled=False,
       format=widgets.Format(width="80%", top="100px")
   )
  
   output = widgets.Output()
  
   button = widgets.Button(
       description='Course of Question',
       disabled=False,
       button_style="major",
       tooltip='Click on to course of the question',
       icon='test'
   )
  
   def on_button_clicked(b):
       with output:
           clear_output()
           question = query_input.worth
          
           if not question.strip():
               print("Please enter a question.")
               return
          
           if "hours" in question.decrease() or "coverage" in question.decrease() or "ship" in question.decrease() or "fee" in question.decrease():
               class = "Basic Query"
               mannequin = "claude-3-5-haiku-20240307"
               response = "Our commonplace enterprise hours are Monday by means of Friday, 9 AM to six PM Japanese Time. Our customer support workforce is out there throughout these hours to help you."
           elif "refund" in question.decrease() or "a refund" in question.decrease() or "charged" in question.decrease():
               class = "Refund Request"
               mannequin = "claude-3-5-sonnet-20240620"
               response = "I perceive you are searching for a refund. Our refund coverage permits returns inside 30 days of buy with a sound receipt. To provoke your refund, please present your order quantity and the rationale for the return."
           else:
               class = "Technical Assist"
               mannequin = "claude-3-5-sonnet-20240620"
               response = "I am sorry to listen to you are experiencing technical points. Let's troubleshoot this step-by-step. First, strive restarting the appliance. If that does not work, please test if the app is up to date to the most recent model."
          
           print(f"Routed to: {class}")
           print(f"Utilizing mannequin: {mannequin}")
           print("nResponse:")
           print(response)
  
   button.on_click(on_button_clicked)
  
   return widgets.VBox([query_input, button, output])

def advanced_route_query(question, shopper):
   """
   A sophisticated routing operate that features confidence scores and fallback mechanisms.
  
   Args:
       question (str): The shopper question to categorise
       shopper: Anthropic shopper
  
   Returns:
       dict: Classification outcome with class and confidence
   """
   system_prompt = """
   You're a question classifier for a customer support system.
   Your job is to categorize buyer queries into precisely one in every of these classes:
   1. Basic Query - Fundamental inquiries in regards to the firm, merchandise, insurance policies, and so on.
   2. Refund Request - Any question associated to refunds, returns, or billing points
   3. Technical Assist - Questions on technical issues, bugs, or find out how to use merchandise
  
   Reply in JSON format with:
   1. "class": The most certainly class
   2. "confidence": A confidence rating between 0 and 1
   3. "reasoning": A short clarification of your classification
  
   Instance response:
   {
       "class": "Basic Query",
       "confidence": 0.85,
       "reasoning": "The question asks about enterprise hours, which is primary firm data."
   }
   """
  
   strive:
       response = shopper.messages.create(
           mannequin="claude-3-5-sonnet-20240620", 
           max_tokens=150,
           system=system_prompt,
           messages=[{"role": "user", "content": query}]
       )
      
       response_text = response.content material[0].textual content.strip()


       strive:
           outcome = json.hundreds(response_text)
           if "class" not in outcome or "confidence" not in outcome:
               elevate ValueError("Incomplete classification outcome")
              
           return outcome
       besides json.JSONDecodeError:
           print("Didn't parse JSON response. Utilizing easy classification.")
           if "basic" in response_text.decrease():
               return {"class": "Basic Query", "confidence": 0.6, "reasoning": "Fallback classification"}
           elif "refund" in response_text.decrease():
               return {"class": "Refund Request", "confidence": 0.6, "reasoning": "Fallback classification"}
           else:
               return {"class": "Technical Assist", "confidence": 0.6, "reasoning": "Fallback classification"}
  
   besides Exception as e:
       print(f"Error in superior routing: {e}")
       return {"class": "Basic Query", "confidence": 0.3, "reasoning": "Error fallback"}

def advanced_process_customer_query(question, shopper, confidence_threshold=0.7):
   """
   Course of a buyer question with confidence-based routing.
  
   Args:
       question (str): The shopper question
       shopper: Anthropic shopper
       confidence_threshold (float): Minimal confidence rating for automated routing
  
   Returns:
       dict: Details about the question processing
   """
   start_time = time.time()
  
  
   if "hours" in question.decrease() or "coverage" in question.decrease() or "ship" in question.decrease() or "fee" in question.decrease():
       classification = {
           "class": "Basic Query",
           "confidence": np.random.uniform(0.7, 0.95),
           "reasoning": "Question associated to enterprise data"
       }
   elif "refund" in question.decrease() or "a refund" in question.decrease() or "charged" in question.decrease():
       classification = {
           "class": "Refund Request",
           "confidence": np.random.uniform(0.7, 0.95),
           "reasoning": "Question mentions refunds or billing points"
       }
   elif "password" in question.decrease() or "crash" in question.decrease() or "account" in question.decrease():
       classification = {
           "class": "Technical Assist",
           "confidence": np.random.uniform(0.7, 0.95),
           "reasoning": "Question mentions technical issues"
       }
   else:
       classes = ["General Question", "Refund Request", "Technical Support"]
       classification = {
           "class": np.random.alternative(classes),
           "confidence": np.random.uniform(0.4, 0.65),
           "reasoning": "Unsure classification"
       }
  
   routing_time = time.time() - start_time
  
   start_time = time.time()
  
   if classification["confidence"] >= confidence_threshold:
       class = classification["category"]
       if class == "Basic Query":
           response = "SIMULATED GENERAL QUESTION RESPONSE: I might be joyful to assist along with your query about our enterprise."
           model_used = "claude-3-5-haiku-20240307"
       elif class == "Refund Request":
           response = "SIMULATED REFUND REQUEST RESPONSE: I perceive you are searching for a refund. Let me assist you to with that course of."
           model_used = "claude-3-5-sonnet-20240620"
       elif class == "Technical Assist":
           response = "SIMULATED TECHNICAL SUPPORT RESPONSE: I see you are having a technical difficulty. Let's troubleshoot this collectively."
           model_used = "claude-3-5-sonnet-20240620"
       else:
           response = "I apologize, however I am undecided find out how to categorize your request."
           model_used = "claude-3-5-sonnet-20240620"
   else:
       response = "SIMULATED ESCALATION RESPONSE: Your question requires particular consideration. I am going to have our superior assist system assist you to with this complicated request."
       model_used = "claude-3-5-sonnet-20240620"
       class = "Escalated (Low Confidence)"
  
   handling_time = time.time() - start_time
   total_time = routing_time + handling_time
  
   return {
       "question": question,
       "routed_category": classification["category"],
       "confidence": classification["confidence"],
       "reasoning": classification["reasoning"],
       "final_category": class,
       "response": response,
       "model_used": model_used,
       "routing_time": routing_time,
       "handling_time": handling_time,
       "total_time": total_time
   }

test_queries = [
   "What are your business hours?",
   "I need a refund for my order #12345",
   "My app keeps crashing when I try to save photos",
   "I received the wrong item in my shipment",
   "How do I change my shipping address?",
   "I'm not sure if my payment went through",
   "The product description was misleading"
]


advanced_results = []
for question in test_queries:
   outcome = advanced_process_customer_query(question, None, 0.7)
   advanced_results.append(outcome)


advanced_df = pd.DataFrame(advanced_results)
show(advanced_df[["query", "routed_category", "confidence", "final_category", "model_used"]])


print("nRouting Distribution:")
print(advanced_df["final_category"].value_counts())


print(f"nAverage Confidence: {advanced_df['confidence'].imply():.2f}")


escalated = (advanced_df["final_category"] == "Escalated (Low Confidence)").sum()
print(f"Escalated Queries: {escalated} ({escalated/len(advanced_df):.1%})")

def calculate_routing_metrics(results_df):
   """
   Calculate key metrics for routing efficiency.
  
   Args:
       results_df (DataFrame): Outcomes of routing assessments
  
   Returns:
       dict: Key efficiency metrics
   """
   metrics = {
       "total_queries": len(results_df),
       "avg_routing_time": results_df["routing_time"].imply(),
       "avg_handling_time": results_df["handling_time"].imply(),
       "avg_total_time": results_df["total_time"].imply(),
       "avg_confidence": results_df["confidence"].imply(),
       "escalation_rate": (results_df["final_category"] == "Escalated (Low Confidence)").imply(),
   }
  
   category_distribution = results_df["routed_category"].value_counts(normalize=True).to_dict()
   metrics["category_distribution"] = category_distribution
  
   return metrics

metrics = calculate_routing_metrics(advanced_df)


print("Routing System Efficiency Metrics:")
print(f"Whole Queries: {metrics['total_queries']}")
print(f"Common Routing Time: {metrics['avg_routing_time']:.3f} seconds")
print(f"Common Dealing with Time: {metrics['avg_handling_time']:.3f} seconds")
print(f"Common Whole Time: {metrics['avg_total_time']:.3f} seconds")
print(f"Common Confidence: {metrics['avg_confidence']:.2f}")
print(f"Escalation Price: {metrics['escalation_rate']:.1%}")
print("nCategory Distribution:")
for class, share in metrics["category_distribution"].objects():
   print(f"  {class}: {share:.1%}")