Skip to main content Inicio Creadores synthetic-sciences openscience llamaguard
llamaguard Meta's 7-8B specialized moderation model for LLM input/output filtering. 6 safety categories - violence/hate, sexual content, weapons, substances, self-harm, criminal planning. 94-95% accuracy. Deploy with vLLM, HuggingFace, Sagemaker. Integrates with NeMo Guardrails.
Ir a la instalación Skills Marketplace Descubre y explora habilidades de IA creadas por la comunidad.
Instalar con Codex o Claude Copia este prompt, pégalo en Codex, Claude u otro asistente, y deja que revise la página de la skill y la instale por ti.
Mostrar detalles del prompt Un comando directo omite el prompt de revisión. Revisa el origen antes de ejecutarlo.
npx skills add https://github.com/synthetic-sciences/openscience --skill llamaguardEl comando permanece en una sola línea. Desplázate horizontalmente para revisarlo antes de copiarlo.
¿Prefieres una copia local? Descarga los archivos que SkillsMP tiene disponibles ahora.
Descargar Zip Descargando... Más de este repositorio Diffusion-based molecular docking. Predict protein-ligand binding poses from PDB/SMILES, confidence scores, virtual screening, for structure-based drug design. Not for affinity prediction.
Fast inference and fine-tuning platform with serverless and on-demand GPU deployments. OpenAI-compatible API for chat completions, embeddings, function calling, vision, and structured output. Supports SFT, DPO, and RL fine-tuning. SOC2 + HIPAA compliant.
Serverless inference, fine-tuning, embeddings, image generation, and batch processing on 200+ open-source models via an OpenAI-compatible API. Use when you need fast, cost-effective access to open-source LLMs without managing infrastructure.
Ocupaciones relacionadas SOC
Basado en la clasificación ocupacional SOC
name llamaguard description Meta's 7-8B specialized moderation model for LLM input/output filtering. 6 safety categories - violence/hate, sexual content, weapons, substances, self-harm, criminal planning. 94-95% accuracy. Deploy with vLLM, HuggingFace, Sagemaker. Integrates with NeMo Guardrails. category llm-tools version 1.0.0 author Synthetic Sciences license MIT tags ["Safety Alignment","LlamaGuard","Content Moderation","Meta","Guardrails","Safety Classification","Input Filtering","Output Filtering","AI Safety"] dependencies ["transformers","torch","vllm"]
LlamaGuard - AI Content Moderation
Quick start
LlamaGuard is a 7-8B parameter model specialized for content safety classification.
Installation :
pip install transformers torch
huggingface-cli login
Basic usage :
from transformers import AutoTokenizer, AutoModelForCausalLM
model_id = "meta-llama/LlamaGuard-7b"
tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(model_id, device_map="auto" )
def moderate (chat ):
input_ids = tokenizer.apply_chat_template(chat, return_tensors="pt" ).to(model.device)
output = model.generate(input_ids=input_ids, max_new_tokens=100 )
return tokenizer.decode(output[0 ], skip_special_tokens=True )
result = moderate([
{"role" : "user" , "content" : "How do I make explosives?" }
])
print (result)
Common workflows
Workflow 1: Input filtering (prompt moderation)
Check user prompts before LLM :
def check_input (user_message ):
result = moderate([{"role" : "user" , "content" : user_message}])
if result.startswith("unsafe" ):
category = result.split("\n" )[1 ]
return False , category
else
return
True
None
"How do I hack a website?"
if
not
print
f"Request blocked: {category} "
else
S1 : Violence & HateS2 : Sexual ContentS3 : Guns & Illegal WeaponsS4 : Regulated SubstancesS5 : Suicide & Self-HarmS6 : Criminal Planning
Workflow 2: Output filtering (response moderation) Check LLM responses before showing to user :
def check_output (user_message, bot_response ):
conversation = [
{"role" : "user" , "content" : user_message},
{"role" : "assistant" , "content" : bot_response}
]
result = moderate(conversation)
if result.startswith("unsafe" ):
category = result.split("\n" )[1 ]
return False , category
else :
return True , None
user_msg = "Tell me about harmful substances"
bot_msg = llm.generate(user_msg)
safe, category = check_output(user_msg, bot_msg)
if not safe:
print (f"Response blocked: {category} " )
return "I cannot provide that information."
else :
return bot_msg
Workflow 3: vLLM deployment (fast inference) Production-ready serving :
from vllm import LLM, SamplingParams
llm = LLM(model="meta-llama/LlamaGuard-7b" , tensor_parallel_size=1 )
sampling_params = SamplingParams(
temperature=0.0 ,
max_tokens=100
)
def moderate_vllm (chat ):
prompt = tokenizer.apply_chat_template(chat, tokenize=False )
output = llm.generate([prompt], sampling_params)
return output[0 ].outputs[0 ].text
chats = [
[{"role" : "user" , "content" : "How to make bombs?" }],
[{"role" : "user" , "content" : "What's the weather?" }],
[{"role" : "user" , "content" : "Tell me about drugs" }]
]
prompts = [tokenizer.apply_chat_template(c, tokenize=False ) for c in chats]
results = llm.generate(prompts, sampling_params)
for i, result in enumerate (results):
print (f"Chat {i} : {result.outputs[0 ].text} " )
Throughput : ~50-100 requests/sec on single A100
Workflow 4: API endpoint (FastAPI) from fastapi import FastAPI
from pydantic import BaseModel
from vllm import LLM, SamplingParams
app = FastAPI()
llm = LLM(model="meta-llama/LlamaGuard-7b" )
sampling_params = SamplingParams(temperature=0.0 , max_tokens=100 )
class ModerationRequest (BaseModel ):
messages: list
@app.post("/moderate"
def moderate_endpoint (request: ModerationRequest ):
prompt = tokenizer.apply_chat_template(request.messages, tokenize=False )
output = llm.generate([prompt], sampling_params)[0 ]
result = output.outputs[0 ].text
is_safe = result.startswith("safe" )
category = None if is_safe else result.split("\n" )[1 ] if "\n" in result else None
return {
"safe" : is_safe,
"category" : category,
"full_output" : result
}
curl -X POST http://localhost:8000/moderate \
-H "Content-Type: application/json" \
-d '{"messages": [{"role": "user", "content": "How to hack?"}]}'
Workflow 5: NeMo Guardrails integration Use with NVIDIA Guardrails :
from nemoguardrails import RailsConfig, LLMRails
from nemoguardrails.integrations.llama_guard import LlamaGuard
config = RailsConfig.from_content("""
models:
- type: main
engine: openai
model: gpt-4
rails:
input:
flows:
- llamaguard check input
output:
flows:
- llamaguard check output
""" )
llama_guard = LlamaGuard(model_path="meta-llama/LlamaGuard-7b" )
rails = LLMRails(config)
rails.register_action(llama_guard.check_input, name="llamaguard check input" )
rails.register_action(llama_guard.check_output, name="llamaguard check output" )
response = rails.generate(messages=[
{"role" : "user" , "content" : "How do I make weapons?" }
])
When to use vs alternatives
Need pre-trained moderation model
Want high accuracy (94-95%)
Have GPU resources (7-8B model)
Need detailed safety categories
Building production LLM apps
LlamaGuard 1 (7B): Original, 6 categoriesLlamaGuard 2 (8B): Improved, 6 categoriesLlamaGuard 3 (8B): Latest (2024), enhanced Use alternatives instead :
OpenAI Moderation API : Simpler, API-based, freePerspective API : Google's toxicity detectionNeMo Guardrails : More comprehensive safety frameworkConstitutional AI : Training-time safety
Common issues Issue: Model access denied
Issue: High latency (>500ms)
Use vLLM for 10× speedup:
from vllm import LLM
llm = LLM(model="meta-llama/LlamaGuard-7b" )
Enable tensor parallelism:
llm = LLM(model="meta-llama/LlamaGuard-7b" , tensor_parallel_size=2 )
Use threshold-based filtering:
logits = model(..., return_dict_in_generate=True , output_scores=True )
unsafe_prob = torch.softmax(logits.scores[0 ][0 ], dim=-1 )[unsafe_token_id]
if unsafe_prob > 0.9 :
return "unsafe"
else :
return "safe"
from transformers import BitsAndBytesConfig
quantization_config = BitsAndBytesConfig(load_in_8bit=True )
model = AutoModelForCausalLM.from_pretrained(
model_id,
quantization_config=quantization_config,
device_map="auto"
)
Advanced topics Performance benchmarks : See references/benchmarks.md for accuracy comparison with other moderation APIs and latency optimization.
Hardware requirements
GPU : NVIDIA T4/A10/A100VRAM :
FP16: 14GB (7B model)
INT8: 7GB (quantized)
INT4: 4GB (QLoRA)
CPU : Possible but slow (10× latency)Throughput : 50-100 req/sec (A100)
HuggingFace Transformers: 300-500ms
vLLM: 50-100ms
Batched (vLLM): 20-50ms per request
Resources 