
    """
Pattern 232: Chatbot

Purpose: Goal-oriented chatbot with intent recognition, dialogue flow, and response generation.
Handles predefined intents, manages conversation state, and provides structured responses.
"""

from typing import Dict, Any, List, Optional, Callable
from dataclasses import dataclass, field
from datetime import datetime
from enum import Enum
from collections import defaultdict
import re
from langchain_core.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI


class IntentType(Enum):
    """Common chatbot intents."""
    GREETING = "greeting"
    FAREWELL = "farewell"
    HELP = "help"
    FAQ = "faq"
    BOOKING = "booking"
    INQUIRY = "inquiry"
    COMPLAINT = "complaint"
    FEEDBACK = "feedback"
    CHITCHAT = "chitchat"
    UNKNOWN = "unknown"


class FlowState(Enum):
    """States in conversation flow."""
    INITIAL = "initial"
    COLLECTING_INFO = "collecting_info"
    CONFIRMING = "confirming"
    PROCESSING = "processing"
    COMPLETED = "completed"
    ERROR = "error"


@dataclass
class Intent:
    """Recognized user intent."""
    type: IntentType
    confidence: float
    entities: Dict[str, Any] = field(default_factory=dict)
    raw_input: str = ""


@dataclass
class Response:
    """Chatbot response."""
    text: str
    intent: IntentType
    follow_up_questions: List[str] = field(default_factory=list)
    actions: List[str] = field(default_factory=list)
    timestamp: datetime = field(default_factory=datetime.now)


@dataclass
class ConversationFlow:
    """Manages conversation flow state."""
    current_state: FlowState = FlowState.INITIAL
    required_fields: List[str] = field(default_factory=list)
    collected_fields: Dict[str, Any] = field(default_factory=dict)
    flow_type: Optional[IntentType] = None


class Chatbot:
    """
    Chatbot - Goal-oriented dialogue with intent recognition and flow management.
    
    Features:
    - Intent recognition with pattern matching
    - Entity extraction
    - Dialogue flow management
    - FAQ handling
    - Context-aware responses
    """
    
    def __init__(self,
                 name: str,
                 domain: str = "general",
                 supported_intents: Optional[List[IntentType]] = None):
        self.name = name
        self.domain = domain
        self.supported_intents = supported_intents or [intent for intent in IntentType]
        self.llm = ChatOpenAI(model="gpt-4", temperature=0.7)
        
        # Intent patterns
        self.intent_patterns: Dict[IntentType, List[str]] = self._init_intent_patterns()
        
        # FAQ knowledge base
        self.faq_db: Dict[str, str] = {}
        
        # Conversation state
        self.current_flow: Optional[ConversationFlow] = None
        self.conversation_history: List[Dict[str, Any]] = []
        
        # Response handlers
        self.response_handlers: Dict[IntentType, Callable] = self._init_response_handlers()
        
        # Statistics
        self.statistics: Dict[str, Any] = {
            "total_messages": 0,
            "intent_counts": defaultdict(int),
            "avg_confidence": 0.0,
            "flow_completions": 0
        }
    
    def _init_intent_patterns(self) -> Dict[IntentType, List[str]]:
        """Initialize intent recognition patterns."""
        return {
            IntentType.GREETING: [
                r'\b(hi|hello|hey|greetings|good morning|good afternoon)\b',
                r'^(hi|hello|hey)[\s!.]*$'
            ],
            IntentType.FAREWELL: [
                r'\b(bye|goodbye|see you|farewell|take care)\b',
                r'^(bye|goodbye)[\s!.]*$'
            ],
            IntentType.HELP: [
                r'\b(help|assist|support|how do i|how can|what can)\b',
                r'^(help|assist me)\b'
            ],
            IntentType.FAQ: [
                r'\b(what is|tell me about|explain|how does|when is|where is)\b',
                r'\?$'
            ],
            IntentType.BOOKING: [
                r'\b(book|reserve|appointment|schedule|availability)\b',
                r'\b(i want to book|make a reservation)\b'
            ],
            IntentType.INQUIRY: [
                r'\b(information|details|more about|interested in)\b',
                r'\b(can you tell|would like to know)\b'
            ],
            IntentType.COMPLAINT: [
                r'\b(problem|issue|complaint|not working|broken|unhappy)\b',
                r'\b(dissatisfied|disappointed|frustrated)\b'
            ],
            IntentType.FEEDBACK: [
                r'\b(feedback|suggestion|recommend|improve|better)\b',
                r'\b(would like to suggest|my opinion)\b'
            ],
            IntentType.CHITCHAT: [
                r'\b(weather|today|how are you|nice day|weekend)\b',
                r'\b(thanks|thank you|appreciate)\b'
            ]
        }
    
    def _init_response_handlers(self) -> Dict[IntentType, Callable]:
        """Initialize intent-specific response handlers."""
        return {
            IntentType.GREETING: self._handle_greeting,
            IntentType.FAREWELL: self._handle_farewell,
            IntentType.HELP: self._handle_help,
            IntentType.FAQ: self._handle_faq,
            IntentType.BOOKING: self._handle_booking,
            IntentType.INQUIRY: self._handle_inquiry,
            IntentType.COMPLAINT: self._handle_complaint,
            IntentType.FEEDBACK: self._handle_feedback,
            IntentType.CHITCHAT: self._handle_chitchat,
            IntentType.UNKNOWN: self._handle_unknown
        }
    
    def chat(self, user_input: str) -> Response:
        """Process user input and generate response."""
        self.statistics["total_messages"] += 1
        
        # Recognize intent
        intent = self._recognize_intent(user_input)
        self.statistics["intent_counts"][intent.type.value] += 1
        
        # Extract entities
        entities = self._extract_entities(user_input, intent.type)
        intent.entities = entities
        
        # Generate response using appropriate handler
        handler = self.response_handlers.get(intent.type, self._handle_unknown)
        response = handler(intent)
        
        # Record in history
        self.conversation_history.append({
            "user_input": user_input,
            "intent": intent.type.value,
            "confidence": intent.confidence,
            "response": response.text,
            "timestamp": datetime.now()
        })
        
        # Update statistics
        self._update_statistics()
        
        return response
    
    def _recognize_intent(self, user_input: str) -> Intent:
        """Recognize user intent from input."""
        user_lower = user_input.lower()
        best_intent = IntentType.UNKNOWN
        max_confidence = 0.0
        
        # Pattern matching
        for intent_type, patterns in self.intent_patterns.items():
            if intent_type not in self.supported_intents:
                continue
            
            for pattern in patterns:
                if re.search(pattern, user_lower):
                    # Simple confidence based on pattern specificity
                    confidence = 0.7 + (0.3 * len(pattern) / 100)
                    if confidence > max_confidence:
                        max_confidence = confidence
                        best_intent = intent_type
        
        # If no pattern matched, use LLM for classification
        if max_confidence  max_confidence:
                best_intent = llm_intent
                max_confidence = llm_confidence
        
        return Intent(
            type=best_intent,
            confidence=min(1.0, max_confidence),
            raw_input=user_input
        )
    
    def _llm_classify_intent(self, user_input: str) -> tuple:
        """Use LLM to classify intent when patterns don't match."""
        intent_options = ", ".join([i.value for i in self.supported_intents])
        
        prompt = ChatPromptTemplate.from_messages([
            ("system", f"You are an intent classifier for a {self.domain} chatbot. "
                      f"Classify the user input into one of these intents: {intent_options}. "
                      f"Respond with ONLY the intent name."),
            ("human", "{input}")
        ])
        
        chain = prompt | self.llm
        response = chain.invoke({"input": user_input})
        
        # Parse response
        intent_str = response.content.strip().lower()
        
        for intent_type in self.supported_intents:
            if intent_type.value in intent_str:
                return intent_type, 0.6
        
        return IntentType.UNKNOWN, 0.3
    
    def _extract_entities(self, user_input: str, intent_type: IntentType) -> Dict[str, Any]:
        """Extract entities from user input."""
        entities = {}
        
        # Simple entity extraction patterns
        # Date/time
        date_pattern = r'\b(\d{1,2}[/-]\d{1,2}[/-]\d{2,4}|\d{4}-\d{2}-\d{2})\b'
        dates = re.findall(date_pattern, user_input)
        if dates:
            entities["date"] = dates[0]
        
        # Time
        time_pattern = r'\b(\d{1,2}:\d{2}\s*(?:am|pm)?)\b'
        times = re.findall(time_pattern, user_input.lower())
        if times:
            entities["time"] = times[0]
        
        # Email
        email_pattern = r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b'
        emails = re.findall(email_pattern, user_input)
        if emails:
            entities["email"] = emails[0]
        
        # Phone
        phone_pattern = r'\b\d{3}[-.]?\d{3}[-.]?\d{4}\b'
        phones = re.findall(phone_pattern, user_input)
        if phones:
            entities["phone"] = phones[0]
        
        # Numbers
        number_pattern = r'\b\d+\b'
        numbers = re.findall(number_pattern, user_input)
        if numbers and intent_type == IntentType.BOOKING:
            entities["quantity"] = numbers[0]
        
        return entities
    
    # Intent handlers
    def _handle_greeting(self, intent: Intent) -> Response:
        """Handle greeting intent."""
        responses = [
            f"Hello! I'm {self.name}, your {self.domain} assistant. How can I help you today?",
            f"Hi there! Welcome to {self.name}. What can I do for you?",
            f"Greetings! I'm here to assist you with {self.domain}. What do you need?"
        ]
        
        import random
        return Response(
            text=random.choice(responses),
            intent=IntentType.GREETING,
            follow_up_questions=["What can I help you with today?"]
        )
    
    def _handle_farewell(self, intent: Intent) -> Response:
        """Handle farewell intent."""
        responses = [
            "Goodbye! Feel free to come back if you need anything!",
            "Take care! Have a great day!",
            "Bye! Thanks for chatting with me!"
        ]
        
        import random
        return Response(
            text=random.choice(responses),
            intent=IntentType.FAREWELL
        )
    
    def _handle_help(self, intent: Intent) -> Response:
        """Handle help request."""
        capabilities = [
            f"- Answer questions about {self.domain}",
            "- Help with bookings and appointments",
            "- Provide information and support",
            "- Handle complaints and feedback"
        ]
        
        help_text = f"I can help you with:\n" + "\n".join(capabilities)
        
        return Response(
            text=help_text,
            intent=IntentType.HELP,
            follow_up_questions=["What would you like to do?"]
        )
    
    def _handle_faq(self, intent: Intent) -> Response:
        """Handle FAQ query."""
        # Check if question matches FAQ database
        for question, answer in self.faq_db.items():
            if any(word in intent.raw_input.lower() for word in question.lower().split()):
                return Response(
                    text=answer,
                    intent=IntentType.FAQ,
                    follow_up_questions=["Is there anything else you'd like to know?"]
                )
        
        # Use LLM for dynamic FAQ
        prompt = ChatPromptTemplate.from_messages([
            ("system", f"You are a helpful {self.domain} assistant. "
                      f"Provide clear, concise answers to user questions."),
            ("human", "{question}")
        ])
        
        chain = prompt | self.llm
        response = chain.invoke({"question": intent.raw_input})
        
        return Response(
            text=response.content,
            intent=IntentType.FAQ,
            follow_up_questions=["Do you have any other questions?"]
        )
    
    def _handle_booking(self, intent: Intent) -> Response:
        """Handle booking request."""
        # Initialize or update booking flow
        if not self.current_flow or self.current_flow.flow_type != IntentType.BOOKING:
            self.current_flow = ConversationFlow(
                current_state=FlowState.COLLECTING_INFO,
                required_fields=["date", "time", "email"],
                flow_type=IntentType.BOOKING
            )
        
        # Collect entities
        for field, value in intent.entities.items():
            if field in self.current_flow.required_fields:
                self.current_flow.collected_fields[field] = value
        
        # Check what's still missing
        missing_fields = [f for f in self.current_flow.required_fields 
                         if f not in self.current_flow.collected_fields]
        
        if missing_fields:
            field = missing_fields[0]
            return Response(
                text=f"I'd be happy to help you book! What {field} would you prefer?",
                intent=IntentType.BOOKING,
                follow_up_questions=[f"Please provide your {field}"]
            )
        else:
            # All info collected
            self.current_flow.current_state = FlowState.CONFIRMING
            booking_details = ", ".join([f"{k}: {v}" for k, v in 
                                        self.current_flow.collected_fields.items()])
            return Response(
                text=f"Great! I've got your booking for {booking_details}. Shall I confirm?",
                intent=IntentType.BOOKING,
                follow_up_questions=["Reply 'yes' to confirm or 'no' to cancel"],
                actions=["prepare_booking"]
            )
    
    def _handle_inquiry(self, intent: Intent) -> Response:
        """Handle general inquiry."""
        prompt = ChatPromptTemplate.from_messages([
            ("system", f"You are a knowledgeable {self.domain} assistant. "
                      f"Provide helpful information about user inquiries."),
            ("human", "{inquiry}")
        ])
        
        chain = prompt | self.llm
        response = chain.invoke({"inquiry": intent.raw_input})
        
        return Response(
            text=response.content,
            intent=IntentType.INQUIRY,
            follow_up_questions=["Would you like more details about anything?"]
        )
    
    def _handle_complaint(self, intent: Intent) -> Response:
        """Handle complaint."""
        return Response(
            text="I'm sorry to hear you're experiencing issues. Let me help resolve this. "
                 "Can you provide more details about the problem?",
            intent=IntentType.COMPLAINT,
            follow_up_questions=["What specific issue are you facing?"],
            actions=["escalate_to_support"]
        )
    
    def _handle_feedback(self, intent: Intent) -> Response:
        """Handle feedback."""
        return Response(
            text="Thank you for your feedback! We really appreciate your input. "
                 "Your suggestions help us improve our service.",
            intent=IntentType.FEEDBACK,
            actions=["record_feedback"]
        )
    
    def _handle_chitchat(self, intent: Intent) -> Response:
        """Handle casual conversation."""
        prompt = ChatPromptTemplate.from_messages([
            ("system", "You are a friendly chatbot. Engage in brief, pleasant conversation."),
            ("human", "{message}")
        ])
        
        chain = prompt | self.llm
        response = chain.invoke({"message": intent.raw_input})
        
        return Response(
            text=response.content,
            intent=IntentType.CHITCHAT
        )
    
    def _handle_unknown(self, intent: Intent) -> Response:
        """Handle unknown intent."""
        return Response(
            text="I'm not sure I understood that. Could you rephrase, or ask me for help?",
            intent=IntentType.UNKNOWN,
            follow_up_questions=["Try asking in a different way", "Type 'help' to see what I can do"]
        )
    
    def add_faq(self, question: str, answer: str):
        """Add FAQ to knowledge base."""
        self.faq_db[question.lower()] = answer
        print(f"   Added FAQ: {question}")
    
    def _update_statistics(self):
        """Update chatbot statistics."""
        if self.conversation_history:
            confidences = [h["confidence"] for h in self.conversation_history]
            self.statistics["avg_confidence"] = sum(confidences) / len(confidences)
    
    def get_statistics(self) -> Dict[str, Any]:
        """Get chatbot statistics."""
        return {
            "name": self.name,
            "domain": self.domain,
            "total_messages": self.statistics["total_messages"],
            "intent_distribution": dict(self.statistics["intent_counts"]),
            "avg_confidence": self.statistics["avg_confidence"],
            "faq_count": len(self.faq_db)
        }


class ChatbotPattern:
    """
    Chatbot Pattern - Manage goal-oriented chatbots.
    
    Coordinates multiple chatbots for different domains.
    """
    
    def __init__(self):
        self.chatbots: Dict[str, Chatbot] = {}
    
    def register_chatbot(self, chatbot: Chatbot):
        """Register a chatbot."""
        self.chatbots[chatbot.name] = chatbot
        print(f"   Registered chatbot: {chatbot.name} ({chatbot.domain})")
    
    def run(self, chatbot_name: str, conversation: List[str]) -> Dict[str, Any]:
        """Run conversation with chatbot."""
        if chatbot_name not in self.chatbots:
            return {"error": f"Chatbot {chatbot_name} not found"}
        
        chatbot = self.chatbots[chatbot_name]
        responses = []
        
        print(f"\n=== Conversation with {chatbot_name} ===\n")
        
        for user_input in conversation:
            print(f"User: {user_input}")
            response = chatbot.chat(user_input)
            print(f"{chatbot_name}: {response.text}")
            if response.follow_up_questions:
                print(f"   Follow-up: {response.follow_up_questions[0]}")
            print()
            responses.append(response)
        
        return {
            "chatbot": chatbot_name,
            "turns": len(conversation),
            "responses": responses,
            "statistics": chatbot.get_statistics()
        }


# Example usage
if __name__ == "__main__":
    print("=== Chatbot Pattern Demo ===\n")
    
    # Create pattern
    pattern = ChatbotPattern()
    
    # Create chatbots for different domains
    print("1. Creating chatbots...")
    
    customer_service = Chatbot(
        name="CustomerServiceBot",
        domain="customer service",
        supported_intents=[IntentType.GREETING, IntentType.HELP, IntentType.FAQ, 
                          IntentType.COMPLAINT, IntentType.FAREWELL]
    )
    
    # Add FAQs
    customer_service.add_faq("What are your hours", "We're open Monday-Friday, 9 AM to 5 PM.")
    customer_service.add_faq("How do I return", "Returns are accepted within 30 days with receipt.")
    customer_service.add_faq("Shipping cost", "Shipping is free for orders over $50.")
    
    pattern.register_chatbot(customer_service)
    
    booking_bot = Chatbot(
        name="BookingBot",
        domain="restaurant reservations",
        supported_intents=[IntentType.GREETING, IntentType.BOOKING, IntentType.INQUIRY, IntentType.FAREWELL]
    )
    pattern.register_chatbot(booking_bot)
    
    # Run conversations
    print("\n2. Running conversations...")
    
    # Customer service conversation
    cs_conversation = [
        "Hello!",
        "I have a problem with my order",
        "It arrived damaged",
        "Thank you for your help"
    ]
    
    result1 = pattern.run("CustomerServiceBot", cs_conversation)
    
    # Booking conversation
    booking_conversation = [
        "Hi, I'd like to make a reservation",
        "For tomorrow at 7 PM",
        "My email is john@example.com",
        "Yes, please confirm"
    ]
    
    result2 = pattern.run("BookingBot", booking_conversation)
    
    # Print statistics
    print("\n3. Chatbot Statistics:")
    for name, chatbot in pattern.chatbots.items():
        stats = chatbot.get_statistics()
        print(f"\n   {name}:")
        for key, value in stats.items():
            if isinstance(value, float):
                print(f"      {key}: {value:.3f}")
            elif isinstance(value, dict):
                print(f"      {key}:")
                for k, v in value.items():
                    print(f"         {k}: {v}")
            else:
                print(f"      {key}: {value}")
    
    print("\n✓ Chatbots handled conversations with intent recognition and flow!")

Agentic Architecture Pattern: Chatbot

Pattern 232: 232 Chatbot – Line-by-Line Explanation

Overview

Pattern 232: Chatbot

Purpose: Goal-oriented chatbot with intent recognition, dialogue flow, and response generation. Handles predefined intents, manages conversation state, and provides structured responses.

Code Structure Analysis

File Information

Pattern Number: 232
Pattern Name: 232 Chatbot
File Path: patterns\domain_specific\232_chatbot.py
Total Lines: 596

Detailed Code Explanation

Module Docstring

"""
Pattern 232: Chatbot

Purpose: Goal-oriented chatbot with intent recognition, dialogue flow, and response generation.
Handles predefined intents, manages conversation state, and provides structured responses.
"""

Explanation: This module docstring describes the purpose and key features of the 232 Chatbot pattern.

Imports Section

from typing import Dict, Any, List, Optional, Callable
from dataclasses import dataclass, field
from datetime import datetime
from enum import Enum
from collections import defaultdict
import re
from langchain_core.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI
        import random
        import random  # First 20 imports shown

Explanation: The module imports necessary dependencies: – from typing import Dict, Any, List, Optional, Callable: Type hints for better code documentation – from dataclasses import dataclass, field: Data class decorators for clean data structures – from datetime import datetime: Date and time utilities – from enum import Enum: Enumeration support for fixed sets of values – from langchain_core.prompts import ChatPromptTemplate: LangChain framework integration – from langchain_openai import ChatOpenAI: LangChain framework integration

Enumerations

IntentType (Line 18)

class IntentType(Enum):
    GREETING
    FAREWELL
    HELP
    FAQ
    BOOKING
    INQUIRY
    COMPLAINT
    FEEDBACK
    CHITCHAT
    UNKNOWN

Purpose: Common chatbot intents.

Values: – GREETING: Represents greeting – FAREWELL: Represents farewell – HELP: Represents help – FAQ: Represents faq – BOOKING: Represents booking – INQUIRY: Represents inquiry – COMPLAINT: Represents complaint – FEEDBACK: Represents feedback – CHITCHAT: Represents chitchat – UNKNOWN: Represents unknown

FlowState (Line 32)

class FlowState(Enum):
    INITIAL
    COLLECTING_INFO
    CONFIRMING
    PROCESSING
    COMPLETED
    ERROR

Purpose: States in conversation flow.

Values: – INITIAL: Represents initial – COLLECTING_INFO: Represents collecting info – CONFIRMING: Represents confirming – PROCESSING: Represents processing – COMPLETED: Successfully finished – ERROR: Error severity level

Classes

IntentType (Line 18)

Description: Common chatbot intents.

FlowState (Line 32)

Description: States in conversation flow.

Intent (Line 43)

Description: Recognized user intent.

Response (Line 52)

Description: Chatbot response.

ConversationFlow (Line 62)

Description: Manages conversation flow state.

Chatbot (Line 70)

Description: Chatbot – Goal-oriented dialogue with intent recognition and flow management.

Features: – Intent recognition with pattern matching – Entity extraction – Dialogue flow management – FAQ handling – Context-aware responses

Methods:

`init` (Line 82)

def __init__(self, name, domain, supported_intents):
    """No method docstring."""

Purpose: No method docstring.

Parameters: – self: Instance reference – name: Identifier or label – domain: Parameter for domain – supported_intents: Parameter for supported_intents

`_init_intent_patterns` (Line 112)

def _init_intent_patterns(self):
    """Initialize intent recognition patterns."""

Purpose: Initialize intent recognition patterns.

Parameters: – self: Instance reference

`_init_response_handlers` (Line 153)

def _init_response_handlers(self):
    """Initialize intent-specific response handlers."""

Purpose: Initialize intent-specific response handlers.

Parameters: – self: Instance reference

`chat` (Line 168)

def chat(self, user_input):
    """Process user input and generate response."""

Purpose: Process user input and generate response.

Parameters: – self: Instance reference – user_input: Parameter for user_input

`_recognize_intent` (Line 198)

def _recognize_intent(self, user_input):
    """Recognize user intent from input."""

Purpose: Recognize user intent from input.

Parameters: – self: Instance reference – user_input: Parameter for user_input

`_llm_classify_intent` (Line 230)

def _llm_classify_intent(self, user_input):
    """Use LLM to classify intent when patterns don't match."""

Purpose: Use LLM to classify intent when patterns don’t match.

Parameters: – self: Instance reference – user_input: Parameter for user_input

`_extract_entities` (Line 253)

def _extract_entities(self, user_input, intent_type):
    """Extract entities from user input."""

Purpose: Extract entities from user input.

Parameters: – self: Instance reference – user_input: Parameter for user_input – intent_type: Parameter for intent_type