AI/ML in Business Applications 2025

// Node.js example - OpenAI SDK
import OpenAI from 'openai';

const openai = new OpenAI({
  apiKey: process.env.OPENAI_API_KEY,
});

const completion = await openai.chat.completions.create({
  model: "gpt-4-turbo-preview",
  messages: [
    { role: "system", content: "You are a helpful assistant." },
    { role: "user", content: "Summarize quarterly sales data" }
  ],
  temperature: 0.7,
  max_tokens: 1000,
});

console.log(completion.choices[0].message.content);

// Azure OpenAI SDK with Managed Identity
import { OpenAIClient, AzureKeyCredential } from "@azure/openai";
import { DefaultAzureCredential } from "@azure/identity";

// Uses Managed Identity - no API keys in code
const credential = new DefaultAzureCredential();
const endpoint = "https://your-resource.openai.azure.com/";

const client = new OpenAIClient(endpoint, credential);

const result = await client.getChatCompletions(
  "gpt-4-deployment",  // Your deployment name
  [
    { role: "system", content: "You are a business analyst." },
    { role: "user", content: "Analyze Q4 revenue trends" }
  ],
  {
    temperature: 0.7,
    maxTokens: 1500,
    // Azure-specific: content filtering
    azureExtensionOptions: {
      contentFiltering: {
        categories: ["hate", "sexual", "violence", "self-harm"],
        severityLevel: "medium"
      }
    }
  }
);

console.log(result.choices[0].message.content);

// Streaming with Azure OpenAI
const stream = await client.streamChatCompletions(
  "gpt-4-deployment",
  messages,
  { maxTokens: 1000 }
);

for await (const chunk of stream) {
  const delta = chunk.choices[0]?.delta?.content;
  if (delta) {
    process.stdout.write(delta);  // Stream to user in real-time
  }
}

const functions = [
  {
    name: "get_customer_data",
    description: "Retrieve customer information from CRM",
    parameters: {
      type: "object",
      properties: {
        customer_id: { type: "string", description: "Customer ID" },
        fields: {
          type: "array",
          items: { type: "string" },
          description: "Fields to retrieve"
        }
      },
      required: ["customer_id"]
    }
  }
];

const response = await client.getChatCompletions(
  "gpt-4-deployment",
  [{ role: "user", content: "Get email for customer C123" }],
  { functions, functionCall: "auto" }
);

const functionCall = response.choices[0].message.functionCall;
if (functionCall?.name === "get_customer_data") {
  const args = JSON.parse(functionCall.arguments);
  const data = await fetchCustomerData(args.customer_id, args.fields);
  // Send result back to LLM for natural language response
}

import { OpenAI } from 'openai';
import { PineconeClient } from '@pinecone-database/pinecone';

const openai = new OpenAI();
const pinecone = new PineconeClient();

async function embedDocument(text: string, metadata: any) {
  // 1. Split into chunks (500 tokens each)
  const chunks = splitIntoChunks(text, 500);

  // 2. Generate embeddings
  const embeddings = await openai.embeddings.create({
    model: "text-embedding-3-small",
    input: chunks,
  });

  // 3. Store in Pinecone
  const index = pinecone.Index("knowledge-base");
  const vectors = embeddings.data.map((emb, i) => ({
    id: `doc-${Date.now()}-${i}`,
    values: emb.embedding,
    metadata: {
      text: chunks[i],
      ...metadata,
      chunk_index: i
    }
  }));

  await index.upsert(vectors);
}

// Embed company knowledge base
await embedDocument(
  "Q4 2024 revenue increased 34% YoY to $2.3B...",
  { source: "Q4-2024-earnings.pdf", type: "financial" }
);

async function ragQuery(userQuery: string) {
  // 1. Embed user query
  const queryEmbedding = await openai.embeddings.create({
    model: "text-embedding-3-small",
    input: userQuery,
  });

  // 2. Semantic search in Pinecone
  const index = pinecone.Index("knowledge-base");
  const results = await index.query({
    vector: queryEmbedding.data[0].embedding,
    topK: 5,  // Top 5 most relevant chunks
    includeMetadata: true,
  });

  // 3. Build context from retrieved chunks
  const context = results.matches
    .map(match => match.metadata.text)
    .join("\n\n");

  // 4. Query LLM with context
  const completion = await openai.chat.completions.create({
    model: "gpt-4-turbo-preview",
    messages: [
      {
        role: "system",
        content: "Answer based on the provided context only. If context doesn't contain the answer, say 'I don't have that information.'"
      },
      {
        role: "user",
        content: `Context:\n${context}\n\nQuestion: ${userQuery}`
      }
    ],
  });

  return {
    answer: completion.choices[0].message.content,
    sources: results.matches.map(m => m.metadata.source),
  };
}

const result = await ragQuery("What was Q4 revenue?");
console.log(result.answer);  // "Q4 2024 revenue was $2.3B..."
console.log(result.sources);  // ["Q4-2024-earnings.pdf"]

// PII Detection & Sanitization
import { PresidioAnalyzer, PresidioAnonymizer } from 'presidio-js';

async function sanitizeInput(userInput: string) {
  const analyzer = new PresidioAnalyzer();
  const anonymizer = new PresidioAnonymizer();

  // Detect PII entities
  const results = await analyzer.analyze(userInput, ['en']);

  // Replace with placeholders
  const sanitized = await anonymizer.anonymize(
    userInput,
    results,
    { operators: { DEFAULT: { type: "replace", new_value: "[REDACTED]" } } }
  );

  return sanitized.text;
}

// Azure OpenAI with Private Endpoint
const client = new OpenAIClient(
  "https://your-resource.privatelink.openai.azure.com/",
  new DefaultAzureCredential()
);

// Input validation & sanitization
function validateInput(userInput: string): boolean {
  // Prevent prompt injection attacks
  const dangerousPatterns = [
    /ignore (previous|above) instructions/i,
    /system prompt/i,
    /you are now/i,
  ];

  if (dangerousPatterns.some(pattern => pattern.test(userInput))) {
    throw new Error("Invalid input detected");
  }

  // Length limits
  if (userInput.length > 10000) {
    throw new Error("Input too long");
  }

  return true;
}

// Azure content filtering
const result = await client.getChatCompletions(
  "gpt-4-deployment",
  messages,
  {
    azureExtensionOptions: {
      contentFiltering: {
        categories: ["hate", "sexual", "violence", "self-harm"],
        severityLevel: "medium",
        blockOnDetection: true
      }
    }
  }
);

// Application Insights logging
import { ApplicationInsights } from '@azure/monitor-opentelemetry';

const appInsights = new ApplicationInsights({
  connectionString: process.env.APPINSIGHTS_CONNECTION_STRING
});

async function loggedAICall(userId: string, query: string) {
  const startTime = Date.now();

  try {
    const result = await client.getChatCompletions(...);

    // Log successful call
    appInsights.trackEvent({
      name: "AI_Call_Success",
      properties: {
        userId,
        model: "gpt-4",
        inputTokens: result.usage.promptTokens,
        outputTokens: result.usage.completionTokens,
        cost: calculateCost(result.usage),
        latency: Date.now() - startTime,
        // DO NOT log actual query/response (PII risk)
      }
    });

    return result;
  } catch (error) {
    appInsights.trackException({ exception: error });
    throw error;
  }
}

// Redis-based rate limiting
import { RateLimiterRedis } from 'rate-limiter-flexible';

const rateLimiter = new RateLimiterRedis({
  storeClient: redisClient,
  keyPrefix: 'ai_rate_limit',
  points: 50,  // 50 requests
  duration: 86400,  // per day
  blockDuration: 3600,  // block for 1 hour if exceeded
});

async function checkRateLimit(userId: string) {
  try {
    await rateLimiter.consume(userId);
  } catch (error) {
    throw new Error("Rate limit exceeded. Try again later.");
  }
}

// Usage tracking for billing
async function trackUsage(userId: string, cost: number) {
  await db.usage.create({
    userId,
    timestamp: new Date(),
    cost,
    model: "gpt-4",
  });

  // Alert if user exceeds budget
  const monthlyUsage = await getMonthlyUsage(userId);
  if (monthlyUsage > USER_BUDGET_LIMIT) {
    await sendAlert(userId, monthlyUsage);
  }
}