Step-by-Step Contact Center Chat Analysis with Azure OpenAI & Communication Services

 

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:

1. The user interacts with the Streamlit application.
2. 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.
3. The Streamlit application prepares the chat data and formulates prompts based on the desired analysis (e.g., summarize, extract topics, analyze sentiment).
4. These prompts and the chat data are sent to the Azure OpenAI Service.
5. Azure OpenAI processes the information using its LLMs and returns the analysis results (summary, topics, sentiment) to the Streamlit application.
6. 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.¹
• 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 ChatThreadClient needed 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.rerun to refresh the display.
• 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) in st.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/else catches cases where the chat_thread_client wasn'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.py

5.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_thread is 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

• Azure Communication Services Documentation
• Azure OpenAI Service Documentation
• Streamlit Documentation