Groq Data Handling

Overview

Manage data flowing through Groq's ultra-fast LPU inference. Covers prompt sanitization, response filtering, conversation logging with PII redaction, and token usage tracking for cost management.

Prerequisites

• Groq API key
• groq-sdk npm package
• Understanding of LLM data flow (prompts in, completions out)
• Logging infrastructure for audit

Instructions

Step 1: Prompt Sanitization Layer

import Groq from 'groq-sdk';

const groq = new Groq({ apiKey: process.env.GROQ_API_KEY });

const PII_REDACTORS = [
  { pattern: /\b[\w.+-]+@[\w-]+\.[\w.]+\b/g, replace: '[EMAIL]' },
  { pattern: /\b\d{3}[-.]?\d{3}[-.]?\d{4}\b/g, replace: '[PHONE]' },
  { pattern: /\b\d{3}-\d{2}-\d{4}\b/g, replace: '[SSN]' },
];

function sanitizePrompt(text: string): { text: string; hadPII: boolean } {
  let hadPII = false;
  let sanitized = text;

  for (const { pattern, replace } of PII_REDACTORS) {
    if (pattern.test(sanitized)) hadPII = true;
    sanitized = sanitized.replace(pattern, replace);
  }

  return { text: sanitized, hadPII };
}

async function safeChatCompletion(messages: any[], model = 'llama-3.1-8b-instant') {
  const sanitizedMessages = messages.map(m => ({
    ...m,
    content: sanitizePrompt(m.content).text,
  }));

  return groq.chat.completions.create({ model, messages: sanitizedMessages });
}

Step 2: Response Content Filtering

interface FilterResult {
  content: string;
  filtered: boolean;
  reasons: string[];
}

function filterResponse(content: string): FilterResult {
  const reasons: string[] = [];

  // Check for leaked PII patterns in response
  for (const { pattern, replace } of PII_REDACTORS) {
    if (pattern.test(content)) {
      reasons.push(`Response contained ${replace} pattern`);
      content = content.replace(pattern, replace);
    }
  }

  // Check for code injection patterns
  if (/<script|javascript:|onclick=/i.test(content)) {
    reasons.push('Response contained script injection');
    content = content.replace(/<script[\s\S]*?<\/script>/gi, '[REMOVED]');
  }

  return { content, filtered: reasons.length > 0, reasons };
}

async function safeCompletion(messages: any[]) {
  const result = await safeChatCompletion(messages);
  const raw = result.choices[0].message.content || '';
  const filtered = filterResponse(raw);

  if (filtered.filtered) {
    console.warn('Response filtered:', filtered.reasons);
  }

  return { ...result, choices: [{ ...result.choices[0], message: { ...result.choices[0].message, content: filtered.content } }] };
}

Step 3: Token Usage Tracking

interface UsageRecord {
  timestamp: string;
  model: string;
  promptTokens: number;
  completionTokens: number;
  totalTokens: number;
  estimatedCost: number;
}

const COST_PER_MILLION: Record<string, { input: number; output: number }> = {
  'llama-3.1-8b-instant': { input: 0.05, output: 0.08 },
  'llama-3.3-70b-versatile': { input: 0.59, output: 0.79 },
  'mixtral-8x7b-32768': { input: 0.24, output: 0.24 },  # 32768 = configured value
};

function trackUsage(model: string, usage: any): UsageRecord {
  const costs = COST_PER_MILLION[model] || { input: 0.50, output: 0.50 };

  return {
    timestamp: new Date().toISOString(),
    model,
    promptTokens: usage.prompt_tokens,
    completionTokens: usage.completion_tokens,
    totalTokens: usage.total_tokens,
    estimatedCost:
      (usage.prompt_tokens / 1_000_000) * costs.input +
      (usage.completion_tokens / 1_000_000) * costs.output,
  };
}

Step 4: Conversation Logging with Redaction

interface AuditLog {
  sessionId: string;
  timestamp: string;
  model: string;
  promptRedacted: string;
  responseRedacted: string;
  tokenUsage: UsageRecord;
}

async function loggedCompletion(
  sessionId: string,
  messages: any[],
  model = 'llama-3.1-8b-instant'
): Promise<{ response: string; log: AuditLog }> {
  const sanitized = messages.map(m => ({
    ...m,
    content: sanitizePrompt(m.content).text,
  }));

  const result = await groq.chat.completions.create({ model, messages: sanitized });
  const response = filterResponse(result.choices[0].message.content || '');
  const usage = trackUsage(model, result.usage);

  const log: AuditLog = {
    sessionId,
    timestamp: new Date().toISOString(),
    model,
    promptRedacted: sanitized.map(m => m.content).join(' | '),
    responseRedacted: response.content,
    tokenUsage: usage,
  };

  return { response: response.content, log };
}

Error Handling

Examples

Daily Cost Report

function dailyCostReport(logs: AuditLog[]) {
  const totalCost = logs.reduce((s, l) => s + l.tokenUsage.estimatedCost, 0);
  const byModel = logs.reduce((acc, l) => {
    acc[l.tokenUsage.model] = (acc[l.tokenUsage.model] || 0) + l.tokenUsage.estimatedCost;
    return acc;
  }, {} as Record<string, number>);

  return { totalCost: totalCost.toFixed(4), byModel };
}

Resources

• Groq Privacy Policy
• Groq Pricing

Output

• Configuration files or code changes applied to the project
• Validation report confirming correct implementation
• Summary of changes made and their rationale