Add initial version of the project

.gitignore

@@ -0,0 +1,6 @@
+.env
+__pycache__
+.idea
+.venv
+.vscode
+.DS_Store

README.md

@@ -1,20 +1,69 @@
 ---
 title: CallCenterSummarizationAgent
-emoji: 🚀
-colorFrom: red
-colorTo: red
-sdk: docker
-app_port: 8501
-tags:
-- streamlit
-pinned: false
-short_description: Summarize Call Center Conversations
 license: mit
 ---
+# Call Center Data Analysis Agent
 
-# Welcome to Streamlit!
+This project implements a multi-agent workflow using **LangGraph** to process, transcribe, summarize, and score call center data. It comes with a **Streamlit** user interface to easily upload `.csv`, `.mp3`, or `.wav` files and view the resulting insights.
 
-Edit `/src/streamlit_app.py` to customize this app to your heart's desire. :heart:
+## Workflow Flow & Agent Classes
+
+The core analysis logic is driven by a LangGraph StateGraph defined in `src/workflow.py`. The state moves sequentially between several agent classes located in the `src/agents/` directory:
+
+1. **`IntakeAgent` (`src/agents/intake_agent.py`)**
+   - *Entry Point*.
+   - Reads the uploaded file, validates the file format, extracts basic metadata, and runs a first-pass profanity scrub (using an LLM).
+
+2. **`Router` (`src/agents/router.py`)**
+   - *Conditional Routing Node*.
+   - Determines the next step based on the file type.
+   - **If Audio (`.mp3`, `.wav`)**: Routes to the `TranscriptionAgent`.
+   - **If Text (`.csv`)**: Routes directly to the `SummarizationAgent`.
+
+3. **`TranscriptionAgent` (`src/agents/transcription_agent.py`)**
+   - Utilizes `openai-whisper` to convert audio files into text.
+   - Also scrubs the resulting transcript of profanity before passing it down the pipeline.
+
+4. **`SummarizationAgent` (`src/agents/summarization_agent.py`)**
+   - Takes the clean text from either the `IntakeAgent` (if CSV) or the `TranscriptionAgent` (if Audio).
+   - Generates a concise summary and extracts key points using OpenAI (`gpt-3.5-turbo`).
+
+5. **`QualityScoringAgent` (`src/agents/quality_scoring_agent.py`)**
+   - Takes the clean text and evaluates it against a predefined rubric.
+   - Scores the transcript based on Tone, Professionalism, and Structured Resolution.
+
+## Prerequisites
+
+- Python 3.9+
+- An OpenAI API key
+- `ffmpeg` installed on your system (required for `openai-whisper` audio transcription). 
+  - On macOS: `brew install ffmpeg`
+  - On Ubuntu/Debian: `sudo apt update && sudo apt install ffmpeg`
+
+## Installation
+
+1. Create a virtual environment and activate it (if you haven't already):
+   ```bash
+   python -m venv .venv
+   source .venv/bin/activate
+   ```
+2. Install the required dependencies:
+   ```bash
+   pip install -r requirements.txt
+   ```
+
+## Running the Application
+
+1. Ensure your OpenAI API key is set in your environment variables:
+   ```bash
+   export OPENAI_API_KEY="your_api_key_here"
+   ```
+
+2. Start the Streamlit application:
+   ```bash
+   streamlit run app.py
+   ```
+
+3. Open your browser to the local URL provided by Streamlit (usually `http://localhost:8501`).
+4. Use the sidebar to upload a `.csv`, `.mp3`, or `.wav` file and watch the agents analyze your data!
 
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).

requirements.txt

@@ -1,3 +1,11 @@
 altair
 pandas
-streamlit
+streamlit
+plotly
+langgraph
+langchain
+langchain-openai
+openai
+openai-whisper
+python-dotenv
+

src/agents/CallState.py

@@ -0,0 +1,11 @@
+from typing import TypedDict, Optional, Dict, Any
+
+class CallState(TypedDict):
+    file_path: str
+    file_type: str
+    content: Optional[str]
+    clean_content: Optional[str]
+    metadata: Optional[Dict[str, Any]]
+    summary: Optional[str]
+    key_points: Optional[str]
+    quality_scores: Optional[Dict[str, Any]]

src/agents/IntakeAgent.py

@@ -0,0 +1,36 @@
+import pandas as pd
+from langchain_openai import ChatOpenAI
+from langchain_core.prompts import PromptTemplate
+from src.agents.CallState import CallState
+
+class IntakeAgent:
+    def __init__(self):
+        self.llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0)
+        
+    def __call__(self, state: CallState) -> CallState:
+        """Validates input formats, cleans up profanity, extracts meta."""
+        file_path = state["file_path"]
+        file_type = state["file_type"]
+        
+        state["metadata"] = {"file_type": file_type, "file_path": file_path}
+        
+        if file_type == "csv":
+            try:
+                df = pd.read_csv(file_path)
+                if "transcript" in df.columns:
+                    content = " ".join(df["transcript"].astype(str).tolist())
+                else:
+                    content = df.to_string()
+                state["content"] = content
+            except Exception as e:
+                state["content"] = f"Error reading CSV: {e}"
+
+        if state.get("content"):
+            prompt = PromptTemplate.from_template(
+                "Clean the following text of any profanity and fix basic grammatical errors. Return only the clean text:\n{text}"
+            )
+            chain = prompt | self.llm
+            clean_text = chain.invoke({"text": state["content"]}).content
+            state["clean_content"] = clean_text
+            
+        return state

src/agents/QualityScoringAgent.py

@@ -0,0 +1,32 @@
+import json
+from langchain_openai import ChatOpenAI
+from langchain_core.prompts import PromptTemplate
+from src.agents.CallState import CallState
+
+class QualityScoringAgent:
+    def __init__(self):
+        self.llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0)
+        
+    def __call__(self, state: CallState) -> CallState:
+        """Evaluates tone, professionalism, and structured resolution with rubric."""
+        clean_text = state.get("clean_content", state.get("content", ""))
+        if not clean_text:
+            return state
+            
+        prompt = PromptTemplate.from_template(
+            "Evaluate the following call transcript for tone, professionalism, and structured resolution. "
+            "Score each out of 10 based on a strict rubric.\n"
+            "Return as JSON string with keys 'tone', 'professionalism', 'structured_resolution', and 'notes'.\n\n"
+            "Transcript:\n{text}"
+        )
+        
+        chain = prompt | self.llm
+        result_text = chain.invoke({"text": clean_text}).content
+        
+        try:
+            result_json = json.loads(result_text)
+            state["quality_scores"] = result_json
+        except json.JSONDecodeError:
+            state["quality_scores"] = {"raw_evaluation": result_text}
+            
+        return state

src/agents/Router.py

@@ -0,0 +1,9 @@
+from src.agents.CallState import CallState
+
+class Router:
+    def __call__(self, state: CallState) -> str:
+        """Invokes above agents accordingly."""
+        file_type = state["file_type"]
+        if file_type in ["mp3", "wav"] and not state.get("content"):
+            return "transcribe"
+        return "summarize"

src/agents/SummarizationAgent.py

@@ -0,0 +1,33 @@
+import json
+from langchain_openai import ChatOpenAI
+from langchain_core.prompts import PromptTemplate
+from src.agents.CallState import CallState
+
+class SummarizationAgent:
+    def __init__(self):
+        self.llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0)
+        
+    def __call__(self, state: CallState) -> CallState:
+        """Generates summaries and key points."""
+        clean_text = state.get("clean_content", state.get("content", ""))
+        if not clean_text:
+            return state
+            
+        prompt = PromptTemplate.from_template(
+            "Summarize the following call transcript and extract key points.\n"
+            "Return as a JSON string with 'summary' and 'key_points' keys.\n\n"
+            "Transcript:\n{text}"
+        )
+        
+        chain = prompt | self.llm
+        result_text = chain.invoke({"text": clean_text}).content
+        
+        try:
+            result_json = json.loads(result_text)
+            state["summary"] = result_json.get("summary", "")
+            state["key_points"] = result_json.get("key_points", "")
+        except json.JSONDecodeError:
+            state["summary"] = result_text
+            state["key_points"] = "Failed to parse JSON for key points."
+            
+        return state

src/agents/TranscriptionAgent.py

@@ -0,0 +1,27 @@
+import whisper
+from langchain_openai import ChatOpenAI
+from langchain_core.prompts import PromptTemplate
+from src.agents.CallState import CallState
+
+class TranscriptionAgent:
+    def __init__(self):
+        self.llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0)
+        
+    def __call__(self, state: CallState) -> CallState:
+        """Converts audio to text using whisper."""
+        file_path = state["file_path"]
+        
+        # Load whisper model - using 'base' for faster processing
+        model = whisper.load_model("base")
+        result = model.transcribe(file_path)
+        state["content"] = result["text"]
+        
+        # Clean the transcript
+        prompt = PromptTemplate.from_template(
+            "Clean the following text of any profanity and fix basic grammatical errors. Return only the clean text:\n{text}"
+        )
+        chain = prompt | self.llm
+        clean_text = chain.invoke({"text": state["content"]}).content
+        state["clean_content"] = clean_text
+        
+        return state

src/agents/__init__.py

@@ -0,0 +1,6 @@
+from .CallState import CallState
+from .IntakeAgent import IntakeAgent
+from .TranscriptionAgent import TranscriptionAgent
+from .SummarizationAgent import SummarizationAgent
+from .QualityScoringAgent import QualityScoringAgent
+from .Router import Router

src/streamlit_app.py

@@ -1,40 +1,237 @@
-import altair as alt
-import numpy as np
-import pandas as pd
 import streamlit as st
+import sys
+import os
+import json
+from pathlib import Path
+from dotenv import load_dotenv
+
+# Load environment variables from .env file
+load_dotenv()
+
+sys.path.append(os.path.dirname(os.path.dirname(__file__)))
+
+PROCESSED_DIR = "data/processed_results"
+
+def apply_material_css():
+    st.markdown("""
+        <style>
+        /* Material Design CSS Overrides */
+        
+        .stApp {
+            font-family: 'Roboto', 'Inter', sans-serif;
+            background-color: #121212;
+            color: #FFFFFF;
+        }
+        
+        /* Material Cards for metrics and sections */
+        .material-card {
+            background-color: #1E1E1E;
+            border-radius: 8px;
+            padding: 20px;
+            box-shadow: 0 4px 6px rgba(0,0,0,0.3);
+            margin-bottom: 20px;
+        }
+        
+        h1, h2, h3, h4 {
+            font-weight: 500;
+        }
+        
+        /* Subtle styling for Streamlit columns to look like cards */
+        [data-testid="column"] {
+            background-color: #1E1E1E;
+            border-radius: 8px;
+            padding: 20px;
+            box-shadow: 0 4px 6px rgba(0,0,0,0.3);
+        }
+        
+        </style>
+    """, unsafe_allow_html=True)
+
+def display_results(final_state):
+    st.subheader("Workflow Results")
+    
+    col1, col2 = st.columns(2)
+    with col1:
+        st.markdown("### Summary")
+        st.write(final_state.get("summary", "No summary generated."))
+        
+        st.markdown("### Key Points")
+        key_points = final_state.get("key_points", "No key points generated.")
+        if isinstance(key_points, list):
+            for point in key_points:
+                st.markdown(f"- {point}")
+        else:
+            st.write(key_points)
+        
+    with col2:
+        st.markdown("### Quality Scores")
+        quality_scores = final_state.get("quality_scores", {})
+        if isinstance(quality_scores, dict) and quality_scores:
+            import plotly.graph_objects as go
+            for metric in ['tone', 'professionalism', 'structured_resolution']:
+                if metric in quality_scores:
+                    try:
+                        val = float(quality_scores[metric])
+                        fig = go.Figure(go.Indicator(
+                            mode="gauge+number",
+                            value=val,
+                            title={'text': metric.replace('_', ' ').title(), 'font': {'size': 16, 'color': '#FFFFFF'}},
+                            gauge={
+                                'axis': {'range': [None, 10], 'tickwidth': 1, 'tickcolor': "#BB86FC"},
+                                'bar': {'color': "#BB86FC"},
+                                'bgcolor': "#1E1E1E",
+                                'borderwidth': 2,
+                                'bordercolor': "#333333",
+                                'steps': [
+                                    {'range': [0, 4], 'color': '#cf6679'},
+                                    {'range': [4, 7], 'color': '#ffb74d'},
+                                    {'range': [7, 10], 'color': '#81c784'}],
+                            }
+                        ))
+                        # Adjust colors for dark theme
+                        fig.update_layout(
+                            height=180, 
+                            margin=dict(l=20, r=20, t=40, b=20),
+                            paper_bgcolor='#1E1E1E',
+                            plot_bgcolor='#1E1E1E',
+                            font={'color': '#FFFFFF'}
+                        )
+                        st.plotly_chart(fig, use_container_width=True)
+                    except (ValueError, TypeError):
+                        st.write(f"**{metric.replace('_', ' ').title()}**: {quality_scores[metric]}")
+            
+            if "notes" in quality_scores:
+                st.write("**Notes:**", quality_scores["notes"])
+        else:
+            st.write("No specific scores generated.", quality_scores)
+        
+        st.markdown("### Metadata")
+        metadata = final_state.get("metadata", {})
+        if isinstance(metadata, dict) and metadata:
+            for k, v in metadata.items():
+                st.markdown(f"- **{k.replace('_', ' ').title()}**: {v}")
+        else:
+            st.write("No metadata available.")
+
+def main():
+    st.set_page_config(page_title="Call Center Data Analysis", layout="wide")
+    apply_material_css()
+    
+    st.title("Call Center Data Analysis Dashboard")
+    
+    os.makedirs(PROCESSED_DIR, exist_ok=True)
+    os.makedirs("tmp", exist_ok=True)
+    
+    if "view_mode" not in st.session_state:
+        st.session_state.view_mode = "none"
+
+    def set_upload_mode():
+        st.session_state.view_mode = "upload"
+
+    def set_dropdown_mode():
+        st.session_state.view_mode = "dropdown"
+
+    st.sidebar.header("Upload New File")
+    uploaded_file = st.sidebar.file_uploader(
+        "Upload a file", 
+        type=["json", "mp3", "wav", "csv"],
+        on_change=set_upload_mode
+    )
+    
+    st.sidebar.markdown("---")
+    st.sidebar.header("Processed Files")
+    
+    # Get list of processed files
+    processed_files = [f for f in os.listdir(PROCESSED_DIR) if f.endswith(".json")]
+    processed_files.sort(reverse=True) # Show newest (or reverse alphabetical) first
+    
+    selected_file = None
+    if processed_files:
+        options = ["-- Select a file --"] + processed_files
+        selected_dropdown = st.sidebar.selectbox("View cached results:", options, on_change=set_dropdown_mode)
+        if selected_dropdown != "-- Select a file --":
+            selected_file = selected_dropdown
+    else:
+        st.sidebar.info("No files processed yet.")
+
+    # Prioritize based on view_mode
+    if st.session_state.view_mode == "upload" and uploaded_file is not None:
+        st.success(f"File '{uploaded_file.name}' uploaded successfully!")
+        
+        from src.workflow import build_workflow
+        
+        file_path = os.path.join("tmp", uploaded_file.name)
+        with open(file_path, "wb") as f:
+            f.write(uploaded_file.getbuffer())
+        
+        file_extension = uploaded_file.name.split('.')[-1].lower()
+        
+        # Check if already processed to avoid reprocessing on rerun if same file is in uploader
+        cached_json_path = os.path.join(PROCESSED_DIR, f"{uploaded_file.name}.json")
+        
+        if os.path.exists(cached_json_path):
+            st.info("Loading cached results for this file...")
+            with open(cached_json_path, 'r') as f:
+                final_state = json.load(f)
+            display_results(final_state)
+        else:
+            st.write("Processing file through LangGraph Workflow...")
+            with st.spinner("Agents are analyzing the data..."):
+                workflow = build_workflow()
+                initial_state = {
+                    "file_path": file_path,
+                    "file_type": file_extension
+                }
+                
+                final_state = workflow.invoke(initial_state)
+                
+                # Cache the results
+                with open(cached_json_path, 'w') as f:
+                    json.dump(final_state, f)
+                    
+            display_results(final_state)
+            
+    elif (st.session_state.view_mode == "dropdown" or st.session_state.view_mode == "none") and selected_file is not None:
+        st.info(f"Loading cached results for '{selected_file.replace('.json', '')}'")
+        cached_json_path = os.path.join(PROCESSED_DIR, selected_file)
+        with open(cached_json_path, 'r') as f:
+            final_state = json.load(f)
+        display_results(final_state)
+        
+    elif uploaded_file is not None:
+        st.success(f"File '{uploaded_file.name}' uploaded successfully!")
+        
+        from src.workflow import build_workflow
+        
+        file_path = os.path.join("tmp", uploaded_file.name)
+        with open(file_path, "wb") as f:
+            f.write(uploaded_file.getbuffer())
+        
+        file_extension = uploaded_file.name.split('.')[-1].lower()
+        
+        cached_json_path = os.path.join(PROCESSED_DIR, f"{uploaded_file.name}.json")
+        
+        if os.path.exists(cached_json_path):
+            st.info("Loading cached results for this file...")
+            with open(cached_json_path, 'r') as f:
+                final_state = json.load(f)
+            display_results(final_state)
+        else:
+            st.write("Processing file through LangGraph Workflow...")
+            with st.spinner("Agents are analyzing the data..."):
+                workflow = build_workflow()
+                initial_state = {
+                    "file_path": file_path,
+                    "file_type": file_extension
+                }
+                final_state = workflow.invoke(initial_state)
+                with open(cached_json_path, 'w') as f:
+                    json.dump(final_state, f)
+            display_results(final_state)
+        
+    else:
+        st.info("Please upload a file or select a previously processed file.")
+
+if __name__ == "__main__":
+    main()
 
-"""
-# Welcome to Streamlit!
-
-Edit `/streamlit_app.py` to customize this app to your heart's desire :heart:.
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
-
-In the meantime, below is an example of what you can do with just a few lines of code:
-"""
-
-num_points = st.slider("Number of points in spiral", 1, 10000, 1100)
-num_turns = st.slider("Number of turns in spiral", 1, 300, 31)
-
-indices = np.linspace(0, 1, num_points)
-theta = 2 * np.pi * num_turns * indices
-radius = indices
-
-x = radius * np.cos(theta)
-y = radius * np.sin(theta)
-
-df = pd.DataFrame({
-    "x": x,
-    "y": y,
-    "idx": indices,
-    "rand": np.random.randn(num_points),
-})
-
-st.altair_chart(alt.Chart(df, height=700, width=700)
-    .mark_point(filled=True)
-    .encode(
-        x=alt.X("x", axis=None),
-        y=alt.Y("y", axis=None),
-        color=alt.Color("idx", legend=None, scale=alt.Scale()),
-        size=alt.Size("rand", legend=None, scale=alt.Scale(range=[1, 150])),
-    ))

src/workflow.py

@@ -0,0 +1,45 @@
+from langgraph.graph import StateGraph, END
+from src.agents import (
+    CallState,
+    IntakeAgent,
+    TranscriptionAgent,
+    SummarizationAgent,
+    QualityScoringAgent,
+    Router
+)
+
+def build_workflow():
+    workflow = StateGraph(CallState)
+    
+    # Initialize agents
+    intake_agent = IntakeAgent()
+    transcription_agent = TranscriptionAgent()
+    summarization_agent = SummarizationAgent()
+    quality_scoring_agent = QualityScoringAgent()
+    router = Router()
+    
+    # Add nodes
+    workflow.add_node("intake", intake_agent)
+    workflow.add_node("transcribe", transcription_agent)
+    workflow.add_node("summarize", summarization_agent)
+    workflow.add_node("score", quality_scoring_agent)
+    
+    # Define entry point
+    workflow.set_entry_point("intake")
+    
+    # Add conditional edges from intake
+    workflow.add_conditional_edges(
+        "intake",
+        router,
+        {
+            "transcribe": "transcribe",
+            "summarize": "summarize"
+        }
+    )
+    
+    # Add standard edges
+    workflow.add_edge("transcribe", "summarize")
+    workflow.add_edge("summarize", "score")
+    workflow.add_edge("score", END)
+    
+    return workflow.compile()