LLM Security & Guardrails

# Install: pip install llm-guard openai
from llm_guard.input_scanners import Anonymize
from llm_guard.input_scanners.anonymize_helpers import BERT_LARGE_NER_CONF
from llm_guard.output_scanners import Deanonymize
from llm_guard.vault import Vault
from openai import OpenAI

vault = Vault()
client = OpenAI(api_key="<your_openai_api_key>")

def anonymize(prompt: str):
    scanner = Anonymize(vault, recognizer_conf=BERT_LARGE_NER_CONF, language="en")
    sanitized_prompt, is_valid, risk_score = scanner.scan(prompt)
    return sanitized_prompt

def deanonymize(sanitized_prompt: str, answer: str):
    scanner = Deanonymize(vault)
    restored_output, is_valid, risk_score = scanner.scan(sanitized_prompt, answer)
    return restored_output

def safe_chat(user_prompt: str):
    # 1. Redact PII from user input
    sanitized = anonymize(user_prompt)

    # 2. Call the model with sanitized input
    response = client.chat.completions.create(
        model="gpt-4",
        messages=[{"role": "user", "content": sanitized}],
    )
    raw_answer = response.choices[0].message.content

    # 3. Restore PII in the output
    final_answer = deanonymize(sanitized, raw_answer)
    return final_answer

// Install: npm install llm-guard openai
// Note: LLM Guard is Python-native. For TypeScript, use Lakera or Azure AI Content Safety.
// This example shows the equivalent pattern using a generic scanner interface.
import OpenAI from "openai";

const client = new OpenAI({ apiKey: "<your_openai_api_key>" });

async function safeChat(userPrompt: string) {
  // 1. Scan/redact PII from user input (use your chosen library)
  const sanitized = await scanAndRedactPII(userPrompt);

  // 2. Call the model with sanitized input
  const response = await client.chat.completions.create({
    model: "gpt-4",
    messages: [{ role: "user", content: sanitized }],
  });
  const rawAnswer = response.choices[0].message.content;

  // 3. Restore PII in the output
  const finalAnswer = await restorePII(sanitized, rawAnswer);
  return finalAnswer;
}

from llm_guard.input_scanners import PromptInjection

scanner = PromptInjection()

def check_injection(prompt: str):
    sanitized_prompt, is_valid, risk_score = scanner.scan(prompt)
    if not is_valid:
        raise ValueError(f"Prompt injection detected (risk: {risk_score})")
    return sanitized_prompt

// Using Lakera Guard API as an example
async function checkInjection(prompt: string): Promise<string> {
  const response = await fetch("https://api.lakera.ai/v1/prompt_injection", {
    method: "POST",
    headers: {
      Authorization: "Bearer <your_lakera_api_key>",
      "Content-Type": "application/json",
    },
    body: JSON.stringify({ input: prompt }),
  });
  const result = await response.json();

  if (result.flagged) {
    throw new Error(`Prompt injection detected (score: ${result.score})`);
  }
  return prompt;
}

export NETRA_OTLP_ENDPOINT="https://api.getnetra.ai/telemetry"
export NETRA_API_KEY="your-api-key-here"

export NETRA_OTLP_ENDPOINT="https://api.eu.getnetra.ai/telemetry"
export NETRA_API_KEY="your-api-key-here"

from netra import Netra

# Initialize before importing other libraries for best results
Netra.init(app_name="my-ai-app", environment="production")

import { Netra } from "netra-sdk";

// Initialize before importing other libraries for best results
await Netra.init({
  appName: "my-ai-app",
  environment: "production",
});