NeuralTrust | The leading security platform for generative AI

When you own the application, integrate TrustGuard directly around your model calls. This gives you full control over what to inspect and how to enforce, and works with any model provider. Create an API key on the collector first. Prefer the official SDKs over hand-rolled HTTP — they take the base URL and call /v1/guard for you:

Language	Package
Node / TypeScript	`@neuraltrust/trustguard-sdk`
Python	`neuraltrust-trustguard`
Go	`github.com/NeuralTrust/trustguard-sdk/go`

The response carries a status (allow / report / transform / block); the SDKs expose is_blocked / isBlocked (true when status == "block") and the transformed_payload for masked content.

Python SDK

pip install neuraltrust-trustguard
Call client.guard() with direction="input" (prompt) or direction="output" (completion).
Pass consumer_id and session_id for attribution.
Block when is_blocked is true; forward transformed_payload when present.

from trustguard import TrustGuard

client = TrustGuard("<your-trustguard-url>", "<collector-api-key>")

response = client.guard(
    {"input": user_input},
    direction="input",            # "output" for completions
    consumer_id="[email protected]",  # who: user id, email, or device fingerprint
    session_id="sess-123",        # which conversation the message belongs to
)

if response.is_blocked:
    raise PermissionError("Blocked by TrustGuard")
# response.transformed_payload carries masked content when a Transform rule ran

Node.js SDK

npm install @neuraltrust/trustguard-sdk
Call client.guard() with direction "input" / "output".
Pass consumerId and sessionId.
Block when isBlocked is true; forward transformedPayload when present.

import { TrustGuard } from "@neuraltrust/trustguard-sdk";

const client = new TrustGuard({
  baseUrl: "<your-trustguard-url>",
  apiKey: "<collector-api-key>",
});

const response = await client.guard({
  payload: { input: userInput },
  direction: "input",          // "output" for completions
  consumerId: user.id,         // who: user id, email, or device fingerprint
  sessionId: conversationId,   // which conversation the message belongs to
});

if (response.isBlocked) throw new Error("Blocked by TrustGuard");
// response.transformedPayload carries masked content when a Transform rule ran

REST API

Any language can call the guard endpoint directly (Go users: use the Go SDK instead of hand-rolling).

curl -X POST "{TRUSTGUARD_URL}/v1/guard" \
  -H "Authorization: Bearer <collector-api-key>" \
  -H "Content-Type: application/json" \
  -d '{
    "protocol": "llm",
    "direction": "input",
    "payload": { "input": "summarize this customer call" },
    "session_id": "sess-123",
    "consumer_id": "[email protected]"
  }'

# Response:
# { "status": "allow", "findings": [], "transformed_payload": null, "trace_id": "…", "request_id": "…" }

Python middleware (FastAPI / Django / Flask)

Guard inbound user traffic in-process with a middleware in front of your AI routes.

from fastapi import FastAPI, Request
from starlette.responses import JSONResponse
from trustguard import AsyncTrustGuard

app = FastAPI()
client = AsyncTrustGuard("<your-trustguard-url>", "<collector-api-key>")

@app.middleware("http")
async def trustguard_middleware(request: Request, call_next):
    if request.method == "POST":
        body = await request.body()
        response = await client.guard(
            {"input": body.decode()},
            consumer_id=request.headers.get("x-user-id", ""),
            session_id=request.cookies.get("session_id", ""),
        )
        if response.is_blocked:
            return JSONResponse({"detail": "Blocked by TrustGuard"}, status_code=403)
    return await call_next(request)

Node.js middleware (Express / Next.js)

import express from "express";
import { TrustGuard } from "@neuraltrust/trustguard-sdk";

const app = express();
app.use(express.json());

const client = new TrustGuard({
  baseUrl: "<your-trustguard-url>",
  apiKey: "<collector-api-key>",
});

app.use(async (req, res, next) => {
  if (req.method !== "POST") return next();
  const response = await client.guard({
    payload: { input: JSON.stringify(req.body) },
    consumerId: req.get("x-user-id") ?? "",
    sessionId: req.cookies?.session_id ?? "",
  });
  if (response.isBlocked) {
    return res.status(403).json({ detail: "Blocked by TrustGuard" });
  }
  next();
});

Tips

Inspect both sides: direction:"input" before the model call, direction:"output" on the completion.
Send documents/links via the attachments argument (folded into payload.attachments) to engage the document and URL analyzers — see the Guard API for the attachment + SSRF rules.
On a detector infrastructure error TrustGuard follows your deployment’s fail-open / fail-closed setting — decide whether to hold traffic on errors accordingly.

​Python SDK

​Node.js SDK

​REST API

​Python middleware (FastAPI / Django / Flask)

​Node.js middleware (Express / Next.js)

​Tips