Customer Support Bot

from supermemory import Supermemory
import os
from typing import Dict, List, Any, Optional
from datetime import datetime
from enum import Enum

class InteractionType(Enum):
    CHAT = "chat"
    EMAIL = "email"
    PHONE = "phone"
    TICKET = "ticket"

class Priority(Enum):
    LOW = "low"
    MEDIUM = "medium"
    HIGH = "high"
    URGENT = "urgent"

class Status(Enum):
    OPEN = "open"
    PENDING = "pending"
    RESOLVED = "resolved"
    CLOSED = "closed"

class CustomerContextManager:
    def __init__(self):
        self.client = Supermemory(api_key=os.getenv("SUPERMEMORY_API_KEY"))

    def _get_container_tag(self, customer_id: str) -> str:
        return f"customer_{customer_id}"

    def add_interaction(self, customer_id: str, interaction: Dict[str, Any]) -> Dict:
        """Add a customer interaction to memory"""
        try:
            content = f"{interaction['type'].upper()}: {interaction['content']}"

            result = self.client.add(
                content=content,
                container_tag=self._get_container_tag(customer_id),
                metadata={
                    'type': 'customer_interaction',
                    'interactionType': interaction['type'],
                    'channel': interaction['channel'],
                    'outcome': interaction.get('outcome'),
                    'agentId': interaction.get('agentId'),
                    'timestamp': datetime.now().isoformat(),
                    **interaction.get('metadata', {})
                }
            )
            return result
        except Exception as e:
            print(f"Failed to add customer interaction: {e}")
            raise

    def get_customer_history(self, customer_id: str, limit: int = 10) -> List[Dict]:
        """Get customer interaction history"""
        try:
            memories = self.client.documents.list(
                container_tags=[self._get_container_tag(customer_id)],
                limit=limit,
                sort='updatedAt',
                order='desc'
            )

            return [
                {
                    'id': memory.id,
                    'content': memory.content,
                    'type': memory.metadata.get('interactionType', 'unknown') if memory.metadata else 'unknown',
                    'channel': memory.metadata.get('channel') if memory.metadata else None,
                    'outcome': memory.metadata.get('outcome') if memory.metadata else None,
                    'timestamp': memory.metadata.get('timestamp', memory.created_at) if memory.metadata else memory.created_at,
                    'agentId': memory.metadata.get('agentId') if memory.metadata else None
                }
                for memory in memories.memories
            ]
        except Exception as e:
            print(f"Failed to get customer history: {e}")
            raise

    def search_customer_context(self, customer_id: str, query: str) -> List[Dict]:
        """Search customer's interaction history"""
        try:
            results = self.client.search.memories(
                q=query,
                container_tag=self._get_container_tag(customer_id),
                threshold=0.6,
                limit=5,
                rerank=True
            )

            return [
                {
                    'content': result.memory,
                    'similarity': result.similarity,
                    'metadata': result.metadata
                }
                for result in results.results
            ]
        except Exception as e:
            print(f"Failed to search customer context: {e}")
            raise

    def track_issue(self, customer_id: str, issue: Dict[str, str]) -> Dict:
        """Track a customer support issue"""
        try:
            issue_content = f"""ISSUE: {issue['subject']}

Description: {issue['description']}
Category: {issue['category']}
Priority: {issue['priority']}
Status: {issue['status']}"""

            result = self.client.add(
                content=issue_content,
                container_tag=self._get_container_tag(customer_id),
                metadata={
                    'type': 'support_issue',
                    'subject': issue['subject'],
                    'category': issue['category'],
                    'priority': issue['priority'],
                    'status': issue['status'],
                    'createdAt': datetime.now().isoformat()
                }
            )
            return result
        except Exception as e:
            print(f"Failed to track issue: {e}")
            raise

    def update_issue_status(self, issue_id: str, status: str, resolution: Optional[str] = None) -> Dict:
        """Update the status of a support issue"""
        try:
            # Get original issue
            memory = self.client.documents.get(issue_id)
            customer_id = (memory.container_tags[0] if memory.container_tags else '').replace('customer_', '')

            update_content = f"ISSUE UPDATE: {memory.metadata.get('subject', 'Unknown')}\nStatus changed to: {status}"
            if resolution:
                update_content += f"\nResolution: {resolution}"

            return self.add_interaction(customer_id, {
                'type': 'ticket',
                'content': update_content,
                'channel': 'internal',
                'outcome': 'resolved' if status == 'resolved' else 'pending',
                'metadata': {
                    'originalIssueId': issue_id,
                    'statusUpdate': True
                }
            })
        except Exception as e:
            print(f"Failed to update issue status: {e}")
            raise

from fastapi import FastAPI, HTTPException
from fastapi.responses import StreamingResponse
from pydantic import BaseModel
from typing import List, Dict, Any, Optional
import openai
from customer_context import CustomerContextManager
import json
import os
import re

app = FastAPI()

openai_client = openai.AsyncOpenAI(api_key=os.getenv("OPENAI_API_KEY"))
context_manager = CustomerContextManager()

class Customer(BaseModel):
    id: str
    name: str
    email: str
    tier: str
    joinDate: str

class SupportRequest(BaseModel):
    message: str
    customerId: str
    customer: Customer
    conversationHistory: List[Dict[str, str]] = []
    agentId: Optional[str] = None

def categorize_issue(message: str) -> str:
    """Categorize support issue based on message content"""
    categories = {
        'billing': ['bill', 'charge', 'payment', 'refund', 'price', 'cost'],
        'technical': ['error', 'bug', 'broken', 'not working', 'crash', 'slow'],
        'account': ['login', 'password', 'access', 'settings', 'profile'],
        'product': ['feature', 'how to', 'tutorial', 'help', 'guide']
    }

    message_lower = message.lower()

    for category, keywords in categories.items():
        if any(keyword in message_lower for keyword in keywords):
            return category

    return 'general'

def determine_priority(tier: str, message: str) -> str:
    """Determine issue priority based on tier and message content"""
    urgent_keywords = ['urgent', 'critical', 'emergency', 'down', 'broken']
    high_keywords = ['important', 'asap', 'soon', 'problem']

    message_lower = message.lower()

    if any(keyword in message_lower for keyword in urgent_keywords):
        return 'urgent'

    if tier == 'enterprise':
        return 'urgent' if any(keyword in message_lower for keyword in high_keywords) else 'high'

    if tier == 'pro':
        return 'high' if any(keyword in message_lower for keyword in high_keywords) else 'medium'

    return 'low'

@app.post("/support/chat")
async def support_chat(request: SupportRequest):
    try:
        # Get customer history and context
        history = context_manager.get_customer_history(request.customerId, 5)
        context_results = context_manager.search_customer_context(request.customerId, request.message)

        # Build customer context
        customer_context = f"""
CUSTOMER PROFILE:
- Name: {request.customer.name}
- Email: {request.customer.email}
- Tier: {request.customer.tier.upper()}
- Member since: {request.customer.joinDate}

RECENT INTERACTIONS (Last 5):
{chr(10).join([f"- {h['timestamp']}: {h['type'].upper()} - {h['content'][:100]}..." for h in history])}

RELEVANT CONTEXT:
{chr(10).join([f"- {c['content'][:150]}... ({c['similarity']*100:.1f}% relevant)" for c in context_results])}
        """.strip()

        # Determine if escalation is needed
        escalation_keywords = ['angry', 'frustrated', 'cancel', 'refund', 'legal', 'complaint', 'manager', 'supervisor']
        needs_escalation = any(keyword in request.message.lower() for keyword in escalation_keywords) or request.customer.tier == 'enterprise'

        system_prompt = f"""You are a helpful customer support agent with access to complete customer history and context.

CUSTOMER CONTEXT:
{customer_context}

SUPPORT GUIDELINES:
1. **Personalization**: Address the customer by name and reference their tier/history when relevant
2. **Context Awareness**: Use previous interactions to inform your response
3. **Tier-Specific Service**:
- Free: Standard support, guide to self-service resources
- Pro: Priority support, detailed explanations, proactive suggestions
- Enterprise: White-glove service, immediate escalation path, dedicated attention

4. **Issue Tracking**: If this is a new issue, categorize it (billing, technical, account, product)
5. **Escalation**: {'This interaction may need human agent escalation - provide helpful response but prepare escalation summary' if needs_escalation else 'Handle directly unless customer specifically requests human agent'}

RESPONSE STYLE:
- Professional but friendly
- Reference specific details from customer history when relevant
- Provide actionable next steps
- Include relevant links or resources for their tier level

If you cannot resolve the issue completely, prepare a clear summary for escalation to human agents."""

        messages = [
            {"role": "system", "content": system_prompt},
            *request.conversationHistory,
            {"role": "user", "content": request.message}
        ]

        response = await openai_client.chat.completions.create(
            model="gpt-5",
            messages=messages,
            temperature=0.3,
            max_tokens=800,
            stream=True
        )

        async def generate():
            full_response = ""
            async for chunk in response:
                if chunk.choices[0].delta.content:
                    content = chunk.choices[0].delta.content
                    full_response += content
                    yield f"data: {json.dumps({'content': content})}\n\n"

            # Store interaction after completion
            context_manager.add_interaction(request.customerId, {
                'type': 'chat',
                'content': f"Customer: {request.message}\nAgent: {full_response}",
                'channel': 'web_chat',
                'outcome': 'escalated' if needs_escalation else 'resolved',
                'agentId': request.agentId,
                'metadata': {
                    'customerTier': request.customer.tier,
                    'needsEscalation': needs_escalation,
                    'responseLength': len(full_response)
                }
            })

            # Track new issues
            if len(request.message) > 50 and not any(c['similarity'] > 0.8 for c in context_results):
                issue_category = categorize_issue(request.message)
                priority = determine_priority(request.customer.tier, request.message)

                context_manager.track_issue(request.customerId, {
                    'subject': request.message[:100],
                    'description': request.message,
                    'category': issue_category,
                    'priority': priority,
                    'status': 'pending' if needs_escalation else 'open'
                })

            yield f"data: {json.dumps({'done': True, 'needsEscalation': needs_escalation})}\n\n"

        return StreamingResponse(generate(), media_type="text/plain")

    except Exception as e:
        raise HTTPException(status_code=500, detail=f"Support chat error: {str(e)}")

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)