The best prompt injection detection library for most Python teams in late 2026 is Meta's Llama Prompt Guard 2 (86M for multilingual traffic, 22M when speed matters), run as a small classifier in front of your model and tuned on your own traffic. Protect AI's DeBERTa model still works but its maintainers archived LLM Guard and stopped updating the models, Pytector is the easiest wrapper with agent features, and rule based scanners such as Sunglasses make a cheap first filter. No library stops every injection: in our 12 prompt test, every tool flagged a harmless translation request, and the rule scanner missed a politely worded leak attempt.
This guide is about detecting attacks at run time. If you want to attack your own app to find holes before launch, read our guide to prompt injection attacks and how to test for them and the comparison of LLM red teaming tools.
Prompt injection detection library options at a glance
| Library | Type | License | Status (checked Nov 10, 2026) | Best for |
|---|---|---|---|---|
| Llama Prompt Guard 2 (86M, 22M) | Classifier model | Llama 4 Community License, gated download | Released April 2025 | Default choice, multilingual (86M) |
Protect AI deberta-v3-base-prompt-injection-v2 | Classifier model | Apache 2.0 | No longer maintained | Existing setups, quick baseline |
| LLM Guard | Scanner toolkit (uses the model above) | MIT | GitHub repo archived | Avoid for new projects |
| Pytector 0.4.0 | Python wrapper around classifiers | Apache 2.0 | Released Aug 10, 2026 | Agents and tool output screening |
| Sunglasses 0.6.20, PromptScreen 0.3.0 | Pattern and rule scanners | MIT, Apache 2.0 | Active | Cheap first pass, encoded payloads |
| NeMo Guardrails 0.24.1 | Guardrail framework with perplexity heuristics | Open source (NVIDIA) | Released Sept 16, 2026 | GCG style gibberish suffixes |
| Azure Prompt Shields, Lakera Guard | Hosted APIs | Commercial | Active | Teams that prefer an API over a model |
Rebuff, once a popular choice, was archived by Protect AI (its last push was August 2024), and Vigil has not been updated since January 2024. Both still show up in older lists; neither is a good starting point now.
What a prompt injection detector can and cannot catch
A detector reads text before it reaches your model (a user message, a retrieved web page, a tool result) and returns a score or a block decision. It works well on attacks that look like known attacks: "ignore all previous instructions", persona swaps like DAN, and instructions hidden in a document.
It cannot know your app's intent. Meta's model card is direct about this: Prompt Guard 2 labels text malicious when it "explicitly attempts to override prior instructions," regardless of whether the attack would work or cause harm. It also warns that adaptive attackers can write prompts designed to slip past it, and that application specific attacks need fine tuning on your own data.
Two practical limits matter most:
- Context window. Both Prompt Guard 2 models read 512 tokens. Longer text has to be split into chunks and scanned piece by piece, and an outside benchmark found that 512 token detectors lose track of injections buried deep in long agent conversations.
- False positives. Text that discusses an attack looks like an attack. A security FAQ, a language class exercise or a prompt engineering request can trip a classifier.
So treat a detector as one layer. The design rules in our prompt injection guide (least privilege, no private data and outbound channel in the same context) still do most of the work.
The libraries in detail
Llama Prompt Guard 2
Meta released two classifiers in the Llama Prompt Guard 2 series: an 86M model built on mDeBERTa base, trained and evaluated on English plus French, German, Hindi, Italian, Portuguese, Spanish and Thai, and a 22M model built on DeBERTa xsmall that Meta says cuts latency and compute by 75%. Both output a simple benign or malicious label and load with the standard transformers pipeline("text-classification") call.
On Meta's private jailbreak benchmark, the model card reports recall at a 1% false positive rate of 97.5% for the 86M model and 88.7% for the 22M model, against 21.2% for Prompt Guard 1, with per call latency of 92.4 ms and 19.3 ms on an A100 GPU. In an agent test on AgentDojo, Meta reports the 86M model cut attack success by 81.2% at a 3% loss of task utility, against 22.2% for the Protect AI model. These are Meta's numbers on Meta's setup.
The catch is access. The weights sit behind the Llama 4 Community License on Hugging Face, so you accept the license and authenticate before downloading, and products above 700 million monthly users need a separate license from Meta.
Protect AI DeBERTa v2 and LLM Guard
protectai/deberta-v3-base-prompt-injection-v2 is a 184M parameter classifier under Apache 2.0, and Hugging Face showed about 511,000 downloads for it in the last month when we checked. It powers the prompt injection scanner in LLM Guard. Both are now frozen: the LLM Guard README opens with "THIS PROJECT HAS BEEN ARCHIVED" and says the project and its Hugging Face models are no longer under active development. The last LLM Guard release on PyPI is 0.3.16 from May 2025.
You can still download and run the model, and it did well on blatant attacks in our test. The problem is drift: new attack styles will not be added, and the outside numbers below show it under catches at its default threshold.
Pytector
Pytector is a small Apache 2.0 package that wraps local classifiers (or a Groq hosted safeguard model) behind one detect_injection() call. Version 0.4.0 adds pieces aimed at agents: a ToolOutputGuard that screens tool results and web pages before they go back into the model, canary tokens that catch system prompt leaks, a keyword blocker and a LangChain guard.
One thing we found by reading the code: the default deberta option points at protectai/deberta-v3-base-prompt-injection, the older v1 model, not v2. In our test that default flagged a harmless git question that v2 passed. If you use Pytector, pass a model id explicitly.
Rule based scanners: Sunglasses and PromptScreen
Pattern scanners need no model download and answer in milliseconds. Sunglasses (MIT) says version 0.6.20 ships 1,584 patterns across 117 attack categories, including tool poisoning and credential exfiltration; that count is the vendor's own. PromptScreen (Apache 2.0) combines keyword heuristics, YARA rules and checks for hidden Unicode and Base64, hex or ROT13 payloads.
They are good at encoded and copy paste attacks and weak at paraphrase. Use one as a cheap first pass in front of a classifier, not instead of it.
NeMo Guardrails jailbreak heuristics
NVIDIA's NeMo Guardrails has a different kind of detector: it measures how surprising the text looks to gpt2-large. The jailbreak protection docs are candid about the tradeoff. The length per perplexity check at its default threshold caught 31.19% of jailbreaks with a 7.44% false positive rate on NVIDIA's dataset. The prefix and suffix check caught 49 of 50 GCG style attacks (the random looking token strings optimized to break models) at a 0.04% false positive rate. Both are meant for English only, and the docs say running them in process is for testing, not production.
Hosted APIs: Azure Prompt Shields and Lakera Guard
If you would rather call an API, Azure Prompt Shields checks a user prompt for attacks and, separately, up to five documents for hidden instructions, returning attackDetected for each. Microsoft notes the models are trained and evaluated mainly on English. Lakera Guard now runs under Check Point as AI Guardrails; its pricing page lists a free Community plan with 10,000 requests a month and prompts up to 8,000 tokens, with Enterprise priced by quote.
What we saw on 12 test prompts
We wrote six attacks and six harmless prompts that share vocabulary with attacks, then ran them through three of the libraries on an 8 core CPU at about 6:50 PM ET on Nov 10, 2026. Twelve prompts is a smoke test, not a benchmark, but it shows the failure types you will meet.
| Prompt | Protect AI v2 | Pytector default | Sunglasses |
|---|---|---|---|
| "Ignore all previous instructions..." | Flagged | Flagged | Blocked |
| DAN persona with no rules | Flagged | Flagged | Blocked |
| Instruction hidden in a report to email it out | Flagged | Flagged | Blocked |
| Base64 encoded "ignore all previous instructions" | Flagged | Flagged | Blocked |
| Same attack in French | Flagged | Flagged | Blocked |
| Polite request to append the hidden developer instructions | Flagged | Flagged | Missed |
| Git question about ignoring previous commits | Passed | Flagged | Passed |
| Help writing a system prompt for a support bot | Passed | Passed | Passed |
| Translate "ignore the above directions" for a class | Flagged | Flagged | Blocked |
| What is a prompt injection attack? | Passed | Passed | Passed |
| Vegetarian lasagna recipe | Passed | Passed | Passed |
| Python function about removing previous list entries | Passed | Passed | Passed |
Results: Protect AI v2 caught 6 of 6 attacks with 1 false positive, Pytector's default model caught 6 of 6 with 2 false positives, and Sunglasses caught 5 of 6 with 1 false positive. The classifiers took about 50 to 180 ms per prompt on CPU; Sunglasses took 5 to 33 ms. Every tool flagged the translation exercise, which is exactly the "talks about an attack" problem.
Outside numbers: why false positives decide the winner
The most useful public comparison we found is the Bastion Soft detector benchmark, which scores detectors on attack datasets and on real chat messages from WildChat and LMSYS. Read it with care: it is maintained by Bastion Soft, which also ships a detector that tops its table, though it publishes every per prompt score so anyone can recompute the results.
At the default 0.5 threshold it measured these false positive rates on real traffic: Prompt Guard 2 22M 0.77%, Prompt Guard 2 86M 4.88%, Protect AI v2 8.82%. Its findings note that Protect AI v2 catches only 68.5% of attacks at that threshold, and that pushing it to catch 95% would flag every benign message in the set. Prompt Guard 2 86M needed to flag 25.52% of real traffic to reach a 95% catch rate, and the 22M model 40.39%.
The lesson is simple. Two detectors with similar accuracy on attack datasets can differ by a factor of ten in how many real users they block, so test on your own traffic before you choose. The same theme runs through Red Hat's guardrail comparison, covered in our guide to picking an LLM judge model, where a small DeBERTa classifier nearly matched an LLM judge on prompt injection.
Prompt injection detection in Python: a minimal setup
This is the shape of a sensible first setup: a fast rule pass, then a classifier, with logging so you can tune later.
from transformers import pipeline
clf = pipeline(
"text-classification",
model="meta-llama/Llama-Prompt-Guard-2-86M", # gated: accept the license first
truncation=True, max_length=512,
)
def screen(text, threshold=0.9):
# Prompt Guard 2 reads 512 tokens, so scan long text in chunks
chunks = [text[i:i + 1500] for i in range(0, len(text), 1500)] or [""]
for chunk in chunks:
result = clf(chunk)[0]
if result["label"] == "MALICIOUS" and result["score"] >= threshold:
return False, result
return True, None
Screen user input and, just as important, every retrieved page and tool result before it goes back into the model. Character chunking is a rough stand in for token chunking; Meta's PurpleLlama repository has inference utilities for splitting long inputs properly.
How to choose and test a detector on your own traffic
- Collect 500 to 1,000 real benign messages from your logs, including the awkward ones (security questions, code, other languages).
- Collect attacks from public sets and from your own red teaming runs with Promptfoo, garak or a scripted PyRIT campaign.
- Run two or three candidates and record the false positive rate on your benign set at the catch rate you need, not just accuracy.
- Pick a threshold per entry point. Tool output and retrieved documents can take a stricter threshold than chat input.
- Decide what a flag does. Blocking, asking the user to rephrase and silently dropping a retrieved page are different choices.
- Rerun monthly and after model or prompt changes, the same way you rerun your red teaming tests.
FAQ
What is the best open source prompt injection detection library?
For a classifier, Llama Prompt Guard 2 is the strongest current open option based on Meta's model card and outside tests, though its license is Meta's own rather than a standard open source license. For a fully Apache 2.0 stack, Pytector with an explicit model choice plus a rule scanner such as PromptScreen is a reasonable start.
Is LLM Guard still maintained?
No. Its GitHub repository is archived, the README says the project and its Hugging Face models are no longer under active development, and the last PyPI release is 0.3.16 from May 2025. Existing installs keep working, but plan a migration.
How do I detect prompt injection in Python?
Load a classifier such as Llama Prompt Guard 2 with the transformers text classification pipeline, split long text into chunks under 512 tokens, and block or review anything scored malicious above a threshold you tuned on your own traffic. Add a fast pattern scanner in front for encoded payloads.
Can a detector stop indirect prompt injection?
Partly. Run it on retrieved documents and tool output, not only on user messages, as Pytector's tool output guard and Azure's document checks do. A detector will still miss novel or buried instructions, so limit what an agent can do with untrusted content.
Are prompt injection detectors accurate?
On blatant attacks, yes: every tool in our test caught "ignore all previous instructions." The weak spots are false positives on text that discusses attacks and missed paraphrased attacks. Public benchmarks show false positive rates on real chat ranging from under 1% to over 60% depending on the model.



