Customer: "I ordered a week ago and it hasn't arrived"

Keyword bot: ❌ No match for "ordered" (expects "order status")

Regex bot: ❌ Pattern doesn't capture "hasn't arrived"

Rule bot: ❌ Goes to "order status" but can't handle "missing" context

Layer 1: Input Preprocessing

         ↓

Layer 2: Intent Recognition (LLM + Human Rules)

         ↓

Layer 3: Context Management (Conversation History)

         ↓

     Bot Generates Response

import DOMPurify from 'dompurify';



const preprocessInput = (rawInput: string) => {

  // 1. Remove HTML tags (prevent XSS)

  const sanitized = DOMPurify.sanitize(rawInput);



  // 2. Trim whitespace

  const trimmed = sanitized.trim();



  // 3. Check for empty input

  if (!trimmed) {

    throw new Error('Empty message');

  }



  // 4. Limit length (prevent token abuse)

  if (trimmed.length > 2000) {

    return trimmed.substring(0, 2000) + '...';

  }



  return trimmed;

};

import { detectPII } from '../utils/piiDetector';



const checkForPII = (message: string) => {

  const piiDetected = detectPII(message);



  if (piiDetected.hasEmail || piiDetected.hasPhone) {

    // Log for audit (don't send PII to OpenAI)

    auditLog('pii_detected', {

      conversationId,

      types: piiDetected

    });



    // Mask PII before sending to LLM

    return maskPII(message);

  }



  return message;

};



// Example mask:

// Input: "My email is [email protected] and phone is 555-1234"

// Output: "My email is [EMAIL_MASKED] and phone is [PHONE_MASKED]"

export interface Intent {

  id: string;

  name: string;

  description: string;

  keywords: string[]; // Fallback for simple matching

  examples: string[]; // Training examples for LLM

  botType: 'support' | 'sales' | 'feedback' | 'knowledge';

  confidenceThreshold: number;

}



const intents: Intent[] = [

  {

    id: 'order_status',

    name: 'Order Status Inquiry',

    description: 'Customer wants to check the status of their order',

    keywords: ['order', 'status', 'shipping', 'tracking', 'where'],

    examples: [

      "Where's my order?",

      "I ordered last week, has it shipped?",

      "Can you track my package?",

      "Order #12345 status please"

    ],

    botType: 'support',

    confidenceThreshold: 70

  },

  {

    id: 'return_request',

    name: 'Return Request',

    description: 'Customer wants to return an item',

    keywords: ['return', 'refund', 'send back', 'defective'],

    examples: [

      "I want to return this laptop",

      "How do I get a refund?",

      "The product is defective, I need to send it back"

    ],

    botType: 'support',

    confidenceThreshold: 75

  },

  // ... more intents

];

import OpenAI from 'openai';



const detectIntent = async (message: string, conversationHistory: Message[]) => {

  const prompt = `You are an intent recognition system for a customer service chatbot.



AVAILABLE INTENTS:

${intents.map(i => `- ${i.id}: ${i.description}`).join('\n')}



CONVERSATION HISTORY:

${conversationHistory.map(m => `${m.role}: ${m.content}`).join('\n')}



CURRENT MESSAGE:

${message}



TASK:

Return a JSON object with:

- "intent": The most likely intent ID from the list above

- "confidence": A number between 0 and 1 representing your confidence

- "reasoning": Brief explanation of why you chose this intent



Only return the JSON object, nothing else.`;



  const completion = await openai.chat.completions.create({

    model: 'gpt-4o-mini',

    messages: [{ role: 'user', content: prompt }],

    temperature: 0.3, // Low temperature for consistent classification

    max_tokens: 150,

    response_format: { type: 'json_object' }

  });



  const result = JSON.parse(completion.choices[0].message.content || '{}');



  return {

    intent: result.intent,

    confidence: result.confidence,

    reasoning: result.reasoning

  };

};

User: "I ordered a laptop last week."

Bot: "I can help with that! Can you provide your order number?"

User: "It was the MacBook Pro."

Bot: ✅ Understands "It" refers to the laptop order

interface ConversationContext {

  conversationId: string;

  messages: Message[]; // Last 10 messages

  entities: {

    orderNumbers: string[];

    productNames: string[];

    customerIntent: string;

  };

  sentiment: 'positive' | 'neutral' | 'negative';

}



const buildContext = async (conversationId: string): Promise<ConversationContext> => {

  // Get last 10 messages

  const messages = await prisma.message.findMany({

    where: { conversationId },

    orderBy: { createdAt: 'desc' },

    take: 10

  });



  // Extract entities (order numbers, product names, etc.)

  const entities = extractEntities(messages);



  // Analyze sentiment

  const sentiment = await analyzeSentiment(messages);



  return {

    conversationId,

    messages: messages.reverse(), // Chronological order

    entities,

    sentiment

  };

};



// Example entity extraction:

// Input: "My order #12345 for MacBook Pro hasn't arrived"

// Output: { orderNumbers: ['#12345'], productNames: ['MacBook Pro'] }

const processMessage = async (message: string, conversationId: string) => {

  // 1. Build context

  const context = await buildContext(conversationId);



  // 2. Detect intent with context

  const { intent, confidence } = await detectIntent(message, context.messages);



  // 3. Route to appropriate bot with context

  const bot = getBotForIntent(intent);



  // 4. Generate response with FULL context

  const response = await bot.generateResponse({

    message,

    context,

    intent,

    confidence

  });



  // 5. Update context with new message

  await updateContext(conversationId, message, response);



  return response;

};

const generateResponse = async (message: string, sentiment: string) => {

  const systemPrompt = `You are a customer service bot.



SENTIMENT DETECTED: ${sentiment}



ADJUST YOUR TONE:

- If NEGATIVE: Be extra empathetic, offer solutions quickly, escalate if needed

- If NEUTRAL: Be professional and helpful

- If POSITIVE: Be warm and appreciative`;



  // ... LLM call with sentiment-aware prompt

};

const personalizeResponse = (response: string, entities: Entities) => {

  let personalized = response;



  // Replace generic references with specific entities

  if (entities.productNames.length > 0) {

    personalized = personalized.replace(

      /that product/gi,

      entities.productNames[0]

    );

  }



  return personalized;

};

User: "I want to buy a laptop." → Intent: sales_inquiry

Bot: "Great! What's your budget?"

User: "Actually, I need help with my current laptop." → Intent: support_request

const trackIntentShift = (

  oldIntent: string,

  newIntent: string,

  confidence: number

) => {

  if (oldIntent !== newIntent && confidence > 0.8) {

    auditLog('intent_shift', {

      from: oldIntent,

      to: newIntent,

      confidence

    });

  }

};

Intent Distribution (Last 7 Days):

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

order_status:     ████████████ 35% (1,250 conversations)

return_request:   ████████ 20% (714)

sales_inquiry:     ██████ 15% (535)

faq_general:       █████ 12% (429)

escalated:         ███ 10% (357)

unknown:           █ 8% (286)



Confidence Distribution:

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

90-100%: ████████████ 60% (High confidence)

70-89%:  ██████ 25% (Medium confidence)

<70%:    █ 15% (Escalated to human)

git clone https://github.com/ayw-ai/ayw-monorepo.git

cd ayw-monorepo

npm install

import { NLUService } from './services/nluService';



const nlu = new NLUService();



const result = await nlu.processMessage({

  message: "I ordered a week ago and it hasn't arrived",

  conversationHistory: [],

  customerId: 'cust_123'

});



console.log(result);

// {

//   intent: 'order_status',

//   confidence: 0.92,

//   entities: { orderNumbers: [], productNames: [] },

//   sentiment: 'negative',

//   routing: 'support_bot'

// }