LLM Risk Decisions
in Under 5ms

import httpx

client = httpx.Client(
    base_url="https://api.shep.ai",
    headers={"Authorization": "Bearer sk_live_..."},
)

response = client.post("/v1/risk/evaluate", json={
    "requestId":         "req_abc123",
    "clientId":          "my-gateway-prod",
    "ipAddress":         "203.0.113.42",
    "userAgent":         "Mozilla/5.0 ...",
    "userId":            "user_7f3a",
    "prompt":            "User's prompt text here...",
    "model":             "llama-3.1-70b",
})

result = response.json()
if result["decision"] == "BLOCK":
    raise PermissionError("Request blocked by ShepAI")

# Otherwise forward to inference provider
decision   = result["decision"]    # "ALLOW"
risk_score = result["riskScore"]   # 0–100
signals    = result["signals"]     # per-evaluator breakdown

import asyncio, httpx

async def check_risk(payload: dict) -> str:
    async with httpx.AsyncClient(
        base_url="https://api.shep.ai",
        headers={"Authorization": "Bearer sk_live_..."},
    ) as client:
        r = await client.post("/v1/risk/evaluate", json=payload)
        return r.json()["decision"]

const SHEP_KEY = process.env.SHEPAI_API_KEY;

async function checkRisk(payload) {
  const res = await fetch("https://api.shep.ai/v1/risk/evaluate", {
    method:  "POST",
    headers: {
      "Authorization": `Bearer ${SHEP_KEY}`,
      "Content-Type":  "application/json",
    },
    body: JSON.stringify(payload),
  });
  return res.json();
}

// In your inference gateway middleware:
const { decision, riskScore, signals } = await checkRisk({
  requestId:  "req_abc123",
  clientId:   "my-gateway-prod",
  ipAddress:  req.ip,
  userAgent:  req.headers["user-agent"],
  userId:     session.userId,
  prompt:     req.body.messages.at(-1)?.content,
  model:      req.body.model,
});

if (decision === "BLOCK") {
  return res.status(403).json({ error: "Request blocked", riskScore });
}

import OpenAI from "openai";

const openai = new OpenAI();

async function safeCompletion(messages, ctx) {
  const risk = await checkRisk({
    ipAddress: ctx.ip,
    userId:    ctx.userId,
    prompt:    messages.at(-1).content,
    model:     "gpt-4o",
  });

  if (risk.decision !== "ALLOW") throw new Error("Blocked");

  return openai.chat.completions.create({ model: "gpt-4o", messages });
}

import org.springframework.web.reactive.function.client.WebClient;

var client = WebClient.builder()
    .baseUrl("https://api.shep.ai")
    .defaultHeader("Authorization", "Bearer sk_live_...")
    .build();

record RiskPayload(
    String requestId, String clientId,
    String ipAddress,  String userAgent,
    String userId,     String prompt
) {}

var result = client.post()
    .uri("/v1/risk/evaluate")
    .bodyValue(new RiskPayload(
        requestId, clientId, ip, userAgent, userId, prompt
    ))
    .retrieve()
    .bodyToMono(RiskResponse.class)
    .block(); // or .subscribe() for non-blocking

if (result.decision() == Decision.BLOCK) {
    throw new SecurityException("Request blocked: score="
        + result.riskScore());
}

@Component
public class ShepAIFilter implements WebFilter {

  private final ShepAIClient shepai;

  @Override
  public Mono<Void> filter(
      ServerWebExchange exchange,
      WebFilterChain   chain
  ) {
    return shepai.evaluate(exchange)
      .flatMap(r -> r.isBlock()
          ? reject(exchange, r)
          : chain.filter(exchange));
  }
}