Auto-instrumentation

init() patches the provider SDKs installed in your process, so each call they make is scanned by the Guard API before it leaves. Your client keeps calling the provider directly with its own key; only the scan goes to PromptGuard.

import promptguard
promptguard.init()  # reads PROMPTGUARD_API_KEY; call once, before creating clients

import { init } from 'promptguard-sdk';
init(); // reads PROMPTGUARD_API_KEY; call once, before creating clients

Options such as mode and fail_open are in the Python SDK and Node.js SDK guides.

What is patched

Patching is per call surface, not per package. A call not listed here is not scanned, even when its package is patched: the OpenAI embeddings, audio and image endpoints, for example.

Name reported	Python package and calls	Node package and calls	Provider page
`openai`	`openai`: `chat.completions.create`, `chat.completions.parse`, `responses.create`, sync and async	`openai`: `chat.completions.create`, `responses.create`	OpenAI, Azure OpenAI
`anthropic`	`anthropic`: `messages.create`, sync and async	`@anthropic-ai/sdk`: `messages.create`	Anthropic
`google-genai`	`google-genai`: `models.generate_content`, its streaming form, sync and async	`@google/genai`: `models.generateContent`	Gemini
`google-generativeai`	`google-generativeai` (deprecated by Google): `GenerativeModel.generate_content`	`@google/generative-ai` (deprecated by Google): `GenerativeModel.generateContent`	Gemini
`cohere`	`cohere`: `Client.chat`, `ClientV2.chat`, sync and async	`cohere-ai`: `Client.chat`, `ClientV2.chat`	Cohere
`bedrock`	`boto3` / `botocore`: Bedrock Runtime `InvokeModel`, `Converse`, `ConverseStream`	`@aws-sdk/client-bedrock-runtime`: `send` of `InvokeModelCommand`, `ConverseCommand` and their streaming variants	AWS Bedrock

The exact surfaces, including which parts of a Responses API input are read, are in each SDK’s README: Python, Node.js.

Frameworks on top of these SDKs

A framework is covered when it calls one of the patched surfaces underneath. LangChain’s ChatOpenAI calls the openai package, so its calls are scanned, including inside a LangGraph graph. Frameworks that make their own HTTP calls are not: the Vercel AI SDK’s providers (@ai-sdk/openai and the rest) do not use the openai package, so init() does not see them. Use the Vercel AI integration or the proxy for those. For the framework-specific hooks, which add chain, tool and agent context to each scan, see Frameworks.

What is not patched

When init() finds a provider library installed that it did not hook, it logs a warning naming it, with a link to this page. Calls through these are not scanned by init(); point their base URL at the proxy instead.

Python	Node
`groq`, `mistralai`, `together`, `ollama`, `google-cloud-aiplatform`	`groq-sdk`, `@mistralai/mistralai`, `together-ai`, `ollama`, `@google-cloud/aiplatform`, `@aws-sdk/client-bedrock-agent-runtime`, `@ai-sdk/openai`, `@ai-sdk/anthropic`, `@ai-sdk/google`

Checking it at runtime

A warning is only read by someone watching the logs at startup. The same facts are available as data, so you can fail a deploy on them:

import promptguard

promptguard.init()
report = promptguard.instrumentation_report()
assert "openai" in report["patched"]
assert report["detected_unpatched"] == [], report["detected_unpatched"]

import { init, instrumentationReport } from 'promptguard-sdk';

init();
const report = instrumentationReport();
if (!report.patched.includes('openai') || report.detectedUnpatched.length > 0) {
  throw new Error(`PromptGuard instrumentation incomplete: ${JSON.stringify(report)}`);
}

patched holds the names in the first column of the table above, the same in both SDKs. middleware lists the request-edge middleware running in the process, whether or not init() was called: fastapi when the Python SDK’s FastAPI and ASGI middleware is mounted. A middleware is never a patch, so it never appears in patched. An SDK with none reports an empty list, so the same check reads the same in both languages.

Node.js ESM apps. The Node SDK patches the provider modules that CommonJS require() resolves. In a native ESM app ("type": "module"), a provider that ships a separate ESM build gives your import a different module object, which is not patched, so its calls go unscanned. There, use a framework integration, the proxy, or GuardClient.scan() directly.

Get Started

Core Concepts

Gateway

Integrations

Shadow AI

Guides

Cookbooks

Platform

Going to Production

Resources

Roadmap / Preview

What is patched

Frameworks on top of these SDKs

What is not patched

Checking it at runtime

​What is patched

​Frameworks on top of these SDKs

​What is not patched

​Checking it at runtime

What is patched

Frameworks on top of these SDKs

What is not patched

Checking it at runtime