refactor: Consolidate AI examples (#1356)

Author: YasharF

app.js

@@ -125,7 +125,7 @@ app.use(passport.initialize());
 app.use(passport.session());
 app.use(flash());
 app.use((req, res, next) => {
-  if (req.path === '/api/upload' || req.path === '/api/togetherai-camera') {
+  if (req.path === '/api/upload' || req.path === '/ai/togetherai-camera') {
     // Multer multipart/form-data handling needs to occur before the Lusca CSRF check.
     // WARN: Any path that is not protected by CSRF here should have lusca.csrf() chained
     // in their route handler.
@@ -237,12 +237,12 @@ app.get('/api/trakt', apiController.getTrakt);
  * AI Integrations and Boilerplate example routes.
  */
 app.get('/ai', aiController.getAi);
-app.get('/api/openai-moderation', apiController.getOpenAIModeration);
-app.post('/api/openai-moderation', apiController.postOpenAIModeration);
-app.get('/api/togetherai-classifier', apiController.getTogetherAIClassifier);
-app.post('/api/togetherai-classifier', apiController.postTogetherAIClassifier);
-app.get('/api/togetherai-camera', lusca({ csrf: true }), apiController.getTogetherAICamera);
-app.post('/api/togetherai-camera', strictLimiter, apiController.imageUploadMiddleware, lusca({ csrf: true }), apiController.postTogetherAICamera);
+app.get('/ai/openai-moderation', aiController.getOpenAIModeration);
+app.post('/ai/openai-moderation', aiController.postOpenAIModeration);
+app.get('/ai/togetherai-classifier', aiController.getTogetherAIClassifier);
+app.post('/ai/togetherai-classifier', aiController.postTogetherAIClassifier);
+app.get('/ai/togetherai-camera', lusca({ csrf: true }), aiController.getTogetherAICamera);
+app.post('/ai/togetherai-camera', strictLimiter, aiController.imageUploadMiddleware, lusca({ csrf: true }), aiController.postTogetherAICamera);
 app.get('/ai/rag', aiController.getRag);
 app.post('/ai/rag/ingest', aiController.postRagIngest);
 app.post('/ai/rag/ask', aiController.postRagAsk);

controllers/ai.js

@@ -1,6 +1,7 @@
+const crypto = require('crypto');
 const fs = require('fs');
+const multer = require('multer');
 const path = require('path');
-const crypto = require('crypto');
 const { PDFLoader } = require('@langchain/community/document_loaders/fs/pdf');
 const { RecursiveCharacterTextSplitter } = require('@langchain/textsplitters');
 const { HuggingFaceInferenceEmbeddings } = require('@langchain/community/embeddings/hf');
@@ -448,3 +449,296 @@ exports.postRagAsk = async (req, res) => {
     await client.close();
   }
 };
+
+/**
+ * GET /ai/openai-moderation
+ * OpenAI Moderation API example.
+ */
+exports.getOpenAIModeration = (req, res) => {
+  res.render('ai/openai-moderation', {
+    title: 'OpenAI Input Moderation',
+    result: null,
+    error: null,
+    input: '',
+  });
+};
+
+/**
+ * POST /ai/openai-moderation
+ * OpenAI Moderation API example.
+ */
+exports.postOpenAIModeration = async (req, res) => {
+  const openAiKey = process.env.OPENAI_API_KEY;
+  const inputText = req.body.inputText || '';
+  let result = null;
+  let error = null;
+
+  if (!openAiKey) {
+    error = 'OpenAI API key is not set in environment variables.';
+  } else if (!inputText.trim()) {
+    error = 'Text for input modaration check:';
+  } else {
+    try {
+      const response = await fetch('https://api.openai.com/v1/moderations', {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          Authorization: `Bearer ${openAiKey}`,
+        },
+        body: JSON.stringify({
+          model: 'text-moderation-latest',
+          input: inputText,
+        }),
+      });
+      if (!response.ok) {
+        const errData = await response.json().catch(() => ({}));
+        error = errData.error && errData.error.message ? errData.error.message : `API Error: ${response.status}`;
+      } else {
+        const data = await response.json();
+        result = data.results && data.results[0];
+      }
+    } catch (err) {
+      console.error('OpenAI Moderation API Error:', err);
+      error = 'Failed to call OpenAI Moderation API.';
+    }
+  }
+
+  res.render('ai/openai-moderation', {
+    title: 'OpenAI Moderation API',
+    result,
+    error,
+    input: inputText,
+  });
+};
+
+/**
+ * Helper functions and constants for Together AI API Example
+ * We are using LLMs to classify text or analyze a picture taken by the user's camera.
+ */
+
+// Shared Together AI API caller
+const callTogetherAiApi = async (apiRequestBody, apiKey) => {
+  const response = await fetch('https://api.together.xyz/v1/chat/completions', {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      Authorization: `Bearer ${apiKey}`,
+    },
+    body: JSON.stringify(apiRequestBody),
+  });
+  if (!response.ok) {
+    const errData = await response.json().catch(() => ({}));
+    console.error('Together AI API Error Response:', errData);
+    const errorMessage = errData.error && errData.error.message ? errData.error.message : `API Error: ${response.status}`;
+    throw new Error(errorMessage);
+  }
+  return response.json();
+};
+
+// Vision-specific functions
+const createVisionLLMRequestBody = (dataUrl, model) => ({
+  model,
+  messages: [
+    {
+      role: 'user',
+      content: [
+        {
+          type: 'text',
+          text: 'What is in this image?',
+        },
+        {
+          type: 'image_url',
+          image_url: {
+            url: dataUrl,
+          },
+        },
+      ],
+    },
+  ],
+});
+
+const extractVisionAnalysis = (data) => {
+  if (data.choices && Array.isArray(data.choices) && data.choices.length > 0 && data.choices[0].message && data.choices[0].message.content) {
+    return data.choices[0].message.content;
+  }
+  return 'No vision analysis available';
+};
+
+// Classifier-specific functions
+const createClassifierLLMRequestBody = (inputText, model, systemPrompt) => ({
+  model,
+  messages: [
+    { role: 'system', content: systemPrompt },
+    { role: 'user', content: inputText },
+  ],
+  temperature: 0,
+  max_tokens: 64,
+});
+
+const extractClassifierResponse = (content) => {
+  let department = null;
+  if (content) {
+    try {
+      // Try to extract JSON from the response
+      const jsonStringMatch = content.match(/{.*}/s);
+      if (jsonStringMatch) {
+        const parsed = JSON.parse(jsonStringMatch[0].replace(/'/g, '"'));
+        department = parsed.department;
+      }
+    } catch (err) {
+      console.log('Failed to parse JSON from TogetherAI API response:', err);
+      // fallback: try to extract department manually
+      const match = content.match(/"department"\s*:\s*"([^"]+)"/);
+      if (match) {
+        [, department] = match;
+      }
+    }
+  }
+  return department || 'Unknown';
+};
+
+// System prompt for the classifier
+// This is the system prompt that instructs the LLM on how to classify the customer message
+// into the appropriate department.
+const messageClassifierSystemPrompt = `You are a customer service classifier for an e-commerce platform. Your role is to identify the primary issue described by the customer and return the result in JSON format. Carefully analyze the customer's message and select one of the following departments as the classification result:
+
+Order Tracking and Status
+Returns and Refunds
+Payments and Billing Issues
+Account Management
+Product Inquiries
+Technical Support
+Shipping and Delivery Issues
+Promotions and Discounts
+Marketplace Seller Support
+Feedback and Complaints
+
+Provide the output in this JSON structure:
+
+{
+  "department": "<selected_department>"
+}
+Replace <selected_department> with the name of the most relevant department from the list above. If the inquiry spans multiple categories, choose the department that is most likely to address the customer's issue promptly and effectively.`;
+
+// Image Uploade middleware for Camera uploads
+const createImageUploader = () => {
+  const memoryStorage = multer.memoryStorage();
+  return multer({
+    storage: memoryStorage,
+    limits: { fileSize: 10 * 1024 * 1024 }, // 10MB limit
+  }).single('image');
+};
+
+exports.imageUploadMiddleware = (req, res, next) => {
+  const uploadToMemory = createImageUploader();
+  uploadToMemory(req, res, (err) => {
+    if (err) {
+      console.error('Upload error:', err);
+      return res.status(500).json({ error: err.message });
+    }
+    next();
+  });
+};
+
+const createImageDataUrl = (file) => {
+  const base64Image = file.buffer.toString('base64');
+  return `data:${file.mimetype};base64,${base64Image}`;
+};
+
+/**
+ * GET /ai/togetherai-camera
+ * Together AI Camera Analysis Example
+ */
+exports.getTogetherAICamera = (req, res) => {
+  res.render('ai/togetherai-camera', {
+    title: 'Together.ai Camera Analysis',
+    togetherAiModel: process.env.TOGETHERAI_VISION_MODEL,
+  });
+};
+
+/**
+ * POST /ai/togetherai-camera
+ * Analyze image using Together AI Vision
+ */
+exports.postTogetherAICamera = async (req, res) => {
+  if (!req.file) {
+    return res.status(400).json({ error: 'No image provided' });
+  }
+  try {
+    const togetherAiKey = process.env.TOGETHERAI_API_KEY;
+    const togetherAiModel = process.env.TOGETHERAI_VISION_MODEL;
+    if (!togetherAiKey) {
+      return res.status(500).json({ error: 'TogetherAI API key is not set' });
+    }
+    const dataUrl = createImageDataUrl(req.file);
+    const apiRequestBody = createVisionLLMRequestBody(dataUrl, togetherAiModel);
+    // console.log('Making Vision API request to Together AI...');
+    const data = await callTogetherAiApi(apiRequestBody, togetherAiKey);
+    const analysis = extractVisionAnalysis(data);
+    // console.log('Vision analysis completed:', analysis);
+    res.json({ analysis });
+  } catch (error) {
+    console.error('Error analyzing image:', error);
+    res.status(500).json({ error: `Error analyzing image: ${error.message}` });
+  }
+};
+
+/**
+ * GET /ai/togetherai-classifier
+ * Together AI / LLM API Example.
+ */
+exports.getTogetherAIClassifier = (req, res) => {
+  res.render('ai/togetherai-classifier', {
+    title: 'Together.ai/LLM Department Classifier',
+    result: null,
+    togetherAiModel: process.env.TOGETHERAI_MODEL,
+    error: null,
+    input: '',
+  });
+};
+
+/**
+ * POST /ai/togetherai-classifier
+ * Together AI API Example.
+ * - Classifies customer service inquiries into departments.
+ * - Uses Together AI API with a foundational LLM model to classify the input text.
+ * - The systemPrompt is the instructions from the developer to the model for processing
+ *   the user input.
+ */
+exports.postTogetherAIClassifier = async (req, res) => {
+  const togetherAiKey = process.env.TOGETHERAI_API_KEY;
+  const togetherAiModel = process.env.TOGETHERAI_MODEL;
+  const inputText = (req.body.inputText || '').slice(0, 300);
+  let result = null;
+  let error = null;
+  if (!togetherAiKey) {
+    error = 'TogetherAI API key is not set in environment variables.';
+  } else if (!togetherAiModel) {
+    error = 'TogetherAI model is not set in environment variables.';
+  } else if (!inputText.trim()) {
+    error = 'Please enter the customer message to classify.';
+  } else {
+    try {
+      const systemPrompt = messageClassifierSystemPrompt; // Your existing system prompt here
+      const apiRequestBody = createClassifierLLMRequestBody(inputText, togetherAiModel, systemPrompt);
+      const data = await callTogetherAiApi(apiRequestBody, togetherAiKey);
+      const content = data.choices && data.choices[0] && data.choices[0].message && data.choices[0].message.content;
+      const department = extractClassifierResponse(content);
+      result = {
+        department,
+        raw: content,
+        systemPrompt,
+      };
+    } catch (err) {
+      console.log('TogetherAI Classifier API Error:', err);
+      error = 'Failed to call TogetherAI API.';
+    }
+  }
+
+  res.render('ai/togetherai-classifier', {
+    title: 'TogetherAI Department Classifier',
+    result,
+    error,
+    input: inputText,
+  });
+};