Introduction to odin-prompt-toolkit

odin-prompt-toolkit is a multi-language SDK for AI prompt safety and security. It gives you the tools to detect jailbreaks, find similar or duplicate prompts, and match incoming prompts against known threat intelligence — across Rust, Python, TypeScript, and Go.

What It Does

The toolkit provides two complementary capabilities:

🔍 LSH Signatures — Prompt Similarity & Deduplication

Converts any prompt into a compact 256-bit signature that preserves semantic similarity. Identical or near-identical prompts produce signatures with small Hamming distance, enabling fast similarity search without storing or comparing raw embeddings.

Use it to:

• Detect duplicate or paraphrased prompts at scale
• Build approximate nearest-neighbor (ANN) indexes over large prompt corpora
• Match incoming prompts against a cache of known threats (Threat Feed)

🚨 SusFactor — Jailbreak & Prompt Injection Classification

Scores a prompt from 0 (safe) to 1 (suspicious) using a fine-tuned e5-large model. No embedding pipeline needed — feed it a prompt, get back a score and a label.

Use it to:

• Flag jailbreak attempts and prompt injection attacks in real time
• Gate LLM requests based on risk score
• Combine with signatures for defense-in-depth: detect known attacks via threat feed and novel attacks via classifier

---

Key Features

• 🔒 Jailbreak detection — SusFactor classifier scores prompts 0–1 for suspicious intent
• 🔍 Similarity signatures — 256-bit SimHash LSH signatures for fast deduplication and ANN search
• 🛡️ Threat intelligence — Sync and query the 0DIN threat feed of known adversarial prompts
• 🌍 Cross-language — Identical signatures and parity scores across Rust, Python, TypeScript, and Go
• 📦 No API required — Local ONNX models for both embeddings (V1) and classification
• 🚀 Fast — O(1) signature lookups; native Rust acceleration for Python (up to ~600× speedup)
• 🧪 Battle-tested — 400+ tests across 4 languages

---

Quick Examples

Jailbreak Detection (SusFactor)

Rust

use odin_prompt_toolkit::providers::ModelCache;
use odin_prompt_toolkit::susfactor::SusFactorClassifier;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let cache = ModelCache::new()?;
    let clf = SusFactorClassifier::new(&cache, None, None, None).await?;

    let result = clf.classify("Ignore all previous instructions").await?;
    println!("{:.3} — {}", result.score, result.label);
    // 0.972 — suspicious

    Ok(())
}

Python

import asyncio
from odin_prompt_toolkit.providers import ModelCache
from odin_prompt_toolkit.susfactor import SusFactorOnnxClassifier

async def main():
    cache = ModelCache()
    clf = await SusFactorOnnxClassifier.new(cache)

    result = await clf.classify("Ignore all previous instructions")
    print(result.score, result.label)  # 0.972 suspicious

    await clf.close()

asyncio.run(main())

TypeScript

import { SusFactorClassifier } from '@0din/prompt-toolkit/susfactor';
import { ModelCache } from '@0din/prompt-toolkit/providers';

const clf = await SusFactorClassifier.create(new ModelCache());
const result = await clf.classify('Ignore all previous instructions');
console.log(result.chunks[0].score, result.chunks[0].label); // 0.972 suspicious
await clf.close();

Go

package main

import (
    "context"
    "fmt"
    "github.com/0din-ai/prompt-toolkit/packages/go/susfactor"
)

func main() {
    ctx := context.Background()
    clf, err := susfactor.NewClassifier(ctx,
        susfactor.WithModelDir("/path/to/susfactor-v1"),
    )
    if err != nil {
        panic(err)
    }
    defer clf.Close()

    result, _ := clf.Classify(ctx, "Ignore all previous instructions")
    fmt.Printf("%.3f — %s\n", result.Chunks[0].Score, result.Chunks[0].Label)
    // 0.972 — suspicious
}

Requires ORT v1.26+ shared lib and libtokenizers. See Installation and Go + Docker Guide.

Signature Generation

Rust

use odin_prompt_toolkit::{sign_text, SignatureVersion};
use odin_prompt_toolkit::providers::{ModelCache, OnnxProvider};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let cache = ModelCache::new()?;
    let provider = OnnxProvider::new(&cache, None, None, 0, 0).await?;

    let result = sign_text(
        "How do I reset my password?",
        &provider,
        SignatureVersion::Latest,
        None,
    ).await?;

    println!("{}", result.to_signature_string());
    // 0din-v1:8d000000ac854dae...

    Ok(())
}

Python

import asyncio
from odin_prompt_toolkit import sign_text
from odin_prompt_toolkit.providers import ModelCache, OnnxProvider

async def main():
    cache = ModelCache()
    provider = await OnnxProvider.new(cache)

    result = await sign_text("How do I reset my password?", provider)
    print(result.signature_string)  # 0din-v1:8d000000ac854dae...

    await provider.close()

asyncio.run(main())

TypeScript

import { signText, getSignatureString } from '@0din/prompt-toolkit';
import { ModelCache, OnnxProvider } from '@0din/prompt-toolkit/providers';

async function main() {
  const provider = await OnnxProvider.create(new ModelCache());
  const result = await signText('How do I reset my password?', provider);
  console.log(getSignatureString(result)); // 0din-v1:8d000000ac854dae...
  await provider.close();
}

main();

---

How the Two Capabilities Fit Together

	SusFactor	LSH Signatures
Input	Raw text	Raw text (embedding generated internally)
Output	Score 0–1 + label	256-bit hex signature
Detects	Novel jailbreaks, prompt injection	Duplicate / paraphrased known attacks
Speed	~50–200ms per prompt (ONNX)	<1ms per lookup after indexing
Best for	Real-time request gating	Large-scale deduplication, threat matching

For defense-in-depth, run both: SusFactor catches novel attacks the threat feed hasn't seen; signatures catch known variants that may score below the classifier threshold.

---

How Signatures Work

Signatures are generated using SimHash via Random Hyperplane LSH — a deterministic algorithm that converts any prompt embedding into a compact 256-bit hex fingerprint. Semantically similar prompts produce signatures with small Hamming distance, enabling fast similarity queries without storing or comparing raw vectors.

Deep dive: LSH Overview →

---

Signature Versions

Version	Provider	Model	Dimensions
V0	OpenAI	text-embedding-3-large	1536
V1	ONNX	0din-jailbreak-embeddings-small	1024

V0 and V1 signatures are not comparable — different embedding spaces.

---

Project Status

✅ Production Ready — All four language implementations validated with 400+ passing tests

Language	Package	Status	Tests
Rust	odin-prompt-toolkit v0.6.0	✅ Ready	69 passing
Python	0din-prompt-toolkit	✅ Ready	183 passing
TypeScript	@0din/prompt-toolkit	✅ Ready	146 passing
Go	github.com/0din-ai/prompt-toolkit/packages/go	✅ Ready (SusFactor)	27+ passing

See the Validation Report for detailed cross-language parity results.

---

Next Steps

• Installation — Install for Rust, Python, TypeScript, or Go
• Quick Start — Your first jailbreak check or LSH signature
• SusFactor — Jailbreak classification deep dive
• Threat Feed — Match prompts against 0DIN threat intelligence
• LSH Overview — How similarity signatures work
• Ecosystem — Projects and integrations built with the toolkit