AI CHATBOT & CONVERSATIONAL AI

HOW WE DO IT

# Advanced Chatbot with Intent Recognition and Context Management

from transformers import pipeline
from langchain.chat_models import ChatOpenAI
from langchain.chains import ConversationChain
from langchain.memory import ConversationBufferMemory
import spacy

# Initialize NLU pipeline
nlp = spacy.load("en_core_web_sm")
intent_classifier = pipeline("text-classification",
    model="bert-base-uncased-finetuned-intent")

# Initialize LLM with memory
llm = ChatOpenAI(temperature=0.7, model="gpt-4")
memory = ConversationBufferMemory(return_messages=True)
conversation = ConversationChain(llm=llm, memory=memory)

class ChatbotEngine:
    def __init__(self):
        self.context = {}
        self.intents = {
            'greeting': self.handle_greeting,
            'product_inquiry': self.handle_product_inquiry,
            'order_status': self.handle_order_status,
            'complaint': self.escalate_to_human
        }

    def extract_entities(self, text):
        """Extract named entities and custom slots"""
        doc = nlp(text)
        entities = {
            'persons': [ent.text for ent in doc.ents if ent.label_ == 'PERSON'],
            'dates': [ent.text for ent in doc.ents if ent.label_ == 'DATE'],
            'products': [ent.text for ent in doc.ents if ent.label_ == 'PRODUCT']
        }
        return entities

    def classify_intent(self, text):
        """Classify user intent with confidence"""
        result = intent_classifier(text)[0]
        return {
            'intent': result['label'],
            'confidence': result['score']
        }

    def handle_message(self, user_message, user_id):
        """Main conversation handler"""

        # Extract intent and entities
        intent_result = self.classify_intent(user_message)
        entities = self.extract_entities(user_message)

        # Update context
        self.context[user_id] = {
            'last_intent': intent_result['intent'],
            'entities': entities,
            'timestamp': datetime.now()
        }

        # Route to appropriate handler
        if intent_result['confidence'] > 0.85:
            handler = self.intents.get(intent_result['intent'])
            if handler:
                return handler(user_message, entities)

        # Fallback to LLM for complex queries
        return self.llm_fallback(user_message)

    def handle_product_inquiry(self, message, entities):
        """Handle product-related questions"""
        product_name = entities.get('products', [''])[0]

        # Query product database
        product_info = self.get_product_info(product_name)

        if product_info:
            return f"Great choice! {product_info['name']} features " \
                   f"{product_info['description']}. The price is " \
                   f"${product_info['price']}. Would you like to proceed?"

        return "I couldn't find that product. Could you specify the name?"

    def llm_fallback(self, message):
        """Use LLM for complex queries with context"""
        response = conversation.predict(input=message)
        return response

    def escalate_to_human(self, message, entities):
        """Transfer to human agent with context"""
        context_summary = self.summarize_context()
        notify_agent(context_summary)
        return "I'm connecting you with a human agent who can better " \
               "assist you. They'll have the full context of our conversation."

# Example usage
bot = ChatbotEngine()
response = bot.handle_message("What's the status of my order #12345?", user_id="user_123")