The 85% AI Deployment Failure Crisis: Senior Engineers Reveal 7 JavaScript Fixes That Slash $50K Monthly Waste

import { cosineSimilarity, tokenCount } from './nlp-utils.js';

/**
 * Prune RAG context by multi-factor relevance.
 * Returns subset that fits the target token budget.
 */
export function pruneContext(query, chunks, maxTokens = 4096) {
  // Score each chunk: semantic + lexical match.
  const scored = chunks.map(chunk => {
    const semantic = cosineSimilarity(query, chunk);
    // Simple lexical overlap bonus
    const lexical = query.split(' ').reduce((acc, word) => acc + (chunk.includes(word) ? 1 : 0), 0);
    const combined = semantic * 0.6 + lexical * 0.4;
    return { chunk, combined, tokens: tokenCount(chunk) };
  })
  .sort((a, b) => b.combined - a.combined);

  // Greedy select until hitting maxTokens
  const selected = [];
  let tokenTotal = 0;
  for (const { chunk, tokens } of scored) {
    if (tokenTotal + tokens > maxTokens) break;
    selected.push(chunk);
    tokenTotal += tokens;
  }
  return selected;
} 

import { PineconeClient } from '@pinecone-database/pinecone';
import postgres from 'postgres';
import { openai } from './openai-wrapper.js';
import { classifyQuery } from './nl-classifier.js';

const pinecone = new PineconeClient(/* ...creds... */);
const sql = postgres();

export async function hybridRAG(query) {
  const qType = classifyQuery(query); // 'AGGREGATION', 'SEMANTIC', 'HYBRID'

  if (qType === 'AGGREGATION') {
    // AI model translates query to SQL
    const sqlText = await openai.translateToSQL(query, await sql.schemas());
    const rows = await sql.unsafe(sqlText);
    return openai.summarizeRows(query, rows);
  }

  if (qType === 'SEMANTIC') {
    const vectors = await pinecone.query({ text: query, topK: 12 });
    return openai.answerWithContext(query, vectors.matches);
  }

  // HYBRID: Combine SQL and semantic context
  const [vectors, sqlText] = await Promise.all([
    pinecone.query({ text: query, topK: 8 }),
    openai.translateToSQL(query, await sql.schemas())
  ]);
  const rows = await sql.unsafe(sqlText);
  return openai.answerWithContext(query, [
    ...vectors.matches.map(m => m.metadata.text),
    JSON.stringify(rows),
  ]);
} 

import escapeStringRegexp from 'escape-string-regexp';
const CANARY = `CANARY_${crypto.randomUUID()}`;
const RAW_PATTERNS = [
  /ignore\s+previous\s+instructions/i,
  /system\s*:\s*you\s+are/i,
  /forget\s+everything\s+above/i,
  /act\s+as\s+if\s+you\s+are/i,
  /<script>|<iframe>|base64\s+decode/i
];

export function promptShield(req, res, next) {
  const input = req.body.prompt || '';
  // Quick block known pattern attacks
  if (RAW_PATTERNS.some(rx => rx.test(input))) return res.status(400).send('Rejected by prompt shield');
  // Block massive or suspicious payloads
  if (input.length > 2000) return res.status(413).send('Prompt too long');

  // Embed canary token
  req.body.prompt = `${CANARY}\n${input}`;
  // Intercept responses to detect canary leaks (server-side)
  res.on('finish', () => {
    if (res.body && res.body.includes(CANARY)) {
      // Alert/SIEM pipeline here
      console.error('CANARY LEAK - possible prompt injection:', req.ip);
    }
  });
  next();
}

// Usage in Express:
app.post('/generate', promptShield, async (req, res) => {
  // ...call LLM, return result...
}); 

import { OpenAI } from 'openai';
import { performance } from 'perf_hooks';

class ProductionAIMonitor {
  constructor(config) {
    this.openai = new OpenAI({ apiKey: config.openaiKey });
  }

  async monitorQuery(query, expected = null) {
    const start = performance.now();
    const response = await this.openai.chat.completions.create({
      model: "gpt-4",
      messages: [{ role: "user", content: query }],
      max_tokens: 180
    });

    const end = performance.now();
    const latency = end - start;
    const tokenUsage = response.usage?.total_tokens ?? 0;

    // Check thresholds
    if (latency > 5000) this.alert('PERFORMANCE', `Latency high: ${latency}ms`);
    if (tokenUsage > 3500) this.alert('COST', `Usage high: ${tokenUsage} tokens`);

    // Optional: Evaluate result accuracy, auto-alert on drop
    let accuracy = 1.0;
    if (expected) accuracy = this.compareOut(response.choices[0].message.content, expected);

    return {
      response: response.choices[0].message.content,
      latency,
      tokenUsage,
      accuracy
    };
  }

  alert(type, msg) {
    console.warn(`[${type} ALERT]:`, msg);
    // Integrate with Slack/webhook as needed
  }
} 

import { OpenAI } from 'openai';

const gpt35 = new OpenAI({ model: "gpt-3.5-turbo" });
const gpt4o = new OpenAI({ model: "gpt-4o-mini" });

export async function smartAnswer(query) {
  // Route simple queries to cheaper model
  const tokens = query.split(' ').length;
  const client = tokens < 18 ? gpt35 : gpt4o;
  const { choices: [{ message: { content } }] } =
    await client.chat.completions.create({ messages: [{ role: "user", content: query }] });
  return content;
} 

import { measureBLEU, measureROUGE } from './nl-metrics.js';

class DriftWatcher {
  constructor(baseline) { this.baseline = baseline; }
  analyse(samples) {
    const bleu = measureBLEU(samples), rouge = measureROUGE(samples);
    const bleuDrop = bleu - this.baseline.bleu;
    if (bleuDrop < -0.05) this.triggerAlert('BLEU drift', bleuDrop);
    return { bleuDrop, rouge };
  }
  triggerAlert(msg, val) { console.error(`[DRIFT] ${msg}: ${val}`); }
} 

import { gauge } from '@opentelemetry/api-metrics';
import { DriftWatcher } from './drift.js';

const drift = new DriftWatcher({ bleu: 0.31 });
const spendGauge = gauge('ai_spend_usd');
const driftGauge = gauge('model_drift_bleu_delta');

export async function updateDashboard(metrics) {
  driftGauge.update(metrics.bleuDrop);
  spendGauge.update(metrics.cost);
  // Add more if desired...
}