upload app

README.md

@@ -1,20 +1,306 @@
----
-title: Langraph Llm Data Analyst Agent
-emoji: 🚀
-colorFrom: red
-colorTo: red
-sdk: docker
-app_port: 8501
-tags:
-- streamlit
-pinned: false
-short_description: Streamlit template space
-license: mit
----
+# 🤖 LangGraph Data Analyst Agent
+
+An intelligent data analyst agent built with LangGraph that analyzes customer support conversations with advanced memory, conversation persistence, and query recommendations.
+
+## 🌟 Features
+
+### Core Functionality
+- **Multi-Agent Architecture**: Separate specialized agents for structured and unstructured queries
+- **Query Classification**: Automatic routing to appropriate agent based on query type
+- **Rich Tool Set**: Comprehensive tools for data analysis and insights
+
+### Advanced Memory & Persistence
+- **Session Management**: Persistent conversations across page reloads and browser sessions
+- **User Profile Tracking**: Agent learns and remembers user interests and preferences  
+- **Conversation History**: Full context retention using LangGraph checkpointers
+- **Cross-Session Continuity**: Resume conversations using session IDs
+
+### Intelligent Recommendations
+- **Query Suggestions**: AI-powered recommendations based on conversation history
+- **Interactive Refinement**: Collaborative query building with the agent
+- **Context-Aware**: Suggestions based on user profile and previous interactions
+
+## 🏗️ Architecture
+
+The agent uses LangGraph's multi-agent architecture with the following components:
+
+```
+User Query → Classifier → [Structured Agent | Unstructured Agent | Recommender] → Summarizer → Response
+                ↓
+            Tool Nodes (Dataset Analysis Tools)
+```
+
+### Agent Types
+1. **Structured Agent**: Handles quantitative queries (statistics, examples, distributions)
+2. **Unstructured Agent**: Handles qualitative queries (summaries, insights, patterns)
+3. **Query Recommender**: Suggests follow-up questions based on context
+4. **Summarizer**: Updates user profile and conversation memory
+
+## 🚀 Setup Instructions
+
+### Prerequisites
+- **Python Version**: 3.9 or higher
+- **API Key**: OpenAI API key or Nebius API key
+
+### Installation
+
+1. **Clone the repository**:
+```bash
+git clone <repository-url>
+cd Agents
+```
+
+2. **Install dependencies**:
+```bash
+pip install -r requirements.txt
+```
+
+3. **Configure API Key**:
+
+Create a `.env` file in the project root:
+```bash
+# For OpenAI (recommended)
+OPENAI_API_KEY=your_openai_api_key_here
+
+# OR for Nebius
+NEBIUS_API_KEY=your_nebius_api_key_here
+```
+
+4. **Run the application**:
+```bash
+streamlit run app_langgraph.py
+```
+
+5. **Access the app**:
+Open your browser to `http://localhost:8501`
+
+### Alternative Deployment
+
+For cloud deployment, set the environment variable:
+```bash
+export OPENAI_API_KEY=your_api_key_here
+# OR
+export NEBIUS_API_KEY=your_api_key_here
+```
+
+## 🎯 Usage Guide
+
+### Query Types
+
+#### Structured Queries (Quantitative Analysis)
+- "How many records are in each category?"
+- "What are the most common customer issues?"
+- "Show me 5 examples of billing problems"
+- "Get distribution of intents"
+
+#### Unstructured Queries (Qualitative Analysis)  
+- "Summarize the refund category"
+- "What patterns do you see in payment issues?"
+- "Analyze customer sentiment in billing conversations"
+- "What insights can you provide about technical support?"
+
+#### Memory & Recommendations
+- "What do you remember about me?"
+- "What should I query next?"
+- "Advise me what to explore"
+- "Recommend follow-up questions"
+
+### Session Management
+
+#### Creating Sessions
+- **New Session**: Click "🆕 New Session" to start fresh
+- **Auto-Generated**: Each new browser session gets a unique ID
+
+#### Resuming Sessions
+1. Copy your session ID from the sidebar (e.g., `a1b2c3d4...`)
+2. Enter the full session ID in "Join Existing Session"
+3. Click "🔗 Join Session" to resume
+
+#### Cross-Tab Persistence
+- Open multiple tabs with the same session ID
+- Conversations sync across all tabs
+- Memory and user profile persist
+
+## 🧠 Memory System
+
+### User Profile Tracking
+The agent automatically tracks:
+- **Interests**: Topics and categories you frequently ask about
+- **Expertise Level**: Inferred from question complexity (beginner/intermediate/advanced)
+- **Preferences**: Analysis style preferences (quantitative vs qualitative)
+- **Query History**: Recent questions for context
+
+### Conversation Persistence
+- **Thread-based**: Each session has a unique thread ID
+- **Checkpoint System**: LangGraph automatically saves state after each interaction
+- **Cross-Session**: Resume conversations days or weeks later
+
+### Memory Queries
+Ask the agent what it remembers:
+```
+"What do you remember about me?"
+"What are my interests?"
+"What have I asked about before?"
+```
 
-# Welcome to Streamlit!
+## 🔧 Testing the Agent
 
-Edit `/src/streamlit_app.py` to customize this app to your heart's desire. :heart:
+### Basic Functionality Tests
+
+1. **Classification Test**:
+```
+Query: "How many categories are there?"
+Expected: Routes to Structured Agent → Uses get_dataset_stats tool
+```
+
+2. **Follow-up Memory Test**:
+```
+Query 1: "Show me billing examples"
+Query 2: "Show me more examples"
+Expected: Agent remembers previous context about billing
+```
+
+3. **User Profile Test**:
+```
+Query 1: "I'm interested in refund patterns"
+Query 2: "What do you remember about me?"
+Expected: Agent mentions interest in refunds
+```
+
+4. **Recommendation Test**:
+```
+Query: "What should I query next?"
+Expected: Personalized suggestions based on history
+```
+
+### Advanced Feature Tests
+
+1. **Session Persistence**:
+   - Ask a question, reload the page
+   - Verify conversation history remains
+   - Verify user profile persists
+
+2. **Cross-Session Memory**:
+   - Note your session ID
+   - Close browser completely
+   - Reopen and join the same session
+   - Verify full conversation and profile restoration
+
+3. **Interactive Recommendations**:
+```
+User: "Advise me what to query next"
+Agent: "Based on your interest in billing, you might want to analyze refund patterns."
+User: "I'd rather see examples instead"
+Agent: "Then I suggest showing 5 examples of refund requests."
+User: "Please do so"
+Expected: Agent executes the refined query
+```
+
+## 📁 File Structure
+
+```
+Agents/
+├── README.md                 # This file
+├── requirements.txt          # Python dependencies
+├── .env                     # API keys (create this)
+├── app_langgraph.py         # New LangGraph Streamlit app
+├── langgraph_agent.py       # LangGraph agent implementation
+├── app.py                   # Original app (for reference)
+├── agent-memory.ipynb       # Memory example notebook
+└── DEPLOYMENT_GUIDE.md      # Original deployment guide
+```
+
+## 🛠️ Technical Implementation
+
+### LangGraph Components
+
+**State Management**:
+```python
+class AgentState(TypedDict):
+    messages: List[Any]
+    query_type: Optional[str]
+    user_profile: Optional[Dict[str, Any]]
+    session_context: Optional[Dict[str, Any]]
+```
+
+**Tool Categories**:
+- **Structured Tools**: Statistics, distributions, examples, search
+- **Unstructured Tools**: Summaries, insights, pattern analysis
+- **Memory Tools**: Profile updates, preference tracking
+
+**Graph Flow**:
+1. **Classifier**: Determines query type
+2. **Agent Selection**: Routes to appropriate specialist
+3. **Tool Execution**: Dynamic tool usage based on needs
+4. **Memory Update**: Profile and context updates
+5. **Response Generation**: Final answer with memory integration
+
+### Memory Architecture
+
+**Checkpointer**: LangGraph's `MemorySaver` for conversation persistence
+**Thread Management**: Unique thread IDs for session isolation
+**Profile Synthesis**: LLM-powered extraction of user characteristics
+**Context Retention**: Full conversation history with temporal awareness
+
+## 🔍 Troubleshooting
+
+### Common Issues
+
+1. **API Key Errors**:
+   - Verify `.env` file exists and has correct key
+   - Check environment variable is set in deployment
+   - Ensure API key has sufficient credits
+
+2. **Memory Not Persisting**:
+   - Verify session ID remains consistent
+   - Check browser localStorage not being cleared
+   - Ensure thread_id parameter is passed correctly
+
+3. **Dataset Loading Issues**:
+   - Check internet connection for Hugging Face datasets
+   - Verify datasets library is installed
+   - Try clearing Streamlit cache: `streamlit cache clear`
+
+4. **Tool Execution Errors**:
+   - Verify all dependencies in requirements.txt are installed
+   - Check dataset is properly loaded
+   - Review error messages in Streamlit interface
+
+### Debug Mode
+
+Enable debug logging by setting:
+```python
+import logging
+logging.basicConfig(level=logging.DEBUG)
+```
+
+## 🎓 Learning Objectives
+
+This implementation demonstrates:
+
+1. **LangGraph Multi-Agent Systems**: Specialized agents for different query types
+2. **Memory & Persistence**: Conversation continuity across sessions  
+3. **Tool Integration**: Dynamic tool selection and execution
+4. **State Management**: Complex state updates and routing
+5. **User Experience**: Session management and interactive features
+
+## 🚀 Future Enhancements
+
+Potential improvements:
+- **Database Persistence**: Replace MemorySaver with PostgreSQL checkpointer
+- **Advanced Analytics**: More sophisticated data analysis tools
+- **Export Features**: PDF/CSV report generation
+- **User Authentication**: Multi-user support with profiles
+- **Real-time Collaboration**: Shared sessions between users
+
+## 📄 License
+
+This project is for educational purposes as part of a data science curriculum.
+
+## 🤝 Contributing
+
+This is an assignment project. For questions or issues, please contact the course instructors.
+
+---
 
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
+**Built with**: LangGraph, Streamlit, OpenAI/Nebius, Hugging Face Datasets 

app.py

@@ -0,0 +1,620 @@
+import json
+import os
+import uuid
+from datetime import datetime
+from typing import Dict, List, Optional
+
+import pandas as pd
+import streamlit as st
+from datasets import load_dataset
+from dotenv import load_dotenv
+
+from langgraph_agent import DataAnalystAgent, DatasetManager
+
+# Load environment variables
+load_dotenv()
+
+# Set up page config
+st.set_page_config(
+    page_title="🤖 LangGraph Data Analyst Agent",
+    layout="wide",
+    page_icon="🤖",
+    initial_sidebar_state="expanded",
+)
+
+# Custom CSS for styling
+st.markdown(
+    """
+<style>
+    /* Main theme colors */
+    :root {
+        --primary-color: #1f77b4;
+        --secondary-color: #ff7f0e;
+        --success-color: #2ca02c;
+        --error-color: #d62728;
+        --warning-color: #ff9800;
+        --background-color: #0e1117;
+        --card-background: #262730;
+    }
+    
+    /* Custom styling for the main container */
+    .main-header {
+        background: linear-gradient(90deg, #1f77b4 0%, #ff7f0e 100%);
+        padding: 2rem 1rem;
+        border-radius: 10px;
+        margin-bottom: 2rem;
+        text-align: center;
+        color: white;
+        box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1);
+    }
+    
+    .main-header h1 {
+        margin: 0;
+        font-size: 2.5rem;
+        font-weight: 700;
+        text-shadow: 2px 2px 4px rgba(0,0,0,0.3);
+    }
+    
+    .main-header p {
+        margin: 0.5rem 0 0 0;
+        font-size: 1.2rem;
+        opacity: 0.9;
+    }
+    
+    /* Card styling */
+    .info-card {
+        background: var(--card-background);
+        padding: 1.5rem;
+        border-radius: 10px;
+        border-left: 4px solid var(--primary-color);
+        margin: 1rem 0;
+        box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
+    }
+    
+    .success-card {
+        background: linear-gradient(90deg, 
+            rgba(44, 160, 44, 0.1) 0%, 
+            rgba(44, 160, 44, 0.05) 100%);
+        border-left: 4px solid var(--success-color);
+        padding: 1rem;
+        border-radius: 8px;
+        margin: 1rem 0;
+    }
+    
+    .error-card {
+        background: linear-gradient(90deg, 
+            rgba(214, 39, 40, 0.1) 0%, 
+            rgba(214, 39, 40, 0.05) 100%);
+        border-left: 4px solid var(--error-color);
+        padding: 1rem;
+        border-radius: 8px;
+        margin: 1rem 0;
+    }
+    
+    .memory-card {
+        background: linear-gradient(90deg, 
+            rgba(255, 127, 14, 0.1) 0%, 
+            rgba(255, 127, 14, 0.05) 100%);
+        border-left: 4px solid var(--secondary-color);
+        padding: 1rem;
+        border-radius: 8px;
+        margin: 1rem 0;
+    }
+    
+    /* Chat message styling */
+    .user-message {
+        background: linear-gradient(90deg, 
+            rgba(31, 119, 180, 0.1) 0%, 
+            rgba(31, 119, 180, 0.05) 100%);
+        padding: 1rem;
+        border-radius: 10px;
+        margin: 0.5rem 0;
+        border-left: 4px solid var(--primary-color);
+    }
+    
+    .assistant-message {
+        background: linear-gradient(90deg, 
+            rgba(255, 127, 14, 0.1) 0%, 
+            rgba(255, 127, 14, 0.05) 100%);
+        padding: 1rem;
+        border-radius: 10px;
+        margin: 0.5rem 0;
+        border-left: 4px solid var(--secondary-color);
+    }
+    
+    .session-info {
+        background: var(--card-background);
+        padding: 1rem;
+        border-radius: 8px;
+        margin: 0.5rem 0;
+        border: 1px solid rgba(255, 255, 255, 0.1);
+        font-size: 0.9rem;
+    }
+    
+    /* Animation for thinking indicator */
+    @keyframes pulse {
+        0% { opacity: 1; }
+        50% { opacity: 0.5; }
+        100% { opacity: 1; }
+    }
+    
+    .thinking-indicator {
+        animation: pulse 2s infinite;
+    }
+</style>
+""",
+    unsafe_allow_html=True,
+)
+
+
+# API configuration
+def get_api_configuration():
+    """Get API configuration from environment variables."""
+    api_key = os.environ.get("NEBIUS_API_KEY") or os.environ.get("OPENAI_API_KEY")
+
+    if not api_key:
+        st.markdown(
+            """
+        <div class="error-card">
+            <h3>🔑 API Key Configuration Required</h3>
+            
+            <h4>For Local Development:</h4>
+            <ol>
+                <li>Create a <code>.env</code> file in your project directory</li>
+                <li>Add your API key: <code>NEBIUS_API_KEY=your_api_key_here</code></li>
+                <li>Or use OpenAI: <code>OPENAI_API_KEY=your_api_key_here</code></li>
+                <li>Restart the application</li>
+            </ol>
+            
+            <h4>For Deployment:</h4>
+            <ol>
+                <li>Set environment variable <code>NEBIUS_API_KEY</code> or 
+                    <code>OPENAI_API_KEY</code></li>
+                <li>Restart your application</li>
+            </ol>
+        </div>
+        """,
+            unsafe_allow_html=True,
+        )
+        st.stop()
+
+    return api_key
+
+
+# Initialize the agent
+@st.cache_resource
+def get_agent(api_key: str) -> DataAnalystAgent:
+    """Initialize and cache the LangGraph agent."""
+    return DataAnalystAgent(api_key=api_key)
+
+
+# Load dataset
+@st.cache_data
+def load_bitext_dataset():
+    """Load and cache the Bitext dataset."""
+    try:
+        dataset = load_dataset(
+            "bitext/Bitext-customer-support-llm-chatbot-training-dataset"
+        )
+        df = pd.DataFrame(dataset["train"])
+        return df
+    except Exception as e:
+        st.error(f"Error loading dataset: {e}")
+        return None
+
+
+# Session management functions
+def initialize_session():
+    """Initialize session state variables."""
+    if "session_id" not in st.session_state:
+        st.session_state.session_id = str(uuid.uuid4())
+
+    if "conversation_history" not in st.session_state:
+        st.session_state.conversation_history = []
+
+    if "user_profile" not in st.session_state:
+        st.session_state.user_profile = {}
+
+    if "current_thread_id" not in st.session_state:
+        st.session_state.current_thread_id = st.session_state.session_id
+
+
+def create_new_session():
+    """Create a new session with a new thread ID."""
+    st.session_state.session_id = str(uuid.uuid4())
+    st.session_state.current_thread_id = st.session_state.session_id
+    st.session_state.conversation_history = []
+    st.session_state.user_profile = {}
+
+
+def format_conversation_message(role: str, content: str, timestamp: str = None):
+    """Format a conversation message for display."""
+    if timestamp is None:
+        timestamp = datetime.now().strftime("%H:%M:%S")
+
+    if role == "human":
+        return f"""
+        <div class="user-message">
+            <strong>👤 You ({timestamp}):</strong><br>
+            {content}
+        </div>
+        """
+    else:
+        return f"""
+        <div class="assistant-message">
+            <strong>🤖 Agent ({timestamp}):</strong><br>
+            {content}
+        </div>
+        """
+
+
+def display_user_profile(profile: Dict):
+    """Display user profile information."""
+    if not profile:
+        return
+
+    with st.expander("🧠 What I Remember About You", expanded=False):
+        col1, col2 = st.columns(2)
+
+        with col1:
+            st.markdown("**Your Interests:**")
+            interests = profile.get("interests", [])
+            if interests:
+                for interest in interests:
+                    st.write(f"• {interest}")
+            else:
+                st.write("_No interests recorded yet_")
+
+            st.markdown("**Expertise Level:**")
+            expertise = profile.get("expertise_level", "beginner")
+            st.write(f"• {expertise.title()}")
+
+        with col2:
+            st.markdown("**Your Preferences:**")
+            preferences = profile.get("preferences", {})
+            if preferences:
+                for key, value in preferences.items():
+                    st.write(f"• {key}: {value}")
+            else:
+                st.write("_No preferences recorded yet_")
+
+            st.markdown("**Recent Query Topics:**")
+            query_history = profile.get("query_history", [])
+            if query_history:
+                for query in query_history[-3:]:  # Show last 3
+                    st.write(f"• {query[:50]}...")
+            else:
+                st.write("_No query history yet_")
+
+
+def main():
+    # Custom header
+    st.markdown(
+        """
+    <div class="main-header">
+        <h1>🤖 LangGraph Data Analyst Agent</h1>
+        <p>Intelligent Analysis with Memory & Recommendations</p>
+    </div>
+    """,
+        unsafe_allow_html=True,
+    )
+
+    # Initialize session
+    initialize_session()
+
+    # Get API configuration
+    api_key = get_api_configuration()
+
+    # Initialize agent
+    agent = get_agent(api_key)
+
+    # Load dataset
+    with st.spinner("🔄 Loading dataset..."):
+        df = load_bitext_dataset()
+
+    if df is None:
+        st.markdown(
+            """
+        <div class="error-card">
+            <h3>❌ Dataset Loading Failed</h3>
+            <p>Failed to load dataset. Please check your connection and try again.</p>
+        </div>
+        """,
+            unsafe_allow_html=True,
+        )
+        return
+
+    # Success message
+    st.markdown(
+        f"""
+    <div class="success-card">
+        <h3>✅ System Ready</h3>
+        <p>Dataset loaded with <strong>{len(df):,}</strong> records. 
+           LangGraph agent initialized with memory.</p>
+    </div>
+    """,
+        unsafe_allow_html=True,
+    )
+
+    # Sidebar configuration
+    with st.sidebar:
+        st.markdown("## ⚙️ Session Management")
+
+        # Session ID management
+        st.markdown("### 🆔 Session Control")
+
+        col1, col2 = st.columns(2)
+        with col1:
+            if st.button("🆕 New Session", use_container_width=True):
+                create_new_session()
+                st.rerun()
+
+        with col2:
+            if st.button("🔄 Refresh", use_container_width=True):
+                st.rerun()
+
+        # Display session info
+        st.markdown(
+            f"""
+        <div class="session-info">
+            <strong>Current Session:</strong><br>
+            <code>{st.session_state.current_thread_id[:8]}...</code><br>
+            <strong>Messages:</strong> {len(st.session_state.conversation_history)}
+        </div>
+        """,
+            unsafe_allow_html=True,
+        )
+
+        # Custom session ID input
+        st.markdown("### 🔗 Join Existing Session")
+        custom_thread_id = st.text_input(
+            "Enter Session ID:",
+            placeholder="Enter full session ID to join...",
+            help="Use this to resume a previous conversation",
+        )
+
+        if st.button("🔗 Join Session") and custom_thread_id:
+            st.session_state.current_thread_id = custom_thread_id
+            # Load conversation history for this thread
+            history = agent.get_conversation_history(custom_thread_id)
+            st.session_state.conversation_history = history
+            # Load user profile for this thread
+            profile = agent.get_user_profile(custom_thread_id)
+            st.session_state.user_profile = profile
+            st.success(f"Joined session: {custom_thread_id[:8]}...")
+            st.rerun()
+
+        st.markdown("---")
+
+        # Dataset info
+        st.markdown("### 📊 Dataset Info")
+        col1, col2 = st.columns(2)
+        with col1:
+            st.metric("📝 Records", f"{len(df):,}")
+        with col2:
+            st.metric("📂 Categories", len(df["category"].unique()))
+
+        st.metric("🎯 Intents", len(df["intent"].unique()))
+
+        # Quick examples
+        st.markdown("### 💡 Try These Queries")
+        example_queries = [
+            "What are the most common categories?",
+            "Show me examples of billing issues",
+            "Summarize the refund category",
+            "What should I query next?",
+            "What do you remember about me?",
+        ]
+
+        for query in example_queries:
+            if st.button(f"💬 {query}", key=f"example_{hash(query)}"):
+                st.session_state.pending_query = query
+                st.rerun()
+
+    # Main content area
+    # Display user profile
+    if st.session_state.user_profile:
+        display_user_profile(st.session_state.user_profile)
+
+    # Dataset information in expandable section
+    with st.expander("📊 Dataset Information", expanded=False):
+        st.markdown("### Dataset Details")
+
+        metrics_col1, metrics_col2, metrics_col3, metrics_col4 = st.columns(4)
+        with metrics_col1:
+            st.metric("Total Records", f"{len(df):,}")
+        with metrics_col2:
+            st.metric("Columns", len(df.columns))
+        with metrics_col3:
+            st.metric("Categories", len(df["category"].unique()))
+        with metrics_col4:
+            st.metric("Intents", len(df["intent"].unique()))
+
+        st.markdown("### Sample Data")
+        st.dataframe(df.head(), use_container_width=True)
+
+        st.markdown("### Category Distribution")
+        st.bar_chart(df["category"].value_counts())
+
+    # User input section
+    st.markdown("## 💬 Chat with the Agent")
+
+    # Handle pending query from sidebar
+    has_pending_query = hasattr(st.session_state, "pending_query")
+    if has_pending_query:
+        user_question = st.session_state.pending_query
+        delattr(st.session_state, "pending_query")
+    else:
+        user_question = st.text_input(
+            "Ask your question:",
+            placeholder="e.g., What are the most common customer issues?",
+            key="user_input",
+            help="Ask about statistics, examples, insights, or request recommendations",
+        )
+
+    # Submit button
+    col1, col2, col3 = st.columns([1, 2, 1])
+    with col2:
+        submit_clicked = st.button("🚀 Send Message", use_container_width=True)
+
+    # Process query
+    if (submit_clicked or has_pending_query) and user_question:
+        # Add user message to local history
+        timestamp = datetime.now().strftime("%H:%M:%S")
+        st.session_state.conversation_history.append(
+            {"role": "human", "content": user_question, "timestamp": timestamp}
+        )
+
+        # Show thinking indicator
+        thinking_placeholder = st.empty()
+        thinking_placeholder.markdown(
+            """
+        <div class="thinking-indicator">
+            <div class="info-card">
+                ⚙️ <strong>Agent is thinking...</strong> 
+                Processing your query through the LangGraph workflow.
+            </div>
+        </div>
+        """,
+            unsafe_allow_html=True,
+        )
+
+        try:
+            # Invoke the agent
+            result = agent.invoke(user_question, st.session_state.current_thread_id)
+
+            # Get the last assistant message
+            assistant_response = None
+            for msg in reversed(result["messages"]):
+                if (
+                    hasattr(msg, "content")
+                    and msg.content
+                    and not isinstance(msg, type(user_question))
+                ):
+                    # Check if this is an AI message (not human or tool message)
+                    if not hasattr(msg, "tool_calls") or not msg.tool_calls:
+                        if "human" not in str(type(msg)).lower():
+                            content = msg.content
+
+                            # Clean up Qwen model thinking tags
+                            if "<think>" in content and "</think>" in content:
+                                # Extract only the part after </think>
+                                parts = content.split("</think>")
+                                if len(parts) > 1:
+                                    content = parts[1].strip()
+
+                            assistant_response = content
+                            break
+
+            if not assistant_response:
+                assistant_response = "I processed your query but couldn't generate a response. Please try again."
+
+            # Add assistant response to local history
+            st.session_state.conversation_history.append(
+                {
+                    "role": "assistant",
+                    "content": assistant_response,
+                    "timestamp": datetime.now().strftime("%H:%M:%S"),
+                }
+            )
+
+            # Update user profile from agent state
+            if result.get("user_profile"):
+                st.session_state.user_profile = result["user_profile"]
+
+        except Exception as e:
+            error_msg = f"Sorry, I encountered an error: {str(e)}"
+            st.session_state.conversation_history.append(
+                {
+                    "role": "assistant",
+                    "content": error_msg,
+                    "timestamp": datetime.now().strftime("%H:%M:%S"),
+                }
+            )
+
+        finally:
+            thinking_placeholder.empty()
+
+        # Clear the input and rerun to show new messages
+        st.rerun()
+
+    # Display conversation
+    if st.session_state.conversation_history:
+        st.markdown("## 💭 Conversation")
+
+        # Display messages
+        for i, message in enumerate(st.session_state.conversation_history):
+            message_html = format_conversation_message(
+                message["role"], message["content"], message.get("timestamp", "")
+            )
+            st.markdown(message_html, unsafe_allow_html=True)
+
+            # Add separator except for last message
+            if i < len(st.session_state.conversation_history) - 1:
+                st.markdown("---")
+
+        # Action buttons
+        col1, col2, col3 = st.columns(3)
+
+        with col1:
+            if st.button("🗑️ Clear Chat"):
+                st.session_state.conversation_history = []
+                st.rerun()
+
+        with col2:
+            if st.button("💾 Export Chat"):
+                chat_data = {
+                    "session_id": st.session_state.current_thread_id,
+                    "timestamp": datetime.now().isoformat(),
+                    "conversation": st.session_state.conversation_history,
+                    "user_profile": st.session_state.user_profile,
+                }
+                st.download_button(
+                    label="📥 Download JSON",
+                    data=json.dumps(chat_data, indent=2),
+                    file_name=f"chat_export_{st.session_state.current_thread_id[:8]}.json",
+                    mime="application/json",
+                )
+
+        with col3:
+            if st.button("🤖 Get Recommendations"):
+                st.session_state.pending_query = "What should I query next?"
+                st.rerun()
+
+    # Instructions
+    with st.expander("📋 How to Use This Agent", expanded=False):
+        st.markdown(
+            """
+        ### 🎯 Query Types Supported:
+        
+        **Structured Queries (Quantitative):**
+        - "How many records are in each category?"
+        - "Show me 5 examples of billing issues"
+        - "What are the most common intents?"
+        
+        **Unstructured Queries (Qualitative):**
+        - "Summarize the refund category"
+        - "What patterns do you see in payment issues?"
+        - "Analyze customer sentiment in billing conversations"
+        
+        **Memory & Recommendations:**
+        - "What do you remember about me?"
+        - "What should I query next?"
+        - "Advise me what to explore"
+        
+        ### 🧠 Memory Features:
+        - **Session Persistence:** Your conversations are saved across page reloads
+        - **User Profile:** The agent learns about your interests and preferences
+        - **Query History:** Past queries influence future recommendations
+        - **Cross-Session:** Use session IDs to resume conversations later
+        
+        ### 🔧 Advanced Features:
+        - **Multi-Agent Architecture:** Separate agents for different query types
+        - **Tool Usage:** Dynamic tool selection based on your needs
+        - **Interactive Recommendations:** Collaborative query refinement
+        """
+        )
+
+
+if __name__ == "__main__":
+    main()

langgraph_agent.py

@@ -0,0 +1,651 @@
+import json
+import os
+from enum import Enum
+from typing import Any, Dict, List, Optional, TypedDict
+
+import pandas as pd
+from langchain_core.messages import AIMessage, HumanMessage, SystemMessage
+from langchain_core.tools import tool
+from langchain_openai import ChatOpenAI
+from langgraph.checkpoint.memory import MemorySaver
+from langgraph.graph import END, START, StateGraph
+from langgraph.prebuilt import ToolNode
+from pydantic import BaseModel, Field
+
+
+# Enums for query types
+class QueryType(str, Enum):
+    STRUCTURED = "structured"
+    UNSTRUCTURED = "unstructured"
+    OUT_OF_SCOPE = "out_of_scope"
+    RECOMMEND_QUERY = "recommend_query"
+
+
+class AnalysisType(str, Enum):
+    QUANTITATIVE = "quantitative"
+    QUALITATIVE = "qualitative"
+    OUT_OF_SCOPE = "out_of_scope"
+
+
+# State definition
+class AgentState(TypedDict):
+    messages: List[Any]
+    query_type: Optional[str]
+    analysis_result: Optional[Dict[str, Any]]
+    user_profile: Optional[Dict[str, Any]]
+    session_context: Optional[Dict[str, Any]]
+    recommendations: Optional[List[str]]
+
+
+# User profile model
+class UserProfile(BaseModel):
+    interests: List[str] = Field(default_factory=list)
+    query_history: List[str] = Field(default_factory=list)
+    preferences: Dict[str, Any] = Field(default_factory=dict)
+    expertise_level: str = "beginner"
+
+
+# Dataset management
+class DatasetManager:
+    _instance = None
+    _df = None
+
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super(DatasetManager, cls).__new__(cls)
+        return cls._instance
+
+    def get_dataset(self) -> pd.DataFrame:
+        if self._df is None:
+            from datasets import load_dataset
+
+            dataset = load_dataset(
+                "bitext/Bitext-customer-support-llm-chatbot-training-dataset"
+            )
+            self._df = pd.DataFrame(dataset["train"])
+        return self._df
+
+
+# Tools for structured queries (quantitative analysis)
+@tool
+def get_category_distribution() -> Dict[str, int]:
+    """Get the distribution of categories in the dataset."""
+    df = DatasetManager().get_dataset()
+    return df["category"].value_counts().to_dict()
+
+
+@tool
+def get_intent_distribution() -> Dict[str, int]:
+    """Get the distribution of intents in the dataset."""
+    df = DatasetManager().get_dataset()
+    return df["intent"].value_counts().to_dict()
+
+
+@tool
+def get_dataset_stats() -> Dict[str, Any]:
+    """Get basic statistics about the dataset."""
+    df = DatasetManager().get_dataset()
+    return {
+        "total_records": len(df),
+        "unique_categories": len(df["category"].unique()),
+        "unique_intents": len(df["intent"].unique()),
+        "columns": df.columns.tolist(),
+    }
+
+
+@tool
+def get_examples_by_category(category: str, n: int = 5) -> List[Dict[str, Any]]:
+    """Get examples from a specific category."""
+    df = DatasetManager().get_dataset()
+    filtered_df = df[df["category"].str.lower() == category.lower()]
+    if filtered_df.empty:
+        return []
+    return filtered_df.head(n).to_dict("records")
+
+
+@tool
+def get_examples_by_intent(intent: str, n: int = 5) -> List[Dict[str, Any]]:
+    """Get examples from a specific intent."""
+    df = DatasetManager().get_dataset()
+    filtered_df = df[df["intent"].str.lower() == intent.lower()]
+    if filtered_df.empty:
+        return []
+    return filtered_df.head(n).to_dict("records")
+
+
+@tool
+def search_conversations(query: str, n: int = 5) -> List[Dict[str, Any]]:
+    """Search for conversations containing specific keywords."""
+    df = DatasetManager().get_dataset()
+    mask = df["customer"].str.contains(query, case=False, na=False) | df[
+        "agent"
+    ].str.contains(query, case=False, na=False)
+    filtered_df = df[mask]
+    return filtered_df.head(n).to_dict("records")
+
+
+# Tools for unstructured queries (qualitative analysis)
+@tool
+def get_category_summary(category: str) -> Dict[str, Any]:
+    """Get a summary of conversations in a specific category."""
+    df = DatasetManager().get_dataset()
+    filtered_df = df[df["category"].str.lower() == category.lower()]
+    if filtered_df.empty:
+        return {"error": f"No data found for category: {category}"}
+
+    return {
+        "category": category,
+        "count": len(filtered_df),
+        "unique_intents": filtered_df["intent"].nunique(),
+        "intents": filtered_df["intent"].value_counts().to_dict(),
+        "sample_conversations": filtered_df.head(3).to_dict("records"),
+    }
+
+
+@tool
+def get_intent_summary(intent: str) -> Dict[str, Any]:
+    """Get a summary of conversations for a specific intent."""
+    df = DatasetManager().get_dataset()
+    filtered_df = df[df["intent"].str.lower() == intent.lower()]
+    if filtered_df.empty:
+        return {"error": f"No data found for intent: {intent}"}
+
+    return {
+        "intent": intent,
+        "count": len(filtered_df),
+        "categories": filtered_df["category"].value_counts().to_dict(),
+        "sample_conversations": filtered_df.head(3).to_dict("records"),
+    }
+
+
+# Memory tools
+@tool
+def update_user_profile(
+    interests: List[str], preferences: Dict[str, Any], expertise_level: str = "beginner"
+) -> Dict[str, Any]:
+    """Update the user's profile with new information."""
+    return {
+        "interests": interests,
+        "preferences": preferences,
+        "expertise_level": expertise_level,
+        "updated": True,
+    }
+
+
+# Define tool lists for different agents
+structured_tools = [
+    get_category_distribution,
+    get_intent_distribution,
+    get_dataset_stats,
+    get_examples_by_category,
+    get_examples_by_intent,
+    search_conversations,
+]
+
+unstructured_tools = [
+    get_category_summary,
+    get_intent_summary,
+    search_conversations,
+    get_examples_by_category,
+    get_examples_by_intent,
+]
+
+memory_tools = [update_user_profile]
+
+
+class DataAnalystAgent:
+    def __init__(self, api_key: str, model_name: str = None):
+        # Determine if using Nebius or OpenAI based on API key source
+        is_nebius = os.environ.get("NEBIUS_API_KEY") == api_key
+
+        if is_nebius:
+            # Configure for Nebius API
+            self.llm = ChatOpenAI(
+                api_key=api_key,
+                model=model_name or "Qwen/Qwen3-30B-A3B",
+                base_url="https://api.studio.nebius.com/v1",
+                temperature=0,
+            )
+        else:
+            # Configure for OpenAI API
+            self.llm = ChatOpenAI(
+                api_key=api_key, model=model_name or "gpt-4o", temperature=0
+            )
+
+        self.memory = MemorySaver()
+        self.graph = self._build_graph()
+
+    def _build_graph(self) -> StateGraph:
+        """Build the LangGraph workflow."""
+        builder = StateGraph(AgentState)
+
+        # Add nodes
+        builder.add_node("classifier", self._classify_query)
+        builder.add_node("structured_agent", self._structured_agent)
+        builder.add_node("unstructured_agent", self._unstructured_agent)
+        builder.add_node("structured_tools", ToolNode(structured_tools))
+        builder.add_node("unstructured_tools", ToolNode(unstructured_tools))
+        builder.add_node("summarizer", self._update_summary)
+        builder.add_node("recommender", self._recommend_queries)
+        builder.add_node("out_of_scope", self._handle_out_of_scope)
+
+        # Add edges
+        builder.add_edge(START, "classifier")
+
+        # Conditional edges from classifier
+        builder.add_conditional_edges(
+            "classifier",
+            self._route_query,
+            {
+                "structured": "structured_agent",
+                "unstructured": "unstructured_agent",
+                "out_of_scope": "out_of_scope",
+                "recommend_query": "recommender",
+            },
+        )
+
+        # Tool routing for structured agent
+        builder.add_conditional_edges(
+            "structured_agent",
+            self._should_use_tools,
+            {"tools": "structured_tools", "end": "summarizer"},
+        )
+
+        # Tool routing for unstructured agent
+        builder.add_conditional_edges(
+            "unstructured_agent",
+            self._should_use_tools,
+            {"tools": "unstructured_tools", "end": "summarizer"},
+        )
+
+        # From tools back to respective agents
+        builder.add_edge("structured_tools", "structured_agent")
+        builder.add_edge("unstructured_tools", "unstructured_agent")
+
+        # End edges
+        builder.add_edge("summarizer", END)
+        builder.add_edge("out_of_scope", END)
+        builder.add_edge("recommender", END)
+
+        return builder.compile(checkpointer=self.memory)
+
+    def _classify_query(self, state: AgentState) -> AgentState:
+        """Classify the user query into different types."""
+        last_message = state["messages"][-1]
+        user_query = last_message.content.lower()
+
+        # Simple keyword-based classification for better reliability
+        # Check for recommendation requests first
+        if any(
+            word in user_query
+            for word in [
+                "what should i",
+                "what to query",
+                "recommend",
+                "suggest",
+                "advise",
+                "what next",
+                "what can i ask",
+            ]
+        ):
+            query_type = "recommend_query"
+
+        # Check for out of scope queries
+        elif any(
+            word in user_query
+            for word in [
+                "weather",
+                "news",
+                "sports",
+                "politics",
+                "cooking",
+                "travel",
+                "music",
+                "movies",
+                "games",
+                "programming",
+                "code",
+            ]
+        ) and not any(
+            word in user_query
+            for word in ["category", "intent", "customer", "support", "data", "records"]
+        ):
+            query_type = "out_of_scope"
+
+        # Check for unstructured/qualitative queries
+        elif any(
+            word in user_query
+            for word in [
+                "summarize",
+                "summary",
+                "patterns",
+                "insights",
+                "analysis",
+                "analyze",
+                "themes",
+                "trends",
+                "what patterns",
+                "understand",
+            ]
+        ):
+            query_type = "unstructured"
+
+        # Default to structured for data-related queries
+        else:
+            query_type = "structured"
+
+        # Double-check with LLM for edge cases, but use simpler prompt
+        if query_type == "out_of_scope":
+            simple_prompt = f"""
+            Is this question about customer support data analysis? 
+            Question: "{last_message.content}"
+            
+            Answer only "yes" or "no".
+            """
+
+            try:
+                response = self.llm.invoke([HumanMessage(content=simple_prompt)])
+                if "yes" in response.content.lower():
+                    query_type = "structured"  # Override if actually about data
+            except Exception:
+                pass  # Keep original classification if LLM fails
+
+        state["query_type"] = query_type
+        return state
+
+    def _route_query(self, state: AgentState) -> str:
+        """Route to appropriate agent based on classification."""
+        return state["query_type"]
+
+    def _structured_agent(self, state: AgentState) -> AgentState:
+        """Handle structured/quantitative queries."""
+
+        system_prompt = """
+        You are a data analyst that MUST use tools to answer questions about 
+        customer support data. You have access to these tools:
+        
+        - get_category_distribution: Get category counts
+        - get_intent_distribution: Get intent counts  
+        - get_dataset_stats: Get basic dataset statistics
+        - get_examples_by_category: Get examples from a category
+        - get_examples_by_intent: Get examples from an intent
+        - search_conversations: Search for conversations with keywords
+        
+        IMPORTANT: Always use the appropriate tool to get real data. 
+        Do NOT make up or guess answers. Use tools to get actual numbers.
+        
+        For questions about:
+        - "How many categories" or "category distribution" → use get_category_distribution
+        - "How many intents" or "intent distribution" → use get_intent_distribution  
+        - "Total records" or "dataset size" → use get_dataset_stats
+        - "Examples of X" → use get_examples_by_category or get_examples_by_intent
+        - "Search for X" → use search_conversations
+        """
+
+        llm_with_tools = self.llm.bind_tools(structured_tools)
+        messages = [SystemMessage(content=system_prompt)] + state["messages"]
+        response = llm_with_tools.invoke(messages)
+
+        state["messages"].append(response)
+        return state
+
+    def _unstructured_agent(self, state: AgentState) -> AgentState:
+        """Handle unstructured/qualitative queries."""
+
+        system_prompt = """
+        You are a data analyst that MUST use tools to provide insights about 
+        customer support data. You have access to these tools:
+        
+        - get_category_summary: Get detailed summary of a category
+        - get_intent_summary: Get detailed summary of an intent
+        - search_conversations: Search conversations for patterns
+        - get_examples_by_category: Get examples to analyze patterns
+        - get_examples_by_intent: Get examples to analyze patterns
+        
+        IMPORTANT: Always use the appropriate tool to get real data.
+        Do NOT make up or guess insights. Use tools to get actual data first.
+        
+        For questions about:
+        - "Summarize X category" → use get_category_summary
+        - "Analyze X intent" → use get_intent_summary
+        - "Patterns in X" → use get_examples_by_category or search_conversations
+        """
+
+        llm_with_tools = self.llm.bind_tools(unstructured_tools)
+        messages = [SystemMessage(content=system_prompt)] + state["messages"]
+        response = llm_with_tools.invoke(messages)
+
+        state["messages"].append(response)
+        return state
+
+    def _should_use_tools(self, state: AgentState) -> str:
+        """Determine if the agent should use tools or end."""
+        last_message = state["messages"][-1]
+
+        # Check if LLM made tool calls
+        if hasattr(last_message, "tool_calls") and last_message.tool_calls:
+            return "tools"
+
+        # If no tool calls but this is the first response from agent,
+        # force tool usage for data questions
+        messages = state["messages"]
+        human_messages = [msg for msg in messages if isinstance(msg, HumanMessage)]
+
+        if len(human_messages) >= 1:
+            last_human_msg = human_messages[-1].content.lower()
+
+            # Check if this looks like a data question that needs tools
+            needs_tools = any(
+                word in last_human_msg
+                for word in [
+                    "how many",
+                    "show me",
+                    "examples",
+                    "distribution",
+                    "categories",
+                    "intents",
+                    "records",
+                    "statistics",
+                    "stats",
+                    "count",
+                    "total",
+                    "billing",
+                    "refund",
+                    "payment",
+                    "technical",
+                    "support",
+                ]
+            )
+
+            # Count AI messages - if this is first AI response and needs tools, force it
+            ai_messages = [msg for msg in messages if not isinstance(msg, HumanMessage)]
+            if needs_tools and len(ai_messages) <= 1:
+                return "tools"
+
+        return "end"
+
+    def _update_summary(self, state: AgentState) -> AgentState:
+        """Update user profile/summary based on the interaction."""
+        user_profile = state.get("user_profile", {})
+        last_human_message = None
+
+        # Find the last human message
+        for msg in reversed(state["messages"]):
+            if isinstance(msg, HumanMessage):
+                last_human_message = msg
+                break
+
+        if last_human_message:
+            # Extract information about user interests
+            system_prompt = """
+            Based on the user's question, extract information about their 
+            interests and update their profile. Consider:
+            - What categories/intents they're interested in
+            - Their level of technical detail preference
+            - Types of analysis they prefer
+            
+            Return a JSON with:
+            {
+                "interests": ["list of topics they seem interested in"],
+                "preferences": {"any preferences about analysis style"},
+                "expertise_level": "beginner/intermediate/advanced"
+            }
+            
+            If no clear information can be extracted, return empty lists/dicts.
+            """
+
+            messages = [
+                SystemMessage(content=system_prompt),
+                HumanMessage(content=f"User question: {last_human_message.content}"),
+            ]
+
+            try:
+                response = self.llm.invoke(messages)
+                profile_update = json.loads(response.content)
+
+                # Merge with existing profile
+                if not user_profile:
+                    user_profile = {
+                        "interests": [],
+                        "preferences": {},
+                        "expertise_level": "beginner",
+                        "query_history": [],
+                    }
+
+                # Update interests (avoid duplicates)
+                new_interests = profile_update.get("interests", [])
+                existing_interests = user_profile.get("interests", [])
+                user_profile["interests"] = list(
+                    set(existing_interests + new_interests)
+                )
+
+                # Update preferences
+                user_profile["preferences"].update(
+                    profile_update.get("preferences", {})
+                )
+
+                # Update expertise level if provided
+                if profile_update.get("expertise_level"):
+                    user_profile["expertise_level"] = profile_update["expertise_level"]
+
+                # Add to query history
+                if "query_history" not in user_profile:
+                    user_profile["query_history"] = []
+                user_profile["query_history"].append(last_human_message.content)
+
+                # Keep only last 10 queries
+                user_profile["query_history"] = user_profile["query_history"][-10:]
+
+            except (json.JSONDecodeError, Exception):
+                # If parsing fails, just add to query history
+                if not user_profile:
+                    user_profile = {"query_history": []}
+                if "query_history" not in user_profile:
+                    user_profile["query_history"] = []
+                user_profile["query_history"].append(last_human_message.content)
+                user_profile["query_history"] = user_profile["query_history"][-10:]
+
+        state["user_profile"] = user_profile
+        return state
+
+    def _recommend_queries(self, state: AgentState) -> AgentState:
+        """Recommend next queries based on conversation history and user profile."""
+        user_profile = state.get("user_profile", {})
+        query_history = user_profile.get("query_history", [])
+        interests = user_profile.get("interests", [])
+
+        # Get dataset info for context
+        df = DatasetManager().get_dataset()
+        categories = df["category"].unique().tolist()
+        intents = df["intent"].unique()[:20].tolist()
+
+        system_prompt = f"""
+        You are a query recommendation assistant. Based on the user's conversation 
+        history and interests, suggest relevant follow-up questions they could ask 
+        about the customer support dataset.
+        
+        User's query history: {query_history}
+        User's interests: {interests}
+        
+        Available categories: {categories}
+        Sample intents: {intents}
+        
+        Suggest 3-5 relevant questions the user might want to ask next. Consider:
+        - Natural follow-ups to their previous questions
+        - Related categories or intents they haven't explored
+        - Different types of analysis (if they've only done quantitative, 
+          suggest qualitative and vice versa)
+        
+        Be conversational and explain why each suggestion might be interesting.
+        Start with "Based on your previous queries, you might want to..."
+        """
+
+        messages = [SystemMessage(content=system_prompt)]
+
+        # Add conversation context
+        if state["messages"]:
+            messages.extend(state["messages"])
+        else:
+            messages.append(HumanMessage(content="What should I query next?"))
+
+        response = self.llm.invoke(messages)
+        state["messages"].append(response)
+
+        return state
+
+    def _handle_out_of_scope(self, state: AgentState) -> AgentState:
+        """Handle queries that are out of scope."""
+        response = AIMessage(
+            content="I'm sorry, but I can only answer questions about the customer "
+            "support dataset. Please ask questions about categories, intents, "
+            "conversation examples, or data statistics."
+        )
+        state["messages"].append(response)
+        return state
+
+    def invoke(self, message: str, thread_id: str) -> Dict[str, Any]:
+        """Invoke the agent with a message and thread ID."""
+        config = {"configurable": {"thread_id": thread_id}}
+
+        # Create input state
+        input_state = {"messages": [HumanMessage(content=message)]}
+
+        # Invoke the graph
+        result = self.graph.invoke(input_state, config)
+
+        return result
+
+    def get_conversation_history(self, thread_id: str) -> List[Dict[str, Any]]:
+        """Get conversation history for a thread."""
+        config = {"configurable": {"thread_id": thread_id}}
+
+        try:
+            # Get the current state
+            state = self.graph.get_state(config)
+            if state and state.values.get("messages"):
+                return [
+                    {
+                        "role": (
+                            "human" if isinstance(msg, HumanMessage) else "assistant"
+                        ),
+                        "content": msg.content,
+                    }
+                    for msg in state.values["messages"]
+                ]
+        except Exception:
+            pass
+
+        return []
+
+    def get_user_profile(self, thread_id: str) -> Dict[str, Any]:
+        """Get user profile for a thread."""
+        config = {"configurable": {"thread_id": thread_id}}
+
+        try:
+            state = self.graph.get_state(config)
+            if state and state.values.get("user_profile"):
+                return state.values["user_profile"]
+        except Exception:
+            pass
+
+        return {}

requirements.txt

@@ -1,3 +1,12 @@
-altair
-pandas
-streamlit
+streamlit>=1.28.0
+pandas>=2.0.0
+datasets>=2.14.0
+openai>=1.3.0
+pydantic>=2.4.0
+python-dotenv>=1.0.0
+requests>=2.31.0
+langgraph>=0.2.0
+langchain>=0.2.0
+langchain-core>=0.2.0
+langchain-openai>=0.1.0
+langsmith>=0.1.0