Guides & Examples

// app/api/chat/route.ts
import { NextRequest, NextResponse } from 'next/server'
import { PromptShield } from '@prompt-shield/sdk'

const shield = new PromptShield({
  apiKey: process.env.PROMPTSHIELD_API_KEY!
})

export async function POST(request: NextRequest) {
  const { message } = await request.json()
  
  // Check for prompt injection
  const detection = await shield.detect(message)
  
  if (detection.isInjection) {
    return NextResponse.json(
      { 
        error: 'Potential security threat detected',
        confidence: detection.confidence,
        recommendation: detection.recommendation
      },
      { status: 400 }
    )
  }
  
  // Safe to process with your LLM
  const response = await processWithLLM(message)
  return NextResponse.json({ response })
}

from fastapi import FastAPI, HTTPException
from fastapi.responses import StreamingResponse
from prompt_shield import PromptShield
import asyncio

app = FastAPI()
shield = PromptShield(api_key="your-api-key")

@app.post("/chat/stream")
async def chat_stream(message: str):
    # Real-time detection
    detection = await shield.async_detect(message)
    
    if detection.is_injection:
        raise HTTPException(
            status_code=400,
            detail={
                "error": "Injection detected",
                "confidence": detection.confidence,
                "risk_level": detection.risk_level
            }
        )
    
    async def generate():
        # Stream LLM response with continuous monitoring
        async for chunk in llm_stream(message):
            # Check response chunks for leaks
            chunk_check = await shield.async_detect(chunk)
            if chunk_check.is_injection:
                yield "\n\n[Response blocked due to security concerns]"
                break
            yield chunk
    
    return StreamingResponse(generate(), media_type="text/plain")

from langchain.memory import ConversationBufferMemory
from langchain.chains import ConversationChain
from langchain.llms import OpenAI
from prompt_shield.integrations.langchain import (
    PromptShieldMemory,
    PromptShieldChain
)

# Protected memory that checks for injections
memory = PromptShieldMemory(
    shield=shield,
    base_memory=ConversationBufferMemory(),
    check_inputs=True,
    check_outputs=True
)

# Protected chain
chain = PromptShieldChain(
    llm=OpenAI(),
    memory=memory,
    shield=shield,
    verbose=True
)

# Both input and memory are protected
try:
    response = chain.run("What did I tell you earlier?")
except PromptInjectionError as e:
    print(f"Blocked: {e.detection_result}")

import { PromptShield } from '@prompt-shield/sdk'

const shield = new PromptShield({
  apiKey: process.env.PROMPTSHIELD_API_KEY,
  webhooks: {
    onHighRiskDetection: 'https://your-app.com/webhooks/high-risk',
    onPatternDetected: 'https://your-app.com/webhooks/patterns'
  }
})

// Subscribe to real-time events
shield.on('detection', (event) => {
  // Send to your analytics platform
  analytics.track('prompt_injection_attempt', {
    userId: event.context.userId,
    confidence: event.detection.confidence,
    riskLevel: event.detection.riskLevel,
    patterns: event.detection.patterns,
    timestamp: event.timestamp
  })
})

// Get aggregated statistics
const stats = await shield.getStatistics({
  timeRange: '24h',
  groupBy: 'pattern'
})

console.log('Top attack patterns:', stats.topPatterns)
console.log('Detection rate:', stats.detectionRate)
console.log('False positive rate:', stats.falsePositiveRate)

# prometheus.yml
global:
  scrape_interval: 15s

scrape_configs:
  - job_name: 'promptshield'
    static_configs:
      - targets: ['localhost:9090']
    metrics_path: '/metrics'
    params:
      api_key: ['your-api-key']

# Available metrics:
# promptshield_detections_total{result="blocked|allowed",risk="low|medium|high|critical"}
# promptshield_detection_duration_seconds
# promptshield_detection_confidence_histogram
# promptshield_api_errors_total{error_type="..."}
# promptshield_rate_limit_remaining