Analyzing customer service calls

from edsl import QuestionFreeText, QuestionList

# Construct questions in the relevant question type templates
# Use a placeholder for the transcripts to be reviewed
q_name = QuestionFreeText(
    question_name="name",
    question_text="""
    What is caller's name? Transcript: {{ scenario.transcript }}
    Return just the name of the caller.
    """,
)

q_email = QuestionFreeText(
    question_name="email",
    question_text="""What is caller's email address? Transcript: {{ scenario.transcript }}
    Return just the email address.
    """,
)

q_questions = QuestionList(
    question_name="questions",
    question_text="What questions does the caller have? Transcript: {{ scenario.transcript }}?",
)

q_requests = QuestionList(
    question_name="requests",
    question_text="What is the caller requesting? Transcript: {{ scenario.transcript }}?",
)

from edsl import Survey

survey = Survey([q_name, q_email, q_questions, q_requests])

from edsl import FileStore

csv_file = FileStore.pull('01474c60-d02b-4874-a577-953e870d8bff')

from edsl import ScenarioList, Scenario

scenarios = ScenarioList.from_source("csv", csv_file.to_tempfile())

defaultdict(<function DelimitedFileSource.to_scenario_list.<locals>.<lambda> at 0x1234242c0>, {})

scenarios

ScenarioList scenarios: 10; keys: ['transcript'];

from edsl import Agent

agent = Agent(
    traits={"persona": "Customer service agent"},
    instruction="You are answering questions about transcripts of customer service calls.",
)

from edsl import Model

Model.services()

Model()

LanguageModel

model = Model("gpt-4o", servive_name = "google")

results = survey.by(scenarios).by(agent).by(model).run()

results.select("name", "email", "questions", "requests")

caller_questions = results.select("questions").to_list(flatten=True)
len(caller_questions)

19

caller_requests = results.select("requests").to_list(flatten=True)
len(caller_requests)

22

q_condense = QuestionList(
    question_name="condense",
    question_text="""
    You have reviewed a set of call transcripts and compiled a detailed list of {{ scenario.topic }}.
    Now you are being asked to condense this list into a more generalized but comprehensive
    list that can be used to quanitfy the {{ scenario.topic }} efficiently (i.e., combine like items
    on the list). Here is the list to be condensed: {{ scenario.list }}
    """,
    max_list_items=10,  # Optional
)

scenarios = ScenarioList([
    Scenario({"topic": "caller questions", "list": caller_questions}),
    Scenario({"topic": "caller requests", "list": caller_requests}),
])

condensed_lists = q_condense.by(scenarios).run()

condensed_lists.select("topic", "condense")

condensed_questions = (
    condensed_lists.filter("topic == 'caller questions'").select("condense").first()
)
condensed_questions

['Technical issues with software features',
 'Version and update inquiries',
 'Account access and password issues',
 'Guides and instructional resources',
 'Project collaboration and team management',
 'Exporting and file management issues',
 'Cost estimation and project calculations',
 'Data access and retrieval issues',
 'Feedback and feature requests',
 'Trial period questions']

condensed_requests = (
    condensed_lists.filter("topic == 'caller requests'").select("condense").first()
)
condensed_requests

['Technical support and troubleshooting',
 'Account access and security',
 'Subscription and billing inquiries',
 'Feature usage tutorials and guides',
 'Project collaboration and management',
 'Software updates and version issues',
 'Exporting and file handling',
 'Automated tools and estimation',
 'Trial period information',
 'Remote support and follow-up']

from edsl import QuestionCheckBox

q_questions_agg = QuestionCheckBox(
    question_name="questions_agg",
    question_text="""
    Review the following call transcript and then identify the topic(s)
    that the caller has questions about. Transcript: {{ scenario.transcript }}
    """,
    question_options=condensed_questions + ["Something else", "None of these"],
)

q_requests_agg = QuestionCheckBox(
    question_name="requests_agg",
    question_text="""
    Review the following call transcript and then identify the topic(s)
    that the caller has requests about. Transcript: {{ scenario.transcript }}
    """,
    question_options=condensed_requests + ["Something else", "None of these"],
)

survey = Survey([q_questions_agg, q_requests_agg])

scenarios = results.select("name", "email", "transcript").to_scenario_list(
    remove_prefix=True
)
scenarios[0]

agg_results = survey.by(scenarios).by(agent).run()

agg_results.columns

agg_results.select("questions_agg", "requests_agg")

import matplotlib.pyplot as plt
import ast

df = agg_results.to_pandas(remove_prefix=True)

# Convert the string representations of lists to actual lists
df["questions_agg"] = df["questions_agg"].apply(ast.literal_eval)
df["requests_agg"] = df["requests_agg"].apply(ast.literal_eval)

# Explode the lists into individual rows
questions_exploded = df.explode("questions_agg")
requests_exploded = df.explode("requests_agg")

# Count the frequency of each item
questions_counts = questions_exploded["questions_agg"].value_counts().reset_index()
questions_counts.columns = ["Question", "Count"]

requests_counts = requests_exploded["requests_agg"].value_counts().reset_index()
requests_counts.columns = ["Request", "Count"]

# Plotting
fig, axes = plt.subplots(1, 2, figsize=(14, 7))

# Bar plot for questions
axes[0].barh(questions_counts["Question"], questions_counts["Count"], color="skyblue")
axes[0].set_title("Frequency of Questions")
axes[0].set_xlabel("Count")
axes[0].set_ylabel("Question")

# Bar plot for requests
axes[1].barh(requests_counts["Request"], requests_counts["Count"], color="lightgreen")
axes[1].set_title("Frequency of Requests")
axes[1].set_xlabel("Count")
axes[1].set_ylabel("Request")

plt.tight_layout()
plt.show()

# Display the counts
print("Questions Count Table:")
print(questions_counts)

print("nRequests Count Table:")
print(requests_counts)

Questions Count Table:
                                     Question  Count
0     Technical issues with software features      3
1                Version and update inquiries      2
2          Guides and instructional resources      2
3          Account access and password issues      1
4                              Something else      1
5        Exporting and file management issues      1
6   Project collaboration and team management      1
7    Cost estimation and project calculations      1
8            Data access and retrieval issues      1
9               Feedback and feature requests      1
10                     Trial period questions      1

Requests Count Table:
                                  Request  Count
0   Technical support and troubleshooting      4
1            Remote support and follow-up      3
2     Software updates and version issues      2
3      Feature usage tutorials and guides      2
4             Account access and security      2
5    Project collaboration and management      2
6      Subscription and billing inquiries      1
7             Exporting and file handling      1
8          Automated tools and estimation      1
9                          Something else      1
10               Trial period information      1

agg_results.to_csv("customer_calls_analysis.csv")

from edsl import Notebook

nb = Notebook(path = "summarizing_transcripts.ipynb")

nb.push(
    description = "Example code for summarizing transcripts",
    alias = "summarizing-transcripts-notebook",
    visibility = "public"
)