System Architecture

import express from 'express';
import cors from 'cors';
import { createServer } from 'http';
import { Server } from 'socket.io';
import apiRoutes from './backend/api/routes.js';
import { setIO } from './backend/whatsapp/queue.js';

const app = express();
const httpServer = createServer(app);
const io = new Server(httpServer, {
  cors: {
    origin: "*",
    methods: ["GET", "POST", "PATCH"]
  }
});

// Share IO instance with routes and queue workers
app.set('io', io);
setIO(io);

const PORT = 3001;
app.use(cors());
app.use(express.json());

// API Routes
app.use('/api', apiRoutes);

httpServer.listen(PORT, () => {
  console.log(`🚀 Server running on http://localhost:${PORT}`);
});

import { Queue, Worker } from 'bullmq';
import IORedis from 'ioredis';
import { generateSupportResponse } from '../services/ai/Retriever.js';

const queueConnection = new IORedis({
  host: process.env.REDIS_HOST || 'localhost',
  port: process.env.REDIS_PORT || 6379,
  password: process.env.REDIS_PASSWORD,
  maxRetriesPerRequest: null
});

export const whatsappQueue = new Queue('whatsapp-ai', { 
  connection: queueConnection 
});

export const worker = new Worker('whatsapp-ai', async job => {
  const { wamid, from, text } = job.data;
  
  // Process message with AI
  const aiResponse = await generateSupportResponse(text, history);
  
  // Send reply via WhatsApp API
  await axios.post(
    `https://graph.facebook.com/v21.0/${process.env.WHATSAPP_PHONE_ID}/messages`,
    { messaging_product: "whatsapp", to: from, text: { body: aiResponse.text } },
    { headers: { 'Authorization': `Bearer ${process.env.WHATSAPP_ACCESS_TOKEN}` } }
  );
}, { 
  connection: queueConnection,
  limiter: { max: 10, duration: 1000 },
  settings: { backoffStrategy: 'exponential' }
});

import { ChatAnthropic } from "@langchain/anthropic";
import { HumanMessage, SystemMessage, ToolMessage, AIMessage } from "@langchain/core/messages";

const chatModel = new ChatAnthropic({
  modelName: "claude-3-haiku-20240307",
  temperature: 0.1,
  anthropicApiKey: process.env.ANTHROPIC_API_KEY,
});

const tools = [
  {
    name: "searchInventory",
    description: "Search product catalog for prices, availability, and variants",
    input_schema: {
      type: "object",
      properties: {
        query: { type: "string", description: "Product name or variant to search" }
      },
      required: ["query"]
    }
  },
  {
    name: "searchKnowledgeBase",
    description: "Search company policies, shipping times, and FAQs",
    input_schema: {
      type: "object",
      properties: {
        query: { type: "string", description: "Policy or information to search" }
      },
      required: ["query"]
    }
  }
];

export async function generateSupportResponse(userQuestion, chatHistory = []) {
  const recentHistory = chatHistory.slice(-4);
  const messages = [
    new SystemMessage(AGENT_PROMPT),
    ...recentHistory.map(m => m.role === 'user' ? new HumanMessage(m.content) : new AIMessage(m.content)),
    new HumanMessage(userQuestion)
  ];
  
  const modelWithTools = chatModel.bindTools(tools);
  let aiMessage = await modelWithTools.invoke(messages);
  
  // Process tool calls
  if (aiMessage.tool_calls && aiMessage.tool_calls.length > 0) {
    messages.push(aiMessage);
    
    for (const toolCall of aiMessage.tool_calls) {
      let result;
      if (toolCall.name === "searchInventory") {
        result = await executeSearchInventory(toolCall.args.query);
      } else if (toolCall.name === "searchKnowledgeBase") {
        result = await executeSearchKnowledgeBase(toolCall.args.query);
      }
      
      messages.push(new ToolMessage({
        tool_call_id: toolCall.id,
        content: result,
        name: toolCall.name
      }));
    }
    
    // Generate final response with tool results
    aiMessage = await modelWithTools.invoke(messages);
  }
  
  return { text: aiMessage.content + "\n\n_🤖 Asistente Virtual KAIU_" };
}

// Singleton pattern for expensive resources
let chatModel = null;

function getChatModel() {
  if (!chatModel) {
    chatModel = new ChatAnthropic({
      modelName: "claude-3-haiku-20240307",
      anthropicApiKey: process.env.ANTHROPIC_API_KEY,
    });
  }
  return chatModel;
}