Pular para o conteúdo
AggregaAggrega
Selecionar língua: Português (Portugal)
Esta página foi traduzida automaticamente. Ler o original em inglês.

NeMo Guardrails a verificar os pedidos de um agente com os modelos NemoGuard da NVIDIA

Os pedidos de modelo de um agente passam pelo NVIDIA NeMo Guardrails, que verifica cada um deles com dois dos modelos NemoGuard da NVIDIA, produtos licenciados da NVIDIA que precisam de uma licença da NVIDIA, de uma chave de API do NGC e de um nó com GPU para funcionar.

O que requer

Os dois modelos NemoGuard são produtos da NVIDIA executados nos termos da NVIDIA. Implementar o que este workspace compila requer:

  • Uma licença da NVIDIA. A documentação da NVIDIA para cada microsserviço NemoGuard indica como pré-requisito «an active subscription to an NVIDIA AI Enterprise product or be an NVIDIA Developer Program member» (uma subscrição ativa de um produto NVIDIA AI Enterprise ou ser membro do NVIDIA Developer Program), e afirma que o acesso aos contentores e aos modelos é restrito.
  • Uma chave de API do NGC, referenciada pela Release como segredo. Os contentores NemoGuard são obtidos do registo da NVIDIA, nvcr.io, e cada um obtém o seu modelo da NVIDIA com a chave quando arranca. A Release nomeia dois Secrets do Kubernetes que a contêm — um a partir do qual os pods leem a chave, outro com o qual o cluster obtém as imagens — e nenhum ficheiro neste workspace, nem nada do que a compilação escreve, contém a própria chave.
  • Um nó com GPU. Cada contentor NemoGuard pede uma GPU da NVIDIA. A NVIDIA indica que o modelo de segurança de conteúdo precisa de 48 GB de memória de GPU, numa GPU ou em duas.

A compilação não precisa de nada disto: compila para manifestos do Kubernetes sem nenhuma chave presente, e não contacta nem a NVIDIA nem o cluster.

O que constrói

Um agente pede o seu modelo através de um gateway de IA. O gateway faz passar primeiro cada pedido de modelo por uma guarda, e a guarda verifica a última mensagem do utilizador de três formas antes de reencaminhar para o modelo o que admite: com um classificador de injeção de prompt, com o modelo de segurança de conteúdo da NVIDIA e com o classificador de jailbreak da NVIDIA. Este workspace compila essa disposição em manifestos do Kubernetes.

Mostra que um produto comercial licenciado é aprovisionado da mesma forma que um de código aberto: um Component do catálogo, uma Recipe, uma aresta uses e um anexo de credencial, com a licença indicada onde um leitor escolhe o componente. Não define nenhuma entidade de catálogo própria; o Aggregate, o Manifest e a Release são tudo o que alguém escreve.

instânciaComponent do catálogoo que é aqui
agentcore/ai-agent/langgrapho agente, a imagem de aplicação própria da Release, que chega ao seu modelo através do gateway
checkpointercore/datastore/valkeyonde o agente guarda o seu estado de execução
routercore/gateway/litellmo gateway de IA: um alias, assistant, enviado para o modelo através da guarda
guardcore/security/nemo-guardrailso servidor do NVIDIA NeMo Guardrails no caminho do modelo
detectorcore/security/trustyai-huggingface-detectoro classificador de injeção de prompt que o rail próprio da guarda consulta
safetycore/ai-model/nemoguard-content-safetyLlama 3.1 NemoGuard 8B ContentSafety da NVIDIA, servido pelo seu NIM
jailbreakcore/security/nemoguard-jailbreak-detectNemoGuard JailbreakDetect da NVIDIA, servido pelo seu NIM

As arestas uses: o socket model do agente para o gateway e o seu socket checkpointer_db para o repositório; o socket guard do gateway para a guarda; e os sockets detector, content_safety e jailbreak_detection da guarda para as três verificações. Os anexos: shield, a Feature core/prompt-injection-shield que coloca a guarda no caminho do gateway; upstream_key, a credencial que a guarda apresenta à API do modelo; e ngc_api_key em cada componente NemoGuard.

Gerar o exemplo

É possível compilar este exemplo com os comandos abaixo, ou pedir ao assistente de IA que o compile.

Escreva o exemplo numa nova pasta com o nome dele:

Terminal window
aggrega scaffold --example nemo-guardrails-nemoguard-nims

Depois, imprime os próximos comandos a executar. O primeiro entra na nova pasta:

Terminal window
cd nemo-guardrails-nemoguard-nims

Compilação

Terminal window
aggrega build --release release.yaml --auto-pull

Uma release precisa de um lockfile antes de ser compilada, e os lockfiles são gerados em vez de distribuídos, pelo que um clone novo não tem nenhum. Resolva-se um primeiro, ou deixe-se que a compilação o preencha:

Terminal window
aggrega pull --release release.yaml # resolve once, then build with no flag
aggrega build --release release.yaml --auto-pull # or resolve during the build

Este workspace resolve as entidades do catálogo a partir do registo predefinido que .aggrega-config.yaml nomeia. A realização do escudo executa um plugin que não vem nem no compilador nem no catálogo, o passo de configuração do gateway pipeline-step/litellm-gateway-config, que a resolução obtém do registo que default_registry nomeia, hub.aggrega.ai.

A compilação imprime, com <workspace> a representar a pasta deste exemplo:

[… omitted: a line reporting on the gateway configuration step's plugin, the resolution's summary, a notice that core/referenced-secret declares origin in both of its pillars, and a total build time, which differs per run]
Build completed: 18 files written to <workspace>/dist

A Release nomeia cada imagem que o catálogo não nomeia. A do agente é a sua própria aplicação. As da guarda e do detetor são cópias das versões em execução, espelhadas num registo sob o seu controlo. As duas imagens NemoGuard são da NVIDIA, e tem direito a obtê-las ao abrigo da sua licença; o catálogo não nomeia nenhuma delas, e release.yaml escreve cada uma com a tag change-me. A compilação encaminha qualquer string que lá esteja; substitua-as antes da implementação.

Com um assistente de IA

Um assistente de IA configurado com as ferramentas do Aggrega pode fazer o mesmo: cole-lhe este prompt.

Use apenas as ferramentas do Aggrega e não crie nenhuma pasta por iniciativa própria. Se a pasta Workspace ainda não contiver uma pasta `nemo-guardrails-nemoguard-nims`, chame uma vez a ferramenta `scaffold` com `example` definido como `nemo-guardrails-nemoguard-nims` e sem `dir`: esta escreve o exemplo numa nova pasta `nemo-guardrails-nemoguard-nims`. Em seguida, chame a ferramenta `build` com `workspace_root` definido como `nemo-guardrails-nemoguard-nims`, `release` definido como `release.yaml`, `auto_pull` definido como true e `write` definido como true. Indique-me que ficheiros a compilação escreveu; encontram-se em `nemo-guardrails-nemoguard-nims/dist/`.

A árvore renderizada

dist/helm/
├── agent-deployment.yaml
├── checkpointer-default-service.yaml
├── checkpointer-deployment.yaml
├── detector-default-service.yaml
├── detector-deployment.yaml
├── guard-default-service.yaml
├── guard-deployment.yaml
├── guard/
│ └── nemo-guardrails-config.configmap.yaml
├── jailbreak-default-service.yaml
├── jailbreak-headless-service.yaml
├── jailbreak-statefulset.yaml
├── router-default-service.yaml
├── router-deployment.yaml
├── router/
│ ├── litellm-gateway-config/
│ │ └── configmap.yaml
│ └── request-guard/
│ └── request-guard.yaml
├── safety-default-service.yaml
├── safety-headless-service.yaml
└── safety-statefulset.yaml

Não há nenhum Secret entre eles. Cada credencial é anexada como core/referenced-secret, e o Manifest associa-a a helm/k8s-existing-secret, que aponta uma carga de trabalho para um Secret que já existe no espaço de nomes e não renderiza nada próprio.

A chave, como referência

O Aggregate escreve apenas onde a chave se encontra dentro de um Secret, a chave de dados NGC_API_KEY; a Release nomeia o Secret, ngc-api-key, e o Secret com que as imagens são obtidas, ngc-registry. Em dist/helm/safety-statefulset.yaml, e da mesma forma no do classificador de jailbreak:

env:
- name: NGC_API_KEY
valueFrom:
secretKeyRef:
name: ngc-api-key
key: NGC_API_KEY
imagePullSecrets:
- name: ngc-registry

Antes da implementação, crie os dois Secrets no espaço de nomes de destino: ngc-api-key, que contém a chave sob NGC_API_KEY, e ngc-registry, um Secret de obtenção de imagens para nvcr.io que inicia sessão com a chave. A credencial a montante da guarda é nomeada da mesma forma, como o Secret upstream-provider-key que contém a chave da API do modelo sob upstream-key.

Uma Release não pode escrever a chave no seu lugar. Um bloco values: num anexo na Release é recusado quando o documento é carregado, porque o que uma Release escreve aí pertence ao operador, e os valores pertencem ao programador. Substitua o bloco infra: da ngc_api_key do componente safety por values: com um origin, e a compilação imprime, antes de mais nada:

[OPS_ERROR E0215] release.yaml
document envelope validation failed (Release, at release.yaml); 66:11: spec.components.safety.features.ngc_api_key.values: against /$defs/boundary_component: unexpected property: "values". correct the document to match its kind's schema

A única string que a Release de facto escreve, o nome de um Secret, é publicada exatamente como foi escrita: a compilação não consegue distinguir um nome de uma chave, pelo que uma chave escrita onde vai um nome apareceria no manifesto como esse nome. O grafo que aggrega build --ir-graph imprime omite-a em qualquer caso, porque origin está declarado como sensível.

O que a guarda faz

A configuração da guarda, a chave config.yaml de dist/helm/guard/nemo-guardrails-config.configmap.yaml, até aos seus prompts:

models:
- type: main
engine: openai
model: named-by-each-request
api_key_env_var: UPSTREAM_API_KEY
- type: content_safety
engine: openai
model: "llama-3.1-nemoguard-8b-content-safety"
parameters:
base_url: "http://safety-default:8000/v1"
api_key: EMPTY
passthrough: true
rails:
config:
hf_classifier:
prompt_injection:
engine: fms
model: "protectai/deberta-v3-base-prompt-injection-v2"
base_url: "http://detector-default:8000"
threshold: 0.5
blocked_labels: ["INJECTION"]
jailbreak_detection:
nim_base_url: "http://jailbreak-default:8000/v1/"
nim_server_endpoint: classify
input:
flows:
- hf classifier check input $classifier=prompt_injection
- jailbreak detection model
- content safety check input $model=content_safety

Para cada pedido de chat, a guarda executa os três rails de entrada sobre a última mensagem do utilizador, por essa ordem, e recusa o pedido quando qualquer um deles o recusa:

  • O classificador de injeção de prompt recusa quando o detetor reporta INJECTION em 0.5 ou acima.
  • O classificador de jailbreak recusa quando o classificador da NVIDIA responde que a mensagem é uma tentativa de jailbreak. A guarda envia a mensagem para a sua rota classify; não está configurada nenhuma chave, porque o serviço interno ao cluster não pede nenhuma.
  • O modelo de segurança de conteúdo recusa quando classifica a mensagem como insegura. A guarda declara-o como um modelo alcançado através da API compatível com OpenAI que o NIM serve, no endpoint e sob o nome de modelo que a aresta safety publica, e o seu prompt — o resto de config.yaml — é o que a documentação do NeMo Guardrails da NVIDIA indica para este modelo, com a lista das suas categorias de dano, lido com o parser que o NeMo Guardrails fornece para o seu veredicto.

Um pedido recusado é respondido pela própria guarda, com I’m sorry, I can’t respond to that. (Lamento, não posso responder a isso.), e nada dele chega ao modelo. A configuração da guarda contém também um flow, rails.co, que executa os rails de entrada seja o que for que o corpo de um pedido peça.

values.model em safety é o nome ao qual o NIM de segurança de conteúdo responde, que o NIM retira do seu próprio manifesto de modelo; a sua listagem de modelos, /v1/models, mostra-o no servidor em execução. A guarda envia-o com cada verificação, pelo que os dois têm de concordar.

O que não faz

  • Avalia apenas a última mensagem do utilizador. Uma tentativa colocada numa mensagem de sistema, num turno anterior ou no resultado de uma ferramenta chega ao modelo sem ser verificada, e não são avaliados nem a resposta do modelo, nem os argumentos de chamadas a ferramentas, nem as imagens.
  • Cada veredicto é o de um modelo. As três verificações deixam passar alguns pedidos nocivos ou manipuladores e recusam alguns comuns.
  • O rail de jailbreak falha em modo aberto. A NVIDIA documenta que, quando o classificador de jailbreak não está acessível, excede o tempo limite ou responde com um erro, o rail deixa passar o pedido e não reporta nada ao chamador. As outras duas verificações continuam a ser executadas. O rail de injeção de prompt recusa o pedido quando o seu detetor não está acessível.
  • Cobre apenas o tráfego que atravessa o gateway. Uma carga de trabalho que chame diretamente o endereço do modelo contorna-o. A guarda e as três verificações não autenticam nenhum chamador, pelo que os seus Services são endereços para os componentes que os chamam, não endereços a publicar.
  • Não está comprovado em execução aqui. A configuração é a que a documentação da NVIDIA descreve, compilada antecipadamente; nada neste workspace executou os contentores NemoGuard.

O que interrompe a compilação

A Recipe da guarda verifica o que os seus sockets NemoGuard contêm. Transforme safety num simples core/ai-model/nvidia-nim — o seu tipo no Aggregate e a sua linha no Manifest — e a compilação é interrompida, sem escrever nada:

[… omitted: a line reporting on the gateway configuration step's plugin, what resolving the lockfile prints, the same halt among it, and a notice that core/referenced-secret declares origin in both of its pillars]
[CATALOG_ERROR E0364] instance guard
rendering node "guard"
caused by: [CATALOG_ERROR] nemo-guardrails-config.configmap.yaml
artifact "nemo-guardrails-config.configmap.yaml" template eval
caused by: [CATALOG_ERROR] artifacts[nemo-guardrails/nemo-guardrails-config.configmap.yaml]
template "artifacts[nemo-guardrails/nemo-guardrails-config.configmap.yaml]" execute
caused by (2):
a value template failed while it ran
---
[… omitted: the template position and the template's own source]: error calling fail: the guard's content_safety socket is wired to "safety", a core/ai-model/nvidia-nim, but the content-safety rail's prompt and verdict parser are NVIDIA's for core/ai-model/nemoguard-content-safety, which another model answers in a shape the parser does not read; wire a core/ai-model/nemoguard-content-safety to content_safety

O socket jailbreak_detection aceita um core/security/nemoguard-jailbreak-detect e nada mais, da mesma forma, e cada socket aceita um único destino. As interrupções próprias do escudo são as de ai-gateway-prompt-injection-shield, que compila o mesmo gateway e a mesma guarda sem as verificações NemoGuard.

Onde o compilador não interpreta

O compilador canaliza os nomes de Service e as portas dos NIM para a configuração da guarda, e os nomes dos Secrets para os pods, como strings. Não obtém nenhuma imagem, não obtém nenhum modelo nem lê nenhuma chave, e não contacta nem a NVIDIA, nem a guarda, nem o modelo. Cada interrupção acima é declarada pelas próprias entidades do catálogo.

Adaptá-lo

  • Sem o modelo de segurança de conteúdo. Remova o componente safety e a aresta content_safety da guarda; a configuração da guarda deixa então de conter esse modelo, rail ou prompt. O classificador de jailbreak é removido da mesma forma.
  • Um modelo executado por si. Aponte-se o upstream_endpoint da guarda para o endpoint do servidor do modelo — core/ai-model/vllm publica um — e escreva-se o destino do alias como openai/<the name that server serves>.
  • GPUs maiores, ou duas. Cada componente NemoGuard aceita infra.gpu.count, e infra.gpu.runtime_class quando o cluster seleciona o seu runtime de GPU por classe.