1. Introduction
Contact centers are the front lines of customer interaction, generating vast amounts of valuable data through chat logs, call transcripts, and emails. However, manually sifting through this data to find actionable insights is often a monumental task. Imagine the scenario of a thriving online service, like a food delivery app: as usage climbs, so does the number of customer support chats, making it incredibly difficult to pinpoint recurring problems or gauge overall satisfaction from the sea of text. How can businesses effectively tap into this wealth of information?
This post explores a powerful solution: building an automated analytics platform using Azure Communication Services (ACS) combined with the intelligence of Azure OpenAI Service. We'll outline how this integration allows businesses to process, understand, and derive actionable insights from their contact center conversations at scale, transforming raw data into a strategic asset.
(Why This Azure Stack for Analytics?)
Combining ACS and Azure OpenAI offers a compelling approach for contact center analytics:
- Azure Communication Services (ACS): Provides a comprehensive cloud-based platform. In terms of analytics, it serves as the central hub for chat interactions or where transcripts are ingested and stored within organized threads, ready for programmatic access via its SDKs.
- Azure OpenAI Service: Offers secure access to advanced large language models (such as GPT-4). These models excel in understanding context, summarizing extensive texts, extracting key information, and analyzing sentiment, making them ideal for processing unstructured conversation data automatically.
What We'll Cover:
- Setting up Azure OpenAI and Azure Communication Services.
- Finding and configuring necessary credentials (Endpoints, Keys, Connection Strings).
- Setting up your streamlit environment.
- Writing Python code to retrieve chat messages from ACS.
- Crafting prompts to instruct Azure OpenAI for analysis (summary, topic, sentiment).
- Calling the Azure OpenAI API.
- Processing the AI-generated insights.
2. Architecture
2.1. Data Flow:
- The user interacts with the Streamlit application.
- When instructed (e.g., by a button click or automatically), the Streamlit application uses the ACS SDK to fetch chat messages from relevant threads within the Azure Communication Services.
- The Streamlit application prepares the chat data and formulates prompts based on the desired analysis (e.g., summarize, extract topics, analyze sentiment).
- These prompts and the chat data are sent to the Azure OpenAI Service.
- Azure OpenAI processes the information using its LLMs and returns the analysis results (summary, topics, sentiment) to the Streamlit application.
- The Streamlit application receives the analysis results and formats them for display in the user interface, alongside the original chat messages.
2.2. Prerequisites
Before you begin, ensure you have the following:
- Python: Version 3.9 or later installed.
- Azure Account: An active Azure subscription. If you're new, you can create a free account with credits.
- Azure OpenAI Access: Your Azure subscription must have access enabled for Azure OpenAI Service. You can request access here: https://aka.ms/oaiapply
- Code Editor/Environment: An IDE like VS Code
3. Setting Up Azure Resources
We need two core Azure services: Azure OpenAI (for the AI model) and Azure Communication Services (to access chat data).
3.1 Azure OpenAI Service
- Requirement: You need an existing Azure OpenAI resource and a deployed model (like gpt-35-turbo, gpt-4, gpt-4o, gpt-4o).
- Action: If you don't have one, follow the Microsoft documentation to Create and deploy an Azure OpenAI Service resource.1
- Collect Credentials: Once deployed, navigate to your Azure OpenAI resource in the Azure Portal. Go to the "Keys and Endpoint" section. You will need to copy:
- One of the API Keys (AZURE_OPENAI_API_KEY)
- The Endpoint URL (AZURE_OPENAI_ENDPOINT)
- You also need the Deployment Name you gave your model (AZURE_OPENAI_DEPLOYMENT_NAME).
- Note the API Version you intend to use (e.g., 2024-05-01-preview).
3.2 Azure Communication Services (ACS)
This service will store or provide access to the chat threads we want to analyze.
- Action: Create the ACS Resource
- Log in to the Azure Portal.
- In the top search bar, type Communication Services and select it from the results.
On the Communication Services page, click the "+ Create" button. (Alternatively: Click "+ Create a resource", search for "Communication Services" in the Marketplace, select it, and click "Create").
-
- Once you click on Create, you get the option to select from the list of services. Select Communication Services from the dropdown, as shown here:
-
- Once you land on the Communication Services page, you need to click on the Create button, as shown here:
-
- Once you’ve successfully created the Communication Service from the Marketplace, move on to the next step. On the Create resource form, choose the subscription and resource group that you set up back
- Tags Tab (Optional): You can add tags for organization or billing purposes, but it's not required for this tutorial. Click "Next: Review + create".
-
- Review + create Tab: Azure will validate your settings. Once validation passes, review the details and click the "Create" button.
- Wait for the deployment to complete. You'll see a notification when it's done.
- Action: Find ACS Credentials
- Once deployed, click "Go to resource" or find your newly created Communication Services resource via the search bar or resource groups.
- In the resource menu (left-hand side), under "Settings", click on "Keys".
- On the Keys page, you will find:
- The Endpoint URL.
- Two Connection Strings (Primary and Secondary). You only need one.
- Copy the Endpoint URL and one of the Connection String values. Keep these secure alongside your Azure OpenAI credentials.
4. Implementing the Streamlit Application Code
Now, we'll build the core of our application. Create a Python file named app.py (or your preferred name) in your project folder. We will add the code in logical sections.
4.1 Imports and Configuration Loading
First, we import all necessary libraries and load the configuration securely from our .env file. We also define some constants for sender names.
# --- Start of Streamlit App Code (app.py) ---
import streamlit as st
from azure.communication.chat import (
ChatClient, CommunicationTokenCredential, ChatMessageType,
ChatParticipant,
ChatThreadClient
)
from azure.communication.identity import CommunicationIdentityClient, CommunicationUserIdentifier
from azure.core.exceptions import ResourceExistsError, ResourceNotFoundError
from datetime import datetime, timedelta
import openai
import re
import os
import time
from dotenv import load_dotenv # Import dotenv
# --- Load Environment Variables ---
load_dotenv() # Load variables from .env file at the start
# --- Configuration ---
# Load from environment with error
checking
AZURE_OPENAI_API_KEY = os.getenv("AZURE_OPENAI_API_KEY")
AZURE_OPENAI_ENDPOINT = os.getenv("AZURE_OPENAI_ENDPOINT")
AZURE_API_VERSION = os.getenv("AZURE_API_VERSION",'2024-05-01-preview') # Provide
a default API version if needed
AZURE_OPENAI_DEPLOYMENT_NAME = os.getenv("AZURE_OPENAI_DEPLOYMENT_NAME") # Your
model deployment name
COMMUNICATION_CONNECTION_STRING = os.getenv("COMMUNICATION_CONNECTION_STRING")
COMMUNICATION_ENDPOINT = os.getenv("COMMUNICATION_ENDPOINT")
# --- Early check for critical
environment variables ---
# Stop execution if essential configs
are missing to prevent errors later
if not all([AZURE_OPENAI_API_KEY,
AZURE_OPENAI_ENDPOINT, AZURE_OPENAI_DEPLOYMENT_NAME,
COMMUNICATION_CONNECTION_STRING, COMMUNICATION_ENDPOINT]):
# Use st.error which is visible
in the Streamlit app
st.error("❌ Critical environment variables are missing! Please ensure AZURE_OPENAI_API_KEY,
AZURE_OPENAI_ENDPOINT, AZURE_OPENAI_DEPLOYMENT_NAME,
COMMUNICATION_CONNECTION_STRING, and COMMUNICATION_ENDPOINT are set in your
.env file or system environment.")
st.stop() # Halt script execution if
configuration is incomplete
# --- Application Specific Settings ---
TARGET_THREAD_TOPIC = "Streamlit ACS Interactive Demo V3" # Name for
the ACS chat thread
# --- Constants for Sender Display Names
---
SENDER_USER = "User
(via Streamlit)" # Display name for messages sent by the human user
SENDER_AI_AGENT = "AI Agent" #
Display name for messages generated by OpenAI
SENDER_SYSTEM = "System" # Display name for automated system messages
# --- Configure OpenAI library (using
v0.28.1 syntax) ---
# This configures the openai library
globally for this script run
openai.api_type = "azure"
openai.api_key = AZURE_OPENAI_API_KEY
openai.api_base = AZURE_OPENAI_ENDPOINT
openai.api_version = AZURE_API_VERSION
Explanation: This section imports necessary modules from Streamlit, Azure SDKs, OpenAI, and standard Python libraries. It uses dotenv to load credentials stored in the.env file into environment variables. A crucial check is added using st.error and st.stop() to halt the app gracefully if essential configuration values are missing. Finally, it defines constants for sender display names and configures the openai library to point to your Azure OpenAI resource using the loaded credentials (note this uses syntax for openai library version 0.x).
4.2 Helper Function: Parsing the AI Summary
This function takes the raw text output from the OpenAI summarization call and extracts structured information using regular expressions.
# --- Helper Function for Parsing Summary ---
def parse_summary(text):
""" Parses the
AI response for summary sections using regex. """
parsed = {
"Topic": "Not
found", "Summary": "Not
found",
"Highlights": "Not
found", "Sentiment": "Not
found"
}
if not text:
parsed["Error"] = "AI
returned no text to parse."
return
parsed
try:
# Regex patterns look for
Markdown headings (## Heading)
# re.DOTALL makes '.' match
newline characters within sections
topic_match = re.search(r"##\s*Topic\s*\n(.*?)(?=\n##\s*(Summary|Highlights|Sentiment)|$)", text, re.IGNORECASE | re.DOTALL)
if
topic_match: parsed["Topic"] = topic_match.group(1).strip()
summary_match = re.search(r"##\s*Summary\s*\n(.*?)(?=\n##\s*(Highlights|Sentiment)|$)", text, re.IGNORECASE | re.DOTALL)
if
summary_match: parsed["Summary"] = summary_match.group(1).strip()
highlights_match = re.search(r"##\s*Highlights\s*\n(.*?)(?=\n##\s*Sentiment|$)", text, re.IGNORECASE | re.DOTALL)
if
highlights_match: parsed["Highlights"] = highlights_match.group(1).strip()
sentiment_match = re.search(r"##\s*Sentiment\s*\n(.*)", text, re.IGNORECASE | re.DOTALL)
if
sentiment_match: parsed["Sentiment"] = sentiment_match.group(1).strip()
# Check if parsing failed
completely or partially
if all(v == "Not found" for k, v in
parsed.items() if
k not in ["RawOutput","Error", "Warning"]):
parsed["Error"] = "Could
not parse specific sections. Displaying raw output."
parsed["RawOutput"] = text # Include
raw output if parsing fails
elif any(v == "Not found" for k, v in
parsed.items() if
k not in ["RawOutput","Error", "Warning"]):
parsed["Warning"] = "AI
response formatting inconsistent; some sections might be missing."
except
Exception as
e:
st.exception(f"Error during summary
parsing: {e}") # Log full
error
parsed["Error"] = f"An
error occurred during parsing. Raw response:\n{text}"
parsed["RawOutput"] = text
parsed["Topic"], parsed["Summary"], parsed["Highlights"], parsed["Sentiment"] = "Error", "Error", "Error", "Error"
return
parsed
Explanation: The parse_summary function takes the text generated by the AI summarization prompt. It uses regular expressions (re.search) to find sections starting with markdown headings like ## Topic. It extracts the content under each heading and stores it in a dictionary. It includes error handling for cases where the AI output doesn't match the expected format, returning an Error or Warning key in the dictionary along with the raw output if possible.
4.3 Helper Function: Initializing Azure Clients and ACS Thread
This is a critical function that sets up connections to Azure services and creates the specific chat thread for the application session. It's decorated with st.cache_resource to ensure it only runs once per session, improving performance and preventing accidental resource recreation.
# --- Initialize Clients and Thread (Cached Resource)
---
@st.cache_resource # IMPORTANT: Caches the returned objects for the
session
def initialize_azure_clients_and_thread():
"""
Initializes Azure OpenAI & ACS clients, creates the chat thread for
this session.
Returns a dictionary containing clients, thread_id, and error status.
Cached by Streamlit to run only once per session unless cache is
cleared.
"""
initialization_details = {
"chat_client": None, "chat_thread_client": None,
"thread_id": None, "error": None
}
try:
# --- (Re)Configure OpenAI
library within function scope if needed, ---
# --- though global config
might suffice if not changing keys ---
# openai.api_key =
AZURE_OPENAI_API_KEY
# ... (rest of openai config)
...
# --- ACS Setup: Identity
Client, User, Token ---
st.sidebar.text("Initializing
ACS Identity...")
identity_client =
CommunicationIdentityClient.from_connection_string(COMMUNICATION_CONNECTION_STRING)
user_streamlit = identity_client.create_user()
token_streamlit = identity_client.get_token(user_streamlit, ["chat"])
st.sidebar.text("ACS
Identity Ready.")
# --- Define Participant for
the Thread ---
participant_streamlit_user = ChatParticipant(
identifier=user_streamlit,
display_name=SENDER_USER,
share_history_time=datetime.utcnow() - timedelta(days=1)
)
participants = [participant_streamlit_user]
# --- Create base ACS Chat
Client ---
st.sidebar.text("Initializing
ACS Chat Client...")
chat_client_streamlit = ChatClient(COMMUNICATION_ENDPOINT,
CommunicationTokenCredential(token_streamlit.token))
initialization_details["chat_client"] = chat_client_streamlit
st.sidebar.text("ACS
Chat Client Ready.")
# --- Create the ACS Chat
Thread ---
thread_id = None
st.sidebar.text(f"Creating
ACS Thread ('{TARGET_THREAD_TOPIC}')...")
try:
create_thread_result =
chat_client_streamlit.create_chat_thread(
topic=TARGET_THREAD_TOPIC,
thread_participants=participants
)
thread_id =
create_thread_result.chat_thread.id
initialization_details["thread_id"] = thread_id
st.sidebar.success(f"Thread Created:\nID: {thread_id[:12]}...", icon="✅")
#
--- Get Thread-Specific Client ---
chat_thread_client_temp =
chat_client_streamlit.get_chat_thread_client(thread_id)
#
--- Send Initial Messages ---
st.sidebar.text("Sending initial messages...")
try:
chat_thread_client_temp.send_message(f"Chat
thread '{TARGET_THREAD_TOPIC}' started.",
sender_display_name=SENDER_SYSTEM)
time.sleep(0.5) # Small delay helps messages appear in order
chat_thread_client_temp.send_message("Hello!
I am your AI assistant. How can I help?",
sender_display_name=SENDER_AI_AGENT)
st.sidebar.info("Initial messages sent.", icon="✉️")
except Exception as msg_err:
st.sidebar.warning(f"Could not send initial messages: {msg_err}", icon="⚠️")
# --- Handle Thread Creation
Errors ---
except
ResourceExistsError:
st.sidebar.warning("Thread creation conflict
(ResourceExistsError).", icon="⚠️")
initialization_details["error"] = "Failed - Thread conflict."
return initialization_details
except
Exception as
e:
initialization_details["error"] = f"Error during thread creation: {e}"
st.exception(e)
return initialization_details
if not
thread_id:
initialization_details["error"] = "Thread ID is missing after
creation attempt."
return initialization_details
# --- Store the final
ChatThreadClient ---
chat_thread_client =
chat_client_streamlit.get_chat_thread_client(thread_id)
initialization_details["chat_thread_client"] = chat_thread_client
st.sidebar.text("Initialization
Complete.")
return
initialization_details
#
--- Handle Overall Initialization Errors ---
except
Exception as
e:
st.error("❌ Failed during Azure
client initialization process.")
st.exception(e)
initialization_details["error"] = f"Failed
overall initialization: {e}"
return
initialization_details
Explanation: This function performs the critical setup on the first run of the session.
st.cache_resource: Makes Streamlit store the returned dictionary (initialization_details) and reuse it on subsequent script reruns within the same user session, avoiding costly re-creation of clients and threads unless the cache is explicitly cleared (e.g., by the "Clear Chat" button).- ACS Identity: Connects to ACS, creates a unique user identity and a temporary chat access token for this specific app session.
- ACS Chat Client: Creates the main client object used to interact with the ACS chat service (e.g., creating/deleting threads).
- Thread Creation: Attempts to create a new chat thread in ACS with a defined topic and adds the app user as a participant. It handles potential errors if a thread creation conflicts.
- Initial Messages: Sends introductory messages from "System" and "AI Agent" to the newly created thread.
- Thread Client: Gets the specific
ChatThreadClientneeded to interact with messages within the created thread. - Return Value: Returns a dictionary containing the base client, the thread-specific client, the thread ID, and any error message encountered. Sidebar messages provide visual feedback during this process.
4.4 Helper Function: Getting the AI Agent's Response
This function encapsulates the logic for generating the AI's conversational reply.
# --- Helper Function to get AI chat response ---
def get_ai_agent_response(thread_client:
ChatThreadClient):
"""Fetches
history from ACS, formats it, calls OpenAI, returns AI response
text."""
if not
thread_client:
st.error("Cannot get AI response:
ChatThreadClient is not initialized.")
return "[Error: Chat client not available]"
try:
# 1. Fetch recent message
history from ACS thread
messages_for_prompt = []
history_limit = 20 # Limit
context window
message_iterator =
thread_client.list_messages(results_per_page=history_limit)
acs_messages = list(message_iterator)
acs_messages.reverse() # Process
oldest first for context
# 2. Format messages into
OpenAI ChatCompletion structure
for
msg in
acs_messages:
sender_name =
msg.sender_display_name
content = msg.content.message if
msg.content and
msg.content.message else ""
if not content: continue # Skip
empty messages
#
Map sender to OpenAI role (user/assistant)
if sender_name == SENDER_AI_AGENT: role = "assistant"
elif sender_name == SENDER_USER: role = "user"
else: role = "user"; content = f"[{sender_name}]: {content}" # Treat
others as user context
messages_for_prompt.append({"role":
role, "content": content})
if not
messages_for_prompt: # Should
not happen after init, but safeguard
return "Hello!
How may I assist you?"
# 3. Define AI's persona via
system message
system_message = {"role": "system", "content": "You
are a helpful and concise AI Agent providing support. Respond naturally to the
user's last message based on the conversation history."}
openai_messages = [system_message] + messages_for_prompt
# 4. Call Azure OpenAI API
response = openai.ChatCompletion.create(
engine=AZURE_OPENAI_DEPLOYMENT_NAME,
messages=openai_messages,
max_tokens=150,
temperature=0.7
)
ai_response_text = response['choices'][0]['message']['content']
return
ai_response_text.strip()
except
Exception as
e:
st.error("Error getting AI
response:")
st.exception(e) # Log full
error
return "[Error occurred while generating AI response.
Please check logs.]"
Explanation: This function is called whenever the AI needs to generate a reply. It fetches the recent conversation history from the ACS thread using the provided thread_client, formats it into the [{role: 'user'/'assistant', content: '...'}] structure required by the OpenAI Chat Completion API, adds a system message to guide the AI's behavior, calls the API, and returns the AI's generated text response.
4.5 Streamlit App Structure and Initialization
This sets up the main page configuration and title and calls the initialization function.
# --- Streamlit App ---
st.set_page_config(layout="wide",
page_title="AI Chat & Summary
(ACS + OpenAI)")
st.title("💬
Interactive AI Agent Chat & Summarizer")
st.markdown(f"Using
**Azure Communication Services** & **Azure OpenAI**. Date: {datetime.now().strftime('%Y-%m-%d')}")
st.info("Type
a message, click 'Send'. AI Agent responds. Use sidebar to clear/reset. Use
summary button for analysis.")
# --- Initialize Clients and Thread ---
# This calls the cached function defined
earlier
init_details =
initialize_azure_clients_and_thread()
chat_client = init_details.get("chat_client")
chat_thread_client = init_details.get("chat_thread_client")
thread_id = init_details.get("thread_id")
init_error = init_details.get("error")
# --- Sidebar ---
st.sidebar.title("Controls")
# Sidebar button logic to clear chat
if
st.sidebar.button("🧹 Clear Chat
& Start New Thread"):
if
chat_client and
thread_id:
with
st.spinner("Clearing chat
thread..."):
try:
print(f"Attempting
to delete thread: {thread_id}") # Server log
chat_client.delete_chat_thread(thread_id=thread_id)
st.sidebar.success("Previous thread deleted.")
except ResourceNotFoundError:
st.sidebar.warning("Thread already deleted or not found.")
except Exception as e:
st.sidebar.error(f"Error deleting thread: {e}")
st.exception(e)
#
Clear state, cache, and rerun
st.session_state.clear()
initialize_azure_clients_and_thread.clear() #
Clear cache
st.rerun() #
Restart script execution
else:
st.sidebar.error("Cannot
clear chat - client/thread not initialized.")
# --- Initialize Session State Variables
(Safety check) ---
# Ensures these keys exist after
potential clearing
if 'current_summary' not in
st.session_state: st.session_state.current_summary = None
if 'messages' not in
st.session_state: st.session_state.messages = []
if 'send_button_clicked' not in
st.session_state: st.session_state.send_button_clicked = False
Explanation: This section configures the web page (title, layout), displays introductory text, and then calls the cached initialize_azure_clients_and_thread function to get the necessary client objects and thread ID. It defines the sidebar, including the "Clear Chat" button which deletes the ACS thread, clears session state and the resource cache, then forces a rerun. Finally, it ensures essential keys exist in Streamlit's session_state dictionary.
4.6 Main Application Logic and UI
This is the core part that runs only if the initialization is successful. It defines the layout and handles the interactive elements.
# --- Main Application Logic ---
# Only proceed if initialization was
successful (clients/thread ready)
if
chat_thread_client and not
init_error:
# Define layout using columns
(Chat on left, Summary on right)
col1, col2 = st.columns([0.6, 0.4])
# --- Column 1: Live Chat
Interface ---
with
col1:
st.subheader(f"💬 Live Chat: {TARGET_THREAD_TOPIC}")
st.markdown("---")
# --- Display Chat Messages ---
message_container = st.container(height=600) #
Scrollable container
try:
#
Fetch latest messages from ACS on every script run
chat_messages_iterator =
chat_thread_client.list_messages(results_per_page=50)
live_messages = list(chat_messages_iterator)
#
Store messages in session state for potential use by summary function
st.session_state.messages =
live_messages
#
Render messages within the container
with message_container:
if not live_messages:
st.info("No messages yet. Send a message to start!")
else:
#
Display messages, newest at the bottom
for msg in reversed(live_messages):
sender_name =
msg.sender_display_name or "Unknown"
# Assign avatars based on sender name constants
if
sender_name == SENDER_AI_AGENT: avatar = "🤖"
elif
sender_name == SENDER_USER: avatar = "👤"
elif
sender_name == SENDER_SYSTEM: avatar = "⚙️"
else: avatar ="🧑💻" # Default
# Use Streamlit's chat elements for display
with
st.chat_message(name=sender_name, avatar=avatar):
st.caption(f"{msg.created_on.strftime('%Y-%m-%d %H:%M:%S')}") # Timestamp
st.write(msg.content.message or "*empty
message*") #
Message content
except
Exception as
e: # Handle errors fetching messages
with message_container:
st.error("Error fetching messages from ACS:")
st.exception(e)
st.markdown("---") #
Separator
# --- Send Message Input Form
---
# Use a form to group input and
button click
with
st.form(key="send_message_form", clear_on_submit=True):
new_message_content =
st.text_input("Your Message:", key="new_message_input", placeholder="Type
your message here...")
submitted = st.form_submit_button("Send Message")
if submitted:
st.session_state.send_button_clicked = True # Flag
submission
# --- Process message sending
(Runs after form check) ---
if
st.session_state.send_button_clicked:
st.session_state.send_button_clicked = False # Reset
flag
if new_message_content: #
Check if user actually typed something
#
Show spinner during processing
with st.spinner("Sending
message and getting AI response..."):
try:
# 1. Send User message to ACS
chat_thread_client.send_message(new_message_content,
sender_display_name=SENDER_USER)
# 2. Get AI response (calls helper function)
ai_reply =
get_ai_agent_response(chat_thread_client)
# 3. Send AI response back to ACS
if ai_reply:
chat_thread_client.send_message(ai_reply, sender_display_name=SENDER_AI_AGENT)
# 4. Rerun script to refresh chat display
st.rerun()
except Exception as e: # Handle
errors during send/response cycle
st.error("Error during send/response cycle:")
st.exception(e)
else:
st.warning("Please enter a message to send.")
# --- Column 2: AI Summary Area
---
with
col2:
st.subheader("✨ Conversation Summary")
st.markdown("---")
summary_error_message = None #
Placeholder for specific summary errors
# --- Generate Summary Button
and Logic ---
if
st.button("Generate Full
Conversation Summary", key="generate_summary_btn"):
st.session_state.summary_processing = True # Flag
processing
st.session_state.current_summary =
{"Info":"Processing..."} # Show
status
#
Use messages already fetched and stored in session state
fetched_messages =
st.session_state.get('messages', [])
if fetched_messages:
prompt_text = ""
#
Build prompt text from stored messages (oldest first)
for msg in reversed(fetched_messages):
#
... (build prompt_text, skipping empty content) ...
sender_name =
msg.sender_display_name if msg.sender_display_name else "Unknown"
content =
msg.content.message if
msg.content and
msg.content.message else ""
if content: prompt_text += f"{sender_name}: {content}\n"
if not prompt_text.strip():
st.session_state.current_summary = {"Info": "No
message content to summarize."}
else:
#
Prepare prompt with instructions
instruction_phrase = 'Summarize the following conversation. Extract the
main topic, a brief summary, key highlights (1-3 bullet points), and overall
sentiment. Format clearly with headings: ## Topic, ## Summary, ## Highlights,
## Sentiment.\n\n'
full_prompt =
instruction_phrase + prompt_text.strip()
#
Call OpenAI within a spinner and try/except block
with st.spinner("Generating
summary..."):
try:
response =
openai.ChatCompletion.create( # Or
Completion API
engine=AZURE_OPENAI_DEPLOYMENT_NAME,
messages=[{"role":"user","content": full_prompt}],
max_tokens=1024,
temperature=0.2
)
summary_text =
response['choices'][0]['message']['content']
# Parse and store result
st.session_state.current_summary = parse_summary(summary_text)
# Handle various OpenAI/other errors
except
openai.error.AuthenticationError as e: ... # Set
Error state
# ... other except blocks ...
except Exceptionas
e: ... # Set Error state
else: # No
messages fetched/stored
st.session_state.current_summary = {"Info": "Empty
conversation history."}
st.session_state.summary_processing = False # Unflag
processing
st.rerun() #
Rerun to update the summary display area
# --- Display Summary (or
Status) ---
# Checks the state variable and
displays Error, Warning, Info, or the parsed summary
if
st.session_state.get('current_summary'):
summary_data =
st.session_state.current_summary
#
--- Handle Error State ---
if isinstance(summary_data, dict) and "Error" in summary_data: ... #
Display st.error(...)
#
--- Handle Warning State ---
elif isinstance(summary_data, dict) and "Warning" in summary_data: ... #
Display st.warning(...) and partial data
#
--- Handle Info State ---
elif isinstance(summary_data, dict) and "Info" in summary_data: ... #
Display st.info(...)
#
--- Handle Successful Summary Display ---
elif isinstance(summary_data, dict): ... # Display
formatted markdown sections
#
--- Fallback ---
else: st.error("Summary
data unexpected format.")
# --- Default Placeholder Text
---
elif not
st.session_state.get('summary_processing', False):
st.info("Click
'Generate Summary' for an analysis...")
# --- Handle Initialization Errors ---
# This runs if the main 'if
chat_thread_client...' block is False
elif
init_error:
st.error(f"❌ Application cannot
start due to initialization errors:")
st.error(init_error) # Display
the error caught during initialization
else:
# Fallback if client is None
but no specific error was caught
st.warning("⏳ Initializing Azure
services or waiting for resources...")
# --- End of Streamlit App Code ---
Explanation: This is the main part of the application that runs if the initial Azure setup was successful.
- Layout: It defines a two-column layout (
st.columns). - Column 1 (Chat):
- Fetches messages from the ACS thread on every rerun using
chat_thread_client.list_messages(). - Stores these messages in
st.session_state.messages(primarily for the summary function's use). - Displays the messages chronologically in a scrollable container using
st.chat_message. - Provides a text input and send button within a
st.form. - Handles the form submission by sending the user's message, getting the AI response via the helper function, sending the AI response, and triggering a
st.rerunto refresh the display.
- Fetches messages from the ACS thread on every rerun using
- Column 2 (Summary):
- Includes the "Generate Full Conversation Summary" button.
- When clicked, it takes the messages stored in session state, creates a summarization prompt, calls Azure OpenAI, parses the result using
parse_summary, and stores the output (or error/info) inst.session_state.current_summary. - It then conditionally displays the summary information (Topic, Summary, Highlights, Sentiment) or any errors/warnings/info messages based on the content of
st.session_state.current_summary.
- Initialization Error Handling: The final
elif/elsecatches cases where thechat_thread_clientwasn't successfully obtained during startup and displays relevant error or waiting messages.
5. Running the Streamlit Application
With your Azure resources configured, the Python environment set up, and the code saved in app.py (or your chosen filename), you are ready to run the interactive application.
5.1. Run the App:
Open your terminal or command prompt, make sure you are in your project directory (where app.py and .env are located), and execute the command:
streamlit run app.py5.2. Initial Loading State:
Streamlit will start its server and provide you with a local URL (usually http://localhost:8501). When you open this URL in your web browser, you will first see the application's initial loading state, similar to this image:
- The page displays the title "Interactive AI Agent Chat (V3)" and the initial informational text.
- You'll notice a spinner element with text like "Running: initialize_azure_clients_and_thread()". This indicates that the application is currently performing the one-time setup for the session.
- During this phase (which might take a few moments, especially on the very first run or after clearing the chat), the cached function
initialize_azure_clients_and_threadis executing. It connects to Azure Communication Services, creates a user identity and token, establishes a connection to Azure OpenAI, and creates the specific chat thread in ACS, sending the initial messages.
5.3. Interact with the App:
- Once the initialization is complete, the spinner will disappear.
- The main chat interface will load, displaying the initial "System" and "AI Agent" messages fetched from the newly created ACS thread.
- Type your messages into the input box at the bottom of the chat column and click "Send Message". You will see your message appear, followed by a response from the "AI Agent" after a brief processing time (indicated by a spinner).
- Navigate to the right-hand column and click "Generate Full Conversation Summary" anytime to get an AI-powered analysis of the conversation so far.
- Use the "Clear Chat & Start New Thread" button in the sidebar to delete the current conversation history (by deleting the ACS thread) and start a fresh session.
5.4. Review Output:
The AI's chat responses appear directly in the chat interface. The generated summary appears in the right-hand column after you click the button. Any errors during operation should be displayed within the Streamlit interface. You can also check the terminal where you ran the streamlit run command for any server-side print statements or error logs.
6. Conclusion
You've now walked through the process of setting up Azure resources and using Streamlit to build a contact center chat analysis solution! By leveraging Azure Communication Services to access chat data and Azure OpenAI Service for intelligent analysis, you can automate the extraction of valuable insights from user or customer interactions, moving from overwhelming data volume to clear, actionable intelligence.
7. Resources
Updated Apr 12, 2025
Version 1.0