Sanificare prompt e risposte

Questa pagina descrive in dettaglio come sanificare prompt e risposte. Model Armor offre un insieme di filtri per proteggere le tue applicazioni di AI. Model Armor controlla prompt e risposte in base ai livelli di confidenza di screening configurati.

Nota: per sanificare prompt e risposte, devi utilizzare endpoint regionali.

Prima di iniziare

Crea un modello seguendo le istruzioni riportate in Creare modelli.

Ottenere le autorizzazioni richieste

Per ottenere le autorizzazioni necessarie per sanificare prompt e risposte, chiedi all'amministratore di concederti i seguenti ruoli IAM su Model Armor:

• Model Armor User (roles/modelarmor.user)
• Visualizzatore Model Armor (roles/modelarmor.viewer)

Per saperne di più sulla concessione dei ruoli, consulta Gestisci l'accesso a progetti, cartelle e organizzazioni.

Potresti anche riuscire a ottenere le autorizzazioni richieste tramite i ruoli personalizzati o altri ruoli predefiniti.

Nel progetto contenente il modello Sensitive Data Protection, concedi il ruolo Utente DLP (roles/dlp.user) e il ruolo Lettore DLP (roles/dlp.reader) all'agente di servizio creato nell'ambito del passaggio Protezione avanzata dei dati sensibili di Crea modelli. Salta questo passaggio se il modello Sensitive Data Protection si trova nello stesso progetto del modello Model Armor.

gcloud projects add-iam-policy-binding SDP_PROJECT_ID \
    --member=serviceAccount:[e-mail] --role=roles/dlp.user

gcloud projects add-iam-policy-binding SDP_PROJECT_ID \
    --member=serviceAccount:[e-mail] --role=roles/dlp.reader

Sostituisci quanto segue:

• SDP_PROJECT_ID: l'ID del progetto a cui appartiene il modello avanzato di Sensitive Data Protection.
• PROJECT_NUMBER: il numero del progetto a cui appartiene il modello.

Abilita API

Prima di poter utilizzare Model Armor, devi abilitare l'API Model Armor.

Console

1. Abilita l'API Model Armor.

   Ruoli richiesti per abilitare le API

   Per abilitare le API, devi disporre del ruolo IAM Amministratore utilizzo dei servizi (roles/serviceusage.serviceUsageAdmin), che include l'autorizzazione serviceusage.services.enable. Scopri come concedere i ruoli.

   Abilitare l'API

2. Seleziona il progetto in cui vuoi attivare Model Armor.

gcloud

Prima di iniziare, segui questi passaggi utilizzando Google Cloud CLI con l'API Model Armor:

1. Nella console Google Cloud , attiva Cloud Shell.

   Attiva Cloud Shell

   Nella parte inferiore della console Google Cloud viene avviata una sessione di Cloud Shell e viene visualizzato un prompt della riga di comando. Cloud Shell è un ambiente shell con Google Cloud CLI già installata e con valori già impostati per il progetto corrente. L'inizializzazione della sessione può richiedere alcuni secondi.

2. Imposta l'override dell'endpoint API utilizzando gcloud CLI.

Imposta l'override dell'endpoint API utilizzando gcloud CLI

Questo passaggio è necessario solo se utilizzi gcloud CLI per abilitare l'API Model Armor. Devi impostare manualmente l'override dell'endpoint API per assicurarti che gcloud CLI indirizzi correttamente le richieste al servizio Model Armor.

Esegui questo comando per impostare l'endpoint API per il servizio Model Armor.

gcloud config set api_endpoint_overrides/modelarmor "https://modelarmor.LOCATION.rep.googleapis.com/"

Sostituisci LOCATION con la regione in cui vuoi utilizzare Model Armor.

Sanifica i prompt

Sanitizza i prompt per impedire input dannosi e contribuire a garantire che vengano inviati prompt sicuri e appropriati ai tuoi LLM.

Prompt di testo

Model Armor sanifica i prompt di testo analizzando il testo e applicando diversi filtri per identificare e mitigare potenziali minacce.

REST

Utilizza il seguente comando per sanificare un prompt di testo in Model Armor.

  curl -X POST \
      -d '{"userPromptData":{"text":"[UNSAFE TEXT]"}}' \
      -H "Content-Type: application/json" \
      -H "Authorization: Bearer $(gcloud auth print-access-token)" \
      "https://modelarmor.LOCATION.rep.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/templates/TEMPLATE_ID:sanitizeUserPrompt"

Sostituisci quanto segue:

• PROJECT_ID: l'ID del progetto per il modello.
• LOCATION: la posizione del modello.
• TEMPLATE_ID: l'ID del modello.

Il risultato è la seguente risposta. Tieni presente che MATCH_FOUND rientra nella categoria Contenuti dannosi.

  {
  "sanitizationResult": {
    "filterMatchState": "MATCH_FOUND",
    "invocationResult": "SUCCESS",
    "filterResults": {
      "csam": {
        "csamFilterFilterResult": {
          "executionState": "EXECUTION_SUCCESS",
          "matchState": "NO_MATCH_FOUND"
        }
      },
      "malicious_uris": {
        "maliciousUriFilterResult": {
          "executionState": "EXECUTION_SUCCESS",
          "matchState": "NO_MATCH_FOUND"
        }
      },
      "rai": {
        "raiFilterResult": {
          "executionState": "EXECUTION_SUCCESS",
          "matchState": "MATCH_FOUND",
          "raiFilterTypeResults": {
            "sexually_explicit": {
              "matchState": "NO_MATCH_FOUND"
            },
            "hate_speech": {
              "matchState": "NO_MATCH_FOUND"
            },
            "harassment": {
              "matchState": "NO_MATCH_FOUND"
            },
            "dangerous": {
              "matchState": "MATCH_FOUND"
            }
          }
        }
      },
      "pi_and_jailbreak": {
        "piAndJailbreakFilterResult": {
          "executionState": "EXECUTION_SUCCESS",
          "matchState": "MATCH_FOUND"
        }
      },
      "sdp": {
        "sdpFilterResult": {
          "inspectResult": {
            "executionState": "EXECUTION_SUCCESS",
            "matchState": "NO_MATCH_FOUND"
          }
        }
      }
    }
  }
  }
  

Go

Per eseguire questo codice, devi innanzitutto configurare un ambiente di sviluppo Go e installare l'SDK Go di Model Armor.

import (
	"context"
	"fmt"
	"io"

	modelarmor "cloud.google.com/go/modelarmor/apiv1"
	modelarmorpb "cloud.google.com/go/modelarmor/apiv1/modelarmorpb"
	"google.golang.org/api/option"
)

// sanitizeUserPrompt sanitizes a user prompt based on the project, location, and template settings.
//
// w io.Writer: The writer to use for logging.
// projectID string: The ID of the project.
// locationID string: The ID of the location.
// templateID string: The ID of the template.
// userPrompt string: The user prompt to sanitize.
func sanitizeUserPrompt(w io.Writer, projectID, locationID, templateID, userPrompt string) error {
	ctx := context.Background()

	//Create options for Model Armor client.
	opts := option.WithEndpoint(fmt.Sprintf("modelarmor.%s.rep.googleapis.com:443", locationID))

	// Create the Model Armor client.
	client, err := modelarmor.NewClient(ctx, opts)
	if err != nil {
		return fmt.Errorf("failed to create client for location %s: %w", locationID, err)
	}
	defer client.Close()

	// Initialize request argument(s)
	userPromptData := &modelarmorpb.DataItem{
		DataItem: &modelarmorpb.DataItem_Text{
			Text: userPrompt,
		},
	}

	// Prepare request for sanitizing user prompt.
	req := &modelarmorpb.SanitizeUserPromptRequest{
		Name:           fmt.Sprintf("projects/%s/locations/%s/templates/%s", projectID, locationID, templateID),
		UserPromptData: userPromptData,
	}

	// Sanitize the user prompt.
	response, err := client.SanitizeUserPrompt(ctx, req)
	if err != nil {
		return fmt.Errorf("failed to sanitize user prompt for template %s: %w", templateID, err)
	}

	// Sanitization Result.
	fmt.Fprintf(w, "Sanitization Result: %v\n", response)

	return nil
}

C#

Per eseguire questo codice, devi innanzitutto configurare un ambiente di sviluppo C# e installare l'SDK C# Model Armor.

using Google.Api.Gax.ResourceNames;
using Google.Cloud.ModelArmor.V1;
using Newtonsoft.Json;
using System;

namespace ModelArmor.Samples
{
    public class SanitizeUserPromptSample
    {
        public SanitizeUserPromptResponse SanitizeUserPrompt(
            string projectId = "my-project",
            string locationId = "us-central1",
            string templateId = "my-template",
            string userPrompt = "Unsafe user prompt"
        )
        {
            // Endpoint to call the Model Armor server.
            ModelArmorClientBuilder clientBuilder = new ModelArmorClientBuilder
            {
                Endpoint = $"modelarmor.{locationId}.rep.googleapis.com",
            };

            // Create the client.
            ModelArmorClient client = clientBuilder.Build();

            // Build the resource name of the template.
            TemplateName templateName = TemplateName.FromProjectLocationTemplate(projectId, locationId, templateId);

            // Prepare the request.
            SanitizeUserPromptRequest request = new SanitizeUserPromptRequest
            {
                TemplateName = templateName,
                UserPromptData = new DataItem { Text = userPrompt },
            };

            // Send the request and get the response.
            SanitizeUserPromptResponse response = client.SanitizeUserPrompt(request);

            return response;
        }
    }
}

Java

Per eseguire questo codice, devi innanzitutto configurare un ambiente di sviluppo Java e installare l'SDK Java Model Armor.

import com.google.cloud.modelarmor.v1.DataItem;
import com.google.cloud.modelarmor.v1.ModelArmorClient;
import com.google.cloud.modelarmor.v1.ModelArmorSettings;
import com.google.cloud.modelarmor.v1.SanitizeUserPromptRequest;
import com.google.cloud.modelarmor.v1.SanitizeUserPromptResponse;
import com.google.cloud.modelarmor.v1.TemplateName;
import com.google.protobuf.util.JsonFormat;
import java.io.IOException;

public class SanitizeUserPrompt {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.

    // Specify the Google Project ID.
    String projectId = "your-project-id";
    // Specify the location ID. For example, us-central1.
    String locationId = "your-location-id";
    // Specify the template ID.
    String templateId = "your-template-id";
    // Specify the user prompt.
    String userPrompt = "Unsafe user prompt";

    sanitizeUserPrompt(projectId, locationId, templateId, userPrompt);
  }

  public static SanitizeUserPromptResponse sanitizeUserPrompt(String projectId, String locationId,
      String templateId, String userPrompt) throws IOException {

    // Endpoint to call the Model Armor server.
    String apiEndpoint = String.format("modelarmor.%s.rep.googleapis.com:443", locationId);
    ModelArmorSettings modelArmorSettings = ModelArmorSettings.newBuilder()
        .setEndpoint(apiEndpoint)
        .build();

    try (ModelArmorClient client = ModelArmorClient.create(modelArmorSettings)) {
      // Build the resource name of the template.
      String templateName = TemplateName.of(projectId, locationId, templateId).toString();

      // Prepare the request.
      SanitizeUserPromptRequest request = SanitizeUserPromptRequest.newBuilder()
          .setName(templateName)
          .setUserPromptData(DataItem.newBuilder().setText(userPrompt).build())
          .build();

      SanitizeUserPromptResponse response = client.sanitizeUserPrompt(request);
      System.out.println("Result for the provided user prompt: "
          + JsonFormat.printer().print(response.getSanitizationResult()));

      return response;
    }
  }
}

Node.js

Per eseguire questo codice, devi innanzitutto configurare un ambiente di sviluppo Node.js e installare l'SDK Node.js di Model Armor.

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const projectId = process.env.PROJECT_ID || 'your-project-id';
// const locationId = process.env.LOCATION_ID || 'us-central1';
// const templateId = process.env.TEMPLATE_ID || 'template-id';
// const userPrompt = 'unsafe user prompt';
const {ModelArmorClient} = require('@google-cloud/modelarmor').v1;

const client = new ModelArmorClient({
  apiEndpoint: `modelarmor.${locationId}.rep.googleapis.com`,
});

const request = {
  name: `projects/${projectId}/locations/${locationId}/templates/${templateId}`,
  userPromptData: {
    text: userPrompt,
  },
};

const [response] = await client.sanitizeUserPrompt(request);
console.log(JSON.stringify(response, null, 2));
return response;

PHP

Per eseguire questo codice, devi innanzitutto configurare un ambiente di sviluppo PHP e installare l'SDK PHP Model Armor.

use Google\Cloud\ModelArmor\V1\Client\ModelArmorClient;
use Google\Cloud\ModelArmor\V1\SanitizeUserPromptRequest;
use Google\Cloud\ModelArmor\V1\DataItem;

/**
 * Sanitizes a user prompt using the specified template.
 *
 * @param string $projectId The ID of your Google Cloud Platform project (e.g. 'my-project').
 * @param string $locationId The ID of the location where the template is stored (e.g. 'us-central1').
 * @param string $templateId The ID of the template (e.g. 'my-template').
 * @param string $userPrompt The user prompt to sanitize (e.g. 'my-user-prompt').
 */
function sanitize_user_prompt(
    string $projectId,
    string $locationId,
    string $templateId,
    string $userPrompt
): void {
    $options = ['apiEndpoint' => "modelarmor.$locationId.rep.googleapis.com"];
    $client = new ModelArmorClient($options);

    $userPromptRequest = (new SanitizeUserPromptRequest())
        ->setName("projects/$projectId/locations/$locationId/templates/$templateId")
        ->setUserPromptData((new DataItem())->setText($userPrompt));

    $response = $client->sanitizeUserPrompt($userPromptRequest);

    printf('Result for Sanitize User Prompt: %s' . PHP_EOL, $response->serializeToJsonString());
}

Python

Per eseguire questo codice, configura un ambiente di sviluppo Python e installa l'SDK Python di Model Armor.

from google.api_core.client_options import ClientOptions
from google.cloud import modelarmor_v1

# TODO(Developer): Uncomment these variables.
# project_id = "YOUR_PROJECT_ID"
# location_id = "us-central1"
# template_id = "template_id"
# user_prompt = "Prompt entered by the user"

# Create the Model Armor client.
client = modelarmor_v1.ModelArmorClient(
    transport="rest",
    client_options=ClientOptions(
        api_endpoint=f"modelarmor.{location_id}.rep.googleapis.com"
    ),
)

# Initialize request argument(s).
user_prompt_data = modelarmor_v1.DataItem(text=user_prompt)

# Prepare request for sanitizing the defined prompt.
request = modelarmor_v1.SanitizeUserPromptRequest(
    name=f"projects/{project_id}/locations/{location_id}/templates/{template_id}",
    user_prompt_data=user_prompt_data,
)

# Sanitize the user prompt.
response = client.sanitize_user_prompt(request=request)

# Sanitization Result.
print(response)

Il risultato è la seguente risposta.

  sanitization_result {
    filter_match_state: MATCH_FOUND
    filter_results {
      key: "rai"
      value {
        rai_filter_result {
          execution_state: EXECUTION_SUCCESS
          match_state: MATCH_FOUND
          rai_filter_type_results {
            key: "dangerous"
            value {
              confidence_level: HIGH
              match_state: MATCH_FOUND
            }
          }
        }
      }
    }
    filter_results {
      key: "pi_and_jailbreak"
      value {
        pi_and_jailbreak_filter_result {
          execution_state: EXECUTION_SUCCESS
          match_state: MATCH_FOUND
          confidence_level: HIGH
        }
      }
    }
    filter_results {
      key: "malicious_uris"
      value {
        malicious_uri_filter_result {
          execution_state: EXECUTION_SUCCESS
          match_state: NO_MATCH_FOUND
        }
      }
    }
    filter_results {
      key: "csam"
      value {
        csam_filter_filter_result {
          execution_state: EXECUTION_SUCCESS
          match_state: NO_MATCH_FOUND
        }
      }
    }
    invocation_result: SUCCESS
  }
  

Best practice per la sanificazione dei prompt nell'AI conversazionale

Quando utilizzi Model Armor per sanificare gli input in un'applicazione di AI conversazionale, è importante capire cosa includere nel campo userPromptData per il metodo SanitizeUserPrompt.

• Sanitizza ogni input utente separatamente: chiama l'API SanitizeUserPrompt per ogni nuovo messaggio ricevuto dall'utente. In questo modo, ogni input dell'utente viene analizzato per rilevare potenziali minacce prima di essere elaborato dal tuo LLM. Il campo userPromptData deve contenere solo i contenuti dell'ultimo messaggio dell'utente nella conversazione corrente.

• Non includere la cronologia delle conversazioni: evita di concatenare l'intera cronologia della chat nel campo userPromptData.

• Non includere prompt di sistema: escludi il prompt di sistema dal campo userPromptData. Model Armor si concentra sul rilevamento delle minacce solo negli input forniti dall'utente.

Sanitizzare i prompt di testo con il rilevamento multilingue abilitato

Abilita il rilevamento multilingue su base per richiesta impostando il flag enableMultiLanguageDetection su true per ogni singola richiesta. Se vuoi, puoi specificare la lingua di origine per risultati più precisi.

• Se non specifichi la lingua di origine, Model Armor la rileva automaticamente per fornire il supporto multilingue.
• Se specifichi la lingua di origine, Model Armor la utilizza per valutare il prompt di testo e non esegue il rilevamento automatico della lingua.

Utilizza il seguente comando per sanificare un prompt di testo in Model Armor con il rilevamento multilingue abilitato a livello di richiesta.

curl -X POST \
    -d  '{"userPromptData":{"text":"[UNSAFE TEXT]"}, "multiLanguageDetectionMetadata": { "enableMultiLanguageDetection": true , "sourceLanguage": "jp"}}' \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer $(gcloud auth print-access-token)" \
       "https://modelarmor.LOCATION.rep.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/templates/TEMPLATE_ID:sanitizeUserPrompt"

Sostituisci quanto segue:

• PROJECT_ID: l'ID del progetto per il modello.
• LOCATION: la posizione del modello.
• TEMPLATE_ID: l'ID del modello.

Sanificare i prompt di testo in modalità flusso

I metodi di streaming di Model Armor sanificano i prompt e le risposte in tempo reale come flussi di testo, senza attendere che l'intero contenuto diventi disponibile. Questa funzionalità è particolarmente utile per le applicazioni che gestiscono payload di testo di grandi dimensioni o che richiedono interazioni a bassa latenza con i LLM.

Utilizza questi metodi per attivare lo streaming:

• StreamSanitizeUserPrompt: trasmette e sanifica il testo fornito dall'utente.
• StreamSanitizeModelResponse: trasmette e sanifica il testo generato dall'LLM.

Model Armor offre le seguenti modalità di streaming:

• Modalità bufferizzata: raccoglie tutti i blocchi trasmessi in streaming ed elabora come una singola unità.
• Modalità in tempo reale: elabora ogni blocco singolarmente man mano che viene ricevuto, fornendo un feedback continuo.

Model Armor supporta un numero illimitato di token quando si utilizza la modalità di streaming in tempo reale, mentre la modalità bufferizzata è soggetta a limiti di token.

Lo streaming funziona nel seguente modo:

1. Input suddiviso in blocchi: la tua applicazione invia il testo a Model Armor in parti più piccole (blocchi) anziché inviare l'intero corpo del testo contemporaneamente.
2. Elaborazione in tempo reale: Model Armor elabora questi blocchi man mano che arrivano e applica i filtri di sicurezza configurati nel modello.
3. Feedback continuo: a seconda della modalità (in tempo reale o bufferizzata), Model Armor restituisce i risultati per ogni blocco elaborato o dopo aver ricevuto tutti i blocchi.

Utilizza il seguente comando per sanificare un prompt di testo in streaming.

Go

Per eseguire questo codice, devi innanzitutto configurare un ambiente di sviluppo Go e installare l'SDK Go di Model Armor.

package main

import (
  "context"
  "fmt"
  "io"
  "log"

  modelarmor "cloud.google.com/go/modelarmor/apiv1beta"
  modelarmorpb "cloud.google.com/go/modelarmor/apiv1beta/modelarmorpb"
  "google.golang.org/api/option"
  "google.golang.org/protobuf/encoding/protojson"
)

func main() {
  ctx := context.Background()

  // Define variables for project, location, and template ID
  projectID := "your-project-id"
  location := "your-location-id"
  templateID := "your-template-id"

  // 1. Create the client with the custom regional endpoint.
  opts := option.WithEndpoint("modelarmor.us-central1.rep.googleapis.com:443")
  c, err := modelarmor.NewClient(ctx, opts)
  if err != nil {
    log.Fatalf("failed to create client: %v", err)
  }
  defer c.Close()

  // 2. Start the StreamSanitizeUserPrompt bidirectional stream.
  stream, err := c.StreamSanitizeUserPrompt(ctx)
  if err != nil {
    log.Fatalf("failed to initialize stream: %v", err)
  }

  // 3. Use a goroutine to send the requests.
  go func() {

    // Define the user prompt data
    userPromptData := &modelarmorpb.DataItem{
      DataItem: &modelarmorpb.DataItem_Text{
                          // Specify the user prompt.
        Text: "This is a sample user prompt",
      },
    }

    // Create the request object
    req := &modelarmorpb.SanitizeUserPromptRequest{ // Use fmt.Sprintf to construct the resource name
      Name:           fmt.Sprintf("projects/%s/locations/%s/templates/%s", projectID, location, templateID),
      UserPromptData: userPromptData,
    }

    reqs := []*modelarmorpb.SanitizeUserPromptRequest{req}

    for _, r := range reqs {
      if err := stream.Send(r); err != nil {
        log.Printf("Failed to send request: %v", err)
        return
      }
    }

    stream.CloseSend()
  }()

  // 4. Iterate over the responses from the stream.
  for {
    resp, err := stream.Recv()
    if err == io.EOF {
      break
    }
    if err != nil {
      log.Fatalf("failed to receive response: %v", err)
    }

    // Marshal the proto message to a formatted JSON string
    b, _ := protojson.MarshalOptions{
      Multiline: true,
      Indent:    "  ",
    }.Marshal(resp)

    // Results can be consumed or assigned here in production workflows
  }
}

Java

Per eseguire questo codice, devi innanzitutto configurare un ambiente di sviluppo Java e installare l'SDK Java Model Armor.

package com.example.armor;

import com.google.api.gax.rpc.BidiStream;
import com.google.cloud.modelarmor.v1beta.DataItem;
import com.google.cloud.modelarmor.v1beta.ModelArmorClient;
import com.google.cloud.modelarmor.v1beta.ModelArmorSettings;
import com.google.cloud.modelarmor.v1beta.SanitizationResult;
import com.google.cloud.modelarmor.v1beta.SanitizeUserPromptRequest;
import com.google.cloud.modelarmor.v1beta.SanitizeUserPromptResponse;
import com.google.cloud.modelarmor.v1beta.StreamingMode;
import com.google.cloud.modelarmor.v1beta.TemplateName;

import java.io.IOException;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.ExecutionException;

public class StreamSanitizeUserPrompt {

    public static void main(String[] args) {
        try {
            streamSanitizeUserPromptExample();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void streamSanitizeUserPromptExample()
            throws IOException, InterruptedException, ExecutionException {

  // Specify the Google Project ID.
String projectId = "your-project-id";
// Specify the location ID. For example, us-central1.
String locationId = "your-location-id";
// Specify the template ID.
String templateId = "your-template-id";
      String customApiEndpoint = "modelarmor.us-central1.rep.googleapis.com:443";

        List<String> promptChunks = Arrays.asList(
                "This is the first part of the user prompt. ",
                "This is the second part. ",
                "And this is the final part."
        );

        // ModelArmorSettings is now properly imported and recognized here
        try (
            ModelArmorClient modelArmorClient = ModelArmorClient.create(
                ModelArmorSettings.newBuilder()
                        .setEndpoint(customApiEndpoint)
                        .build()
            )
        ) {

            BidiStream<SanitizeUserPromptRequest, SanitizeUserPromptResponse> stream =
                    modelArmorClient.streamSanitizeUserPromptCallable().call();

            String resourceName = TemplateName.of(projectId, locationId, templateId).toString();

            // --- Send First Request ---
            SanitizeUserPromptRequest firstRequest = SanitizeUserPromptRequest.newBuilder()
                    .setName(resourceName)
                    .setUserPromptData(DataItem.newBuilder().setText(promptChunks.get(0)))
                    .setStreamingMode(StreamingMode.STREAMING_MODE_BUFFERED)
                    .build();
            stream.send(firstRequest);

            // --- Send Subsequent Requests ---
            for (int i = 1; i < promptChunks.size(); i++) {
                SanitizeUserPromptRequest subsequentRequest = SanitizeUserPromptRequest.newBuilder()
      .setName(resourceName)
                        .setUserPromptData(DataItem.newBuilder().setText(promptChunks.get(i)))
                        .build();
                stream.send(subsequentRequest);
            }

            stream.closeSend();

            // --- Receive Responses ---
            for (SanitizeUserPromptResponse response : stream) {
                if (response.hasSanitizationResult()) {
                    SanitizationResult result = response.getSanitizationResult();
// Results can be consumed or assigned here in production workflows
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Python

Per eseguire questo codice, configura un ambiente di sviluppo Python e installa l'SDK Python di Model Armor.

from google.cloud import modelarmor_v1beta

def sample_stream_sanitize_user_prompt():
    # Create a client
    client = modelarmor_v1beta.ModelArmorClient(transport="grpc", client_options = {"api_endpoint" : "modelarmor.us-central1.rep.googleapis.com"})

    # Specify the Google Project ID.
    project_id = "your-project-id"
    # Specify the location ID. For example, us-central1.
    location = "your-location-id"
    # Specify the template ID.
    template_id = "your-template-id"
    template_name = client.template_path(project_id, location, template_id)

    # Initialize request argument(s)
    user_prompt_data = modelarmor_v1beta.DataItem()
    # Specify the user prompt.
    user_prompt_data.text = "This is a sample user prompt"

    request = modelarmor_v1beta.SanitizeUserPromptRequest(
        name=template_name,
        user_prompt_data=user_prompt_data,
    )

    # This method expects an iterator which contains
    # 'modelarmor_v1beta.SanitizeUserPromptRequest' objects
    # Here we create a generator that yields a single `request` for
    # demonstrative purposes.
    requests = [request]

    def request_generator():
        for request in requests:
            yield request

    # Make the request
    stream = client.stream_sanitize_user_prompt(requests=request_generator())

    # Handle the response
    for response in stream:
        # Results can be consumed or assigned here in production workflows

sample_stream_sanitize_user_prompt()

Tieni presente quanto segue quando sanifichi un prompt o una risposta di testo in streaming:

• Per sanificare i contenuti in modo efficace, assicurati che i singoli blocchi non superino i limiti dei token.
• I metodi di streaming di Model Armor supportano solo l'input testuale, non gli allegati come immagini e file.
• Utilizza l'ID correlazione per monitorare i log di sanificazione dello streaming per una determinata richiesta.
• I metodi di streaming di Model Armor non supportano l'anonimizzazione di Sensitive Data Protection.

Prompt basati su file

Per sanificare un prompt archiviato in un file, fornisci i contenuti del file in formato base64. Model Armor non rileva automaticamente il tipo di file. Devi impostare esplicitamente il campo byteDataType per indicare il formato del file. Se il campo è mancante o non specificato, la richiesta non va a buon fine. I valori possibili di byteDataType sono PLAINTEXT_UTF8, PDF, WORD_DOCUMENT, EXCEL_DOCUMENT, POWERPOINT_DOCUMENT, TXT e CSV. La deidentificazione di Sensitive Data Protection non è supportata per i prompt basati su file.

REST

  curl -X POST \
      -d "$(jq -n \
      --arg data "$(base64 -w 0 -i sample.pdf)" \
      '{userPromptData: {byteItem: {byteDataType: "FILE_TYPE", byteData: $data}}}')" \
      -H "Content-Type: application/json" \
      -H "Authorization: Bearer $(gcloud auth print-access-token)" \
      "https://modelarmor.LOCATION.rep.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/templates/TEMPLATE_ID:sanitizeUserPrompt"

Sostituisci quanto segue:

• PROJECT_ID: l'ID del progetto a cui appartiene il modello.
• LOCATION: la posizione del modello.
• TEMPLATE_ID: l'ID del modello.
• FILE_TYPE: il formato del file di input.

Go

Per eseguire questo codice, devi innanzitutto configurare un ambiente di sviluppo Go e installare l'SDK Go di Model Armor.

import (
	"context"
	"fmt"
	"io"
	"os"

	modelarmor "cloud.google.com/go/modelarmor/apiv1"
	modelarmorpb "cloud.google.com/go/modelarmor/apiv1/modelarmorpb"
	"google.golang.org/api/option"
)

// screenPDFFile screens a PDF file.
//
// This method screens a PDF file based on the project, location, and template settings.
//
// w io.Writer: The writer to use for logging.
// projectID string: The ID of the project.
// locationID string: The ID of the location.
// templateID string: The ID of the template.
// pdfFilePath string: The path to the PDF file to be screened.
func screenPDFFile(w io.Writer, projectID, locationID, templateID, pdfFilePath string) error {
	ctx := context.Background()

	// Create options for Model Armor client.
	opts := option.WithEndpoint(fmt.Sprintf("modelarmor.%s.rep.googleapis.com:443", locationID))
	// Create the Model Armor client.
	client, err := modelarmor.NewClient(ctx, opts)
	if err != nil {
		return fmt.Errorf("failed to create client: %w", err)
	}
	defer client.Close()

	// Read PDF file content into bytes
	pdfBytes, err := os.ReadFile(pdfFilePath)
	if err != nil {
		return fmt.Errorf("failed to read PDF file: %w", err)
	}

	// Initialize request argument(s)
	userPromptData := &modelarmorpb.DataItem{
		DataItem: &modelarmorpb.DataItem_ByteItem{
			ByteItem: &modelarmorpb.ByteDataItem{
				ByteDataType: modelarmorpb.ByteDataItem_PDF,
				ByteData:     pdfBytes,
			},
		},
	}

	// Prepare request for sanitizing the defined prompt.
	req := &modelarmorpb.SanitizeUserPromptRequest{
		Name:           fmt.Sprintf("projects/%s/locations/%s/templates/%s", projectID, locationID, templateID),
		UserPromptData: userPromptData,
	}

	// Sanitize the user prompt.
	response, err := client.SanitizeUserPrompt(ctx, req)
	if err != nil {
		return fmt.Errorf("failed to sanitize PDF content for template %s: %w", templateID, err)
	}

	// Sanitization Result.
	fmt.Fprintf(w, "PDF screening sanitization result: %v\n", response)

	return nil
}

C#

Per eseguire questo codice, devi innanzitutto configurare un ambiente di sviluppo C# e installare l'SDK C# Model Armor.

using Google.Api.Gax.ResourceNames;
using Google.Cloud.ModelArmor.V1;
using Google.Protobuf;
using Newtonsoft.Json;
using System;
using System.IO;

namespace ModelArmor.Samples
{
    public class ScanPdfFileSample
    {
        public SanitizeUserPromptResponse ScanPdfFile(
            string projectId = "my-project",
            string locationId = "us-central1",
            string templateId = "my-template",
            string pdfFilePath = "path/to/file.pdf"
        )
        {
            // Endpoint to call the Model Armor server.
            ModelArmorClientBuilder clientBuilder = new ModelArmorClientBuilder
            {
                Endpoint = $"modelarmor.{locationId}.rep.googleapis.com",
            };

            // Create the client.
            ModelArmorClient client = clientBuilder.Build();

            // Build the resource name of the template.
            TemplateName templateName = TemplateName.FromProjectLocationTemplate(projectId, locationId, templateId);

            // Read the PDF file content
            byte[] fileContent = File.ReadAllBytes(pdfFilePath);

            // Prepare the request with PDF data
            SanitizeUserPromptRequest request = new SanitizeUserPromptRequest
            {
                TemplateName = templateName,
                UserPromptData = new DataItem
                {
                    ByteItem = new ByteDataItem
                    {
                        ByteDataType = ByteDataItem.Types.ByteItemType.Pdf,
                        ByteData = ByteString.CopyFrom(fileContent),
                    },
                },
            };

            // Send the request and get the response.
            SanitizeUserPromptResponse response = client.SanitizeUserPrompt(request);

            return response;
        }
    }
}

Java

Per eseguire questo codice, devi innanzitutto configurare un ambiente di sviluppo Java e installare l'SDK Java Model Armor.

import com.google.cloud.modelarmor.v1.ByteDataItem;
import com.google.cloud.modelarmor.v1.ByteDataItem.ByteItemType;
import com.google.cloud.modelarmor.v1.DataItem;
import com.google.cloud.modelarmor.v1.ModelArmorClient;
import com.google.cloud.modelarmor.v1.ModelArmorSettings;
import com.google.cloud.modelarmor.v1.SanitizeUserPromptRequest;
import com.google.cloud.modelarmor.v1.SanitizeUserPromptResponse;
import com.google.cloud.modelarmor.v1.TemplateName;
import com.google.protobuf.ByteString;
import com.google.protobuf.util.JsonFormat;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;

public class ScreenPdfFile {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.

    // Specify the Google Project ID.
    String projectId = "your-project-id";
    // Specify the location ID. For example, us-central1. 
    String locationId = "your-location-id";
    // Specify the template ID.
    String templateId = "your-template-id";
    // Specify the PDF file path. Replace with your PDF file path.
    String pdfFilePath = "src/main/resources/test_sample.pdf";

    screenPdfFile(projectId, locationId, templateId, pdfFilePath);
  }

  public static SanitizeUserPromptResponse screenPdfFile(String projectId, String locationId,
      String templateId, String pdfFilePath) throws IOException {

    // Endpoint to call the Model Armor server.
    String apiEndpoint = String.format("modelarmor.%s.rep.googleapis.com:443", locationId);
    ModelArmorSettings modelArmorSettings = ModelArmorSettings.newBuilder().setEndpoint(apiEndpoint)
        .build();

    try (ModelArmorClient client = ModelArmorClient.create(modelArmorSettings)) {
      // Build the resource name of the template.
      String name = TemplateName.of(projectId, locationId, templateId).toString();

      // Read the PDF file content and encode it to Base64.
      byte[] fileContent = Files.readAllBytes(Paths.get(pdfFilePath));

      // Prepare the request.
      DataItem userPromptData = DataItem.newBuilder()
          .setByteItem(
            ByteDataItem.newBuilder()
              .setByteDataType(ByteItemType.PDF)
              .setByteData(ByteString.copyFrom(fileContent))
              .build())
          .build();

      SanitizeUserPromptRequest request =
          SanitizeUserPromptRequest.newBuilder()
              .setName(name)
              .setUserPromptData(userPromptData)
              .build();

      // Send the request and get the response.
      SanitizeUserPromptResponse response = client.sanitizeUserPrompt(request);

      // Print the sanitization result.
      System.out.println("Result for the provided PDF file: "
          + JsonFormat.printer().print(response.getSanitizationResult()));

      return response;
    }
  }
}

Node.js

Per eseguire questo codice, devi innanzitutto configurare un ambiente di sviluppo Node.js e installare l'SDK Node.js di Model Armor.

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const projectId = process.env.PROJECT_ID || 'your-project-id';
// const locationId = process.env.LOCATION_ID || 'us-central1';
// const templateId = process.env.TEMPLATE_ID || 'template-id';
// const pdfContentFilename = 'path/to/file.pdf';

// Imports the Model Armor library
const modelarmor = require('@google-cloud/modelarmor');
const {ModelArmorClient} = modelarmor.v1;
const {protos} = modelarmor;
const ByteItemType =
  protos.google.cloud.modelarmor.v1.ByteDataItem.ByteItemType;

const fs = require('fs');

const pdfContent = fs.readFileSync(pdfContentFilename);
const pdfContentBase64 = pdfContent.toString('base64');

const client = new ModelArmorClient({
  apiEndpoint: `modelarmor.${locationId}.rep.googleapis.com`,
});

const request = {
  name: `projects/${projectId}/locations/${locationId}/templates/${templateId}`,
  userPromptData: {
    byteItem: {
      byteDataType: ByteItemType.PDF,
      byteData: pdfContentBase64,
    },
  },
};

const [response] = await client.sanitizeUserPrompt(request);
console.log(JSON.stringify(response, null, 2));
return response;

PHP

Per eseguire questo codice, devi innanzitutto configurare un ambiente di sviluppo PHP e installare l'SDK PHP Model Armor.

use Google\Cloud\ModelArmor\V1\Client\ModelArmorClient;
use Google\Cloud\ModelArmor\V1\SanitizeUserPromptRequest;
use Google\Cloud\ModelArmor\V1\ByteDataItem;
use Google\Cloud\ModelArmor\V1\ByteDataItem\ByteItemType;
use Google\Cloud\ModelArmor\V1\DataItem;

/**
 * Screens a PDF file using the ModelArmor service.
 *
 * @param string $projectId The Google Cloud project ID (e.g. 'my-project').
 * @param string $locationId The location ID of the ModelArmor service (e.g. 'us-central1').
 * @param string $templateId The ID of the template to use for the screener (e.g. 'my-template').
 * @param string $filePath The path to the PDF file to screen (e.g. 'path/to/file.pdf').
 */
function screen_pdf_file(
    string $projectId,
    string $locationId,
    string $templateId,
    string $filePath
): void {
    $options = ['apiEndpoint' => "modelarmor.$locationId.rep.googleapis.com"];
    $client = new ModelArmorClient($options);

    // Read the file content and encode it in base64.
    $pdfContent = file_get_contents($filePath);
    $pdfContentBase64 = base64_encode($pdfContent);

    $userPromptRequest = (new SanitizeUserPromptRequest())
        ->setName("projects/$projectId/locations/$locationId/templates/$templateId")
        ->setUserPromptData((new DataItem())
            ->setByteItem((new ByteDataItem())->setByteData($pdfContentBase64)
                ->setByteDataType(ByteItemType::PDF)));

    $response = $client->sanitizeUserPrompt($userPromptRequest);

    printf('Result for Screen PDF File: %s' . PHP_EOL, $response->serializeToJsonString());
}

Python

Per eseguire questo codice, configura un ambiente di sviluppo Python e installa l'SDK Python di Model Armor.

import base64
from google.api_core.client_options import ClientOptions
from google.cloud import modelarmor_v1

# TODO(Developer): Uncomment these variables.
# project_id = "YOUR_PROJECT_ID"
# location_id = "us-central1"
# template_id = "template_id"
# pdf_content_filename = "path/to/file.pdf"

# Encode the PDF file into base64
with open(pdf_content_filename, "rb") as f:
    pdf_content_base64 = base64.b64encode(f.read())

# Create the Model Armor client.
client = modelarmor_v1.ModelArmorClient(
    transport="rest",
    client_options=ClientOptions(
        api_endpoint=f"modelarmor.{location_id}.rep.googleapis.com"
    ),
)

# Initialize request argument(s).
user_prompt_data = modelarmor_v1.DataItem(
    byte_item=modelarmor_v1.ByteDataItem(
        byte_data_type=modelarmor_v1.ByteDataItem.ByteItemType.PDF,
        byte_data=pdf_content_base64,
    )
)

request = modelarmor_v1.SanitizeUserPromptRequest(
    name=f"projects/{project_id}/locations/{location_id}/templates/{template_id}",
    user_prompt_data=user_prompt_data,
)

# Sanitize the user prompt.
response = client.sanitize_user_prompt(request=request)

# Sanitization Result.
print(response)

Configurazione di base di Sensitive Data Protection

Model Armor si integra con Sensitive Data Protection per contribuire a prevenire l'esposizione accidentale di informazioni private. Crea un modello con le impostazioni di base di Sensitive Data Protection abilitate. La protezione dei dati sensibili di base ti aiuta a eseguire lo screening di un insieme fisso di infoType di Sensitive Data Protection.

I seguenti infoType di Sensitive Data Protection vengono analizzati nel prompt per tutte le regioni:

• CREDIT_CARD_NUMBER: Il numero di una carta di credito può contenere da 12 a 19 cifre. Si utilizzano per eseguire transazioni di pagamento a livello globale.
• FINANCIAL_ACCOUNT_NUMBER: un numero che si riferisce a un conto finanziario specifico, ad esempio un numero di conto bancario o un numero di conto pensionistico.
• GCP_CREDENTIALS: Google Cloud credenziali del service account. Credenziali che possono essere utilizzate per l'autenticazione con {api_client_lib_name} e service account.
• GCP_API_KEY: Google Cloud chiave API. Una stringa criptata utilizzata quando vengono chiamate API Google Cloud che non richiedono l'accesso a dati utente privati.
• PASSWORD: Cancella le password in chiaro nelle configurazioni, nel codice e in altri contenuti testuali.

I seguenti infoType di Sensitive Data Protection aggiuntivi vengono scansionati nel prompt per le regioni con sede negli Stati Uniti:

• US_SOCIAL_SECURITY_NUMBER: Il codice SSN (States Social Security) statunitense è un numero di previdenza sociale di 9 cifre rilasciato a cittadini statunitensi, residenti permanenti e residenti temporanei. Questo rilevatore non ricercherà la corrispondenza con numeri composti da soli zeri in uno dei gruppi di cifre (ossia 000-##-####, ###-00-#### o ###-##-0000), con numeri contenenti 666 nel primo gruppo di cifre o con numeri la cui cifra iniziale è 9.
• US_INDIVIDUAL_TAXPAYER_IDENTIFICATION_NUMBER: un numero di identificazione del contribuente individuale (ITIN) degli Stati Uniti è un tipo di numero di identificazione fiscale (TIN) emesso dall'Internal Revenue Service (IRS). Si tratta di un numero utilizzato a fini fiscali disponibile solo per alcuni stranieri residenti e non residenti, i loro coniugi e familiari a carico che non possono ottenere un numero di previdenza sociale (SSN).

Ecco un esempio di configurazione di base di Sensitive Data Protection:

gcloud

gcloud model-armor templates create TEMPLATE_ID \
    --location=LOCATION \
    --project=PROJECT_ID \
    --basic-config-filter-enforcement=enabled

Sostituisci quanto segue:

• TEMPLATE_ID: l'ID del modello.
• LOCATION: la posizione del modello.

REST

export FILTER_CONFIG_SDP_BASIC='{
  "filterConfig": {
    "sdpSettings": {
      "basicConfig": {
        "filterEnforcement": "ENABLED"
      }
    }
  }
}'

curl -X PATCH \
    -d "$FILTER_CONFIG_SDP_BASIC" \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer $(gcloud auth print-access-token)" \
    "https://modelarmor.LOCATION.rep.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/templates/TEMPLATE_ID?updateMask=filterConfig.sdpSettings.basicConfig.filterEnforcement"

Sostituisci quanto segue:

• PROJECT_ID: l'ID del progetto a cui appartiene il modello.
• LOCATION: la posizione del modello.
• TEMPLATE_ID: l'ID del modello.

Go

Per eseguire questo codice, devi innanzitutto configurare un ambiente di sviluppo Go e installare l'SDK Go di Model Armor.

import (
	"context"
	"fmt"
	"io"

	modelarmor "cloud.google.com/go/modelarmor/apiv1"
	modelarmorpb "cloud.google.com/go/modelarmor/apiv1/modelarmorpb"
	"google.golang.org/api/option"
)

// createModelArmorTemplateWithBasicSDP method creates a new Model Armor template with basic SDP settings.
//
// w io.Writer: The writer to use for logging.
// projectID string: The ID of the Google Cloud project.
// locationID string: The ID of the Google Cloud location.
// templateID string: The ID of the template to create.
func createModelArmorTemplateWithBasicSDP(w io.Writer, projectID, locationID, templateID string) error {
	ctx := context.Background()

	// Create options for Model Armor client.
	opts := option.WithEndpoint(fmt.Sprintf("modelarmor.%s.rep.googleapis.com:443", locationID))
	// Create the Model Armor client.
	client, err := modelarmor.NewClient(ctx, opts)
	if err != nil {
		return fmt.Errorf("failed to create client for project %s, location %s: %w", projectID, locationID, err)
	}
	defer client.Close()

	parent := fmt.Sprintf("projects/%s/locations/%s", projectID, locationID)

	// Build the Model Armor template with your preferred filters.
	// For more details on filters, please refer to the following doc:
	// [https://cloud.google.com/security-command-center/docs/key-concepts-model-armor#ma-filters](https://cloud.google.com/security-command-center/docs/key-concepts-model-armor#ma-filters)
	template := &modelarmorpb.Template{
		FilterConfig: &modelarmorpb.FilterConfig{
			RaiSettings: &modelarmorpb.RaiFilterSettings{
				RaiFilters: []*modelarmorpb.RaiFilterSettings_RaiFilter{
					{
						FilterType:      modelarmorpb.RaiFilterType_DANGEROUS,
						ConfidenceLevel: modelarmorpb.DetectionConfidenceLevel_HIGH,
					},
					{
						FilterType:      modelarmorpb.RaiFilterType_HARASSMENT,
						ConfidenceLevel: modelarmorpb.DetectionConfidenceLevel_MEDIUM_AND_ABOVE,
					},
					{
						FilterType:      modelarmorpb.RaiFilterType_HATE_SPEECH,
						ConfidenceLevel: modelarmorpb.DetectionConfidenceLevel_HIGH,
					},
					{
						FilterType:      modelarmorpb.RaiFilterType_SEXUALLY_EXPLICIT,
						ConfidenceLevel: modelarmorpb.DetectionConfidenceLevel_HIGH,
					},
				},
			},
			SdpSettings: &modelarmorpb.SdpFilterSettings{
				SdpConfiguration: &modelarmorpb.SdpFilterSettings_BasicConfig{
					BasicConfig: &modelarmorpb.SdpBasicConfig{
						FilterEnforcement: modelarmorpb.SdpBasicConfig_ENABLED,
					},
				},
			},
		},
	}

	// Prepare the request for creating the template.
	req := &modelarmorpb.CreateTemplateRequest{
		Parent:     parent,
		TemplateId: templateID,
		Template:   template,
	}

	// Create the template.
	response, err := client.CreateTemplate(ctx, req)
	if err != nil {
		return fmt.Errorf("failed to create template: %w", err)
	}

	// Print the new template name using fmt.Fprintf with the io.Writer.
	fmt.Fprintf(w, "Created Template with basic SDP: %s\n", response.Name)

	return err
}

C#

Per eseguire questo codice, devi innanzitutto configurare un ambiente di sviluppo C# e installare l'SDK C# Model Armor.

using Google.Api.Gax.ResourceNames;
using Google.Cloud.ModelArmor.V1;
using System;

public class CreateTemplateWithBasicSdpSample
{
    public Template CreateTemplateWithBasicSdp(
        string projectId = "my-project",
        string locationId = "us-central1",
        string templateId = "my-template")
    {
        ModelArmorClient client = new ModelArmorClientBuilder
        {
            Endpoint = $"modelarmor.{locationId}.rep.googleapis.com",
        }.Build();

        LocationName parent = LocationName.FromProjectLocation(projectId, locationId);

        // Build the Model Armor template with Basic SDP Filter.
        // For more details on filters, please refer to:
        // https://cloud.google.com/security-command-center/docs/key-concepts-model-armor#ma-filters
        SdpBasicConfig basicSdpConfig = new SdpBasicConfig
        {
            FilterEnforcement = SdpBasicConfig.Types.SdpBasicConfigEnforcement.Enabled,
        };

        SdpFilterSettings sdpSettings = new SdpFilterSettings { BasicConfig = basicSdpConfig };

        FilterConfig filterConfig = new FilterConfig { SdpSettings = sdpSettings };

        CreateTemplateRequest request = new CreateTemplateRequest
        {
            ParentAsLocationName = parent,
            TemplateId = templateId,
            Template = new Template { FilterConfig = filterConfig },
        };

        Template createdTemplate = client.CreateTemplate(request);

        Console.WriteLine($"Created template with Basic SDP filter: {createdTemplate.Name}");

        return createdTemplate;
    }
}

Java

Per eseguire questo codice, devi innanzitutto configurare un ambiente di sviluppo Java e installare l'SDK Java Model Armor.

import com.google.cloud.modelarmor.v1.CreateTemplateRequest;
import com.google.cloud.modelarmor.v1.FilterConfig;
import com.google.cloud.modelarmor.v1.LocationName;
import com.google.cloud.modelarmor.v1.ModelArmorClient;
import com.google.cloud.modelarmor.v1.ModelArmorSettings;
import com.google.cloud.modelarmor.v1.SdpBasicConfig;
import com.google.cloud.modelarmor.v1.SdpBasicConfig.SdpBasicConfigEnforcement;
import com.google.cloud.modelarmor.v1.SdpFilterSettings;
import com.google.cloud.modelarmor.v1.Template;
import java.io.IOException;

public class CreateTemplateWithBasicSdp {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.

    // Specify the Google Project ID.
    String projectId = "your-project-id";
    // Specify the location ID. For example, us-central1. 
    String locationId = "your-location-id";
    // Specify the template ID.
    String templateId = "your-template-id";

    createTemplateWithBasicSdp(projectId, locationId, templateId);
  }

  public static Template createTemplateWithBasicSdp(
      String projectId, String locationId, String templateId) throws IOException {

    // Construct the API endpoint URL.
    String apiEndpoint = String.format("modelarmor.%s.rep.googleapis.com:443", locationId);
    ModelArmorSettings modelArmorSettings = ModelArmorSettings.newBuilder().setEndpoint(apiEndpoint)
        .build();

    // Initialize the client that will be used to send requests. This client
    // only needs to be created once, and can be reused for multiple requests.
    try (ModelArmorClient client = ModelArmorClient.create(modelArmorSettings)) {
      String parent = LocationName.of(projectId, locationId).toString();

      // Build the Model Armor template with your preferred filters.
      // For more details on filters, please refer to the following doc:
      // https://cloud.google.com/security-command-center/docs/key-concepts-model-armor#ma-filters

      // Configure Basic SDP Filter.
      SdpBasicConfig basicSdpConfig = SdpBasicConfig.newBuilder()
          .setFilterEnforcement(SdpBasicConfigEnforcement.ENABLED)
          .build();

      SdpFilterSettings sdpSettings = SdpFilterSettings.newBuilder()
          .setBasicConfig(basicSdpConfig)
          .build();

      FilterConfig modelArmorFilter = FilterConfig.newBuilder()
          .setSdpSettings(sdpSettings)
          .build();

      Template template = Template.newBuilder()
          .setFilterConfig(modelArmorFilter)
          .build();

      CreateTemplateRequest request = CreateTemplateRequest.newBuilder()
          .setParent(parent)
          .setTemplateId(templateId)
          .setTemplate(template)
          .build();

      Template createdTemplate = client.createTemplate(request);
      System.out.println("Created template with basic SDP filter: " + createdTemplate.getName());

      return createdTemplate;
    }
  }
}

Node.js

Per eseguire questo codice, devi innanzitutto configurare un ambiente di sviluppo Node.js e installare l'SDK Node.js di Model Armor.

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const projectId = 'your-project-id';
// const locationId = 'us-central1';
// const templateId = 'template-id';

const parent = `projects/${projectId}/locations/${locationId}`;

// Imports the Model Armor library
const modelarmor = require('@google-cloud/modelarmor');
const {ModelArmorClient} = modelarmor.v1;
const {protos} = modelarmor;

const RaiFilterType = protos.google.cloud.modelarmor.v1.RaiFilterType;
const DetectionConfidenceLevel =
  protos.google.cloud.modelarmor.v1.DetectionConfidenceLevel;
const SdpBasicConfigEnforcement =
  protos.google.cloud.modelarmor.v1.SdpBasicConfig.SdpBasicConfigEnforcement;

// Instantiates a client
const client = new ModelArmorClient({
  apiEndpoint: `modelarmor.${locationId}.rep.googleapis.com`,
});

// Configuration for the template with basic SDP settings
const templateConfig = {
  filterConfig: {
    raiSettings: {
      raiFilters: [
        {
          filterType: RaiFilterType.DANGEROUS,
          confidenceLevel: DetectionConfidenceLevel.HIGH,
        },
        {
          filterType: RaiFilterType.HARASSMENT,
          confidenceLevel: DetectionConfidenceLevel.MEDIUM_AND_ABOVE,
        },
        {
          filterType: RaiFilterType.HATE_SPEECH,
          confidenceLevel: DetectionConfidenceLevel.HIGH,
        },
        {
          filterType: RaiFilterType.SEXUALLY_EXPLICIT,
          confidenceLevel: DetectionConfidenceLevel.HIGH,
        },
      ],
    },
    sdpSettings: {
      basicConfig: {
        filterEnforcement: SdpBasicConfigEnforcement.ENABLED,
      },
    },
  },
};

// Construct request
const request = {
  parent,
  templateId,
  template: templateConfig,
};

const [response] = await client.createTemplate(request);
return response;

PHP

Per eseguire questo codice, devi innanzitutto configurare un ambiente di sviluppo PHP e installare l'SDK PHP Model Armor.

use Google\Cloud\ModelArmor\V1\Client\ModelArmorClient;
use Google\Cloud\ModelArmor\V1\SdpBasicConfig\SdpBasicConfigEnforcement;
use Google\Cloud\ModelArmor\V1\SdpBasicConfig;
use Google\Cloud\ModelArmor\V1\SdpFilterSettings;
use Google\Cloud\ModelArmor\V1\FilterConfig;
use Google\Cloud\ModelArmor\V1\CreateTemplateRequest;
use Google\Cloud\ModelArmor\V1\Template;

/**
 * Create a Model Armor template with Basic SDP Filter.
 *
 * @param string $projectId The ID of the project (e.g. 'my-project').
 * @param string $locationId The ID of the location (e.g. 'us-central1').
 * @param string $templateId The ID of the template (e.g. 'my-template').
 */
function create_template_with_basic_sdp(string $projectId, string $locationId, string $templateId): void
{
    $options = ['apiEndpoint' => "modelarmor.$locationId.rep.googleapis.com"];
    $client = new ModelArmorClient($options);
    $parent = $client->locationName($projectId, $locationId);

    // Build the Model Armor template with your preferred filters.
    // For more details on filters, please refer to the following doc:
    // https://cloud.google.com/security-command-center/docs/key-concepts-model-armor#ma-filters

    // Configure Basic SDP Filter.
    $sdpBasicConfig = (new SdpBasicConfig())->setFilterEnforcement(SdpBasicConfigEnforcement::ENABLED);
    $sdpSettings = (new SdpFilterSettings())->setBasicConfig($sdpBasicConfig);

    $templateFilterConfig = (new FilterConfig())
        ->setSdpSettings($sdpSettings);

    $template = (new Template())->setFilterConfig($templateFilterConfig);

    $request = (new CreateTemplateRequest())
        ->setParent($parent)
        ->setTemplateId($templateId)
        ->setTemplate($template);

    $response = $client->createTemplate($request);

    printf('Template created: %s' . PHP_EOL, $response->getName());
}

Python

Per eseguire questo codice, configura un ambiente di sviluppo Python e installa l'SDK Python di Model Armor.

from google.api_core.client_options import ClientOptions
from google.cloud import modelarmor_v1

# TODO(Developer): Uncomment these variables.
# project_id = "YOUR_PROJECT_ID"
# location_id = "us-central1"
# template_id = "template_id"

# Create the Model Armor client.
client = modelarmor_v1.ModelArmorClient(
    client_options=ClientOptions(
        api_endpoint=f"modelarmor.{location_id}.rep.googleapis.com"
    )
)

parent = f"projects/{project_id}/locations/{location_id}"

# Build the Model Armor template with your preferred filters.
# For more details on filters, please refer to the following doc:
# https://cloud.google.com/security-command-center/docs/key-concepts-model-armor#ma-filters
template = modelarmor_v1.Template(
    filter_config=modelarmor_v1.FilterConfig(
        rai_settings=modelarmor_v1.RaiFilterSettings(
            rai_filters=[
                modelarmor_v1.RaiFilterSettings.RaiFilter(
                    filter_type=modelarmor_v1.RaiFilterType.DANGEROUS,
                    confidence_level=modelarmor_v1.DetectionConfidenceLevel.HIGH,
                ),
                modelarmor_v1.RaiFilterSettings.RaiFilter(
                    filter_type=modelarmor_v1.RaiFilterType.HARASSMENT,
                    confidence_level=modelarmor_v1.DetectionConfidenceLevel.MEDIUM_AND_ABOVE,
                ),
                modelarmor_v1.RaiFilterSettings.RaiFilter(
                    filter_type=modelarmor_v1.RaiFilterType.HATE_SPEECH,
                    confidence_level=modelarmor_v1.DetectionConfidenceLevel.HIGH,
                ),
                modelarmor_v1.RaiFilterSettings.RaiFilter(
                    filter_type=modelarmor_v1.RaiFilterType.SEXUALLY_EXPLICIT,
                    confidence_level=modelarmor_v1.DetectionConfidenceLevel.HIGH,
                ),
            ]
        ),
        sdp_settings=modelarmor_v1.SdpFilterSettings(
            basic_config=modelarmor_v1.SdpBasicConfig(
                filter_enforcement=modelarmor_v1.SdpBasicConfig.SdpBasicConfigEnforcement.ENABLED
            )
        ),
    ),
)

# Prepare the request for creating the template.
create_template = modelarmor_v1.CreateTemplateRequest(
    parent=parent, template_id=template_id, template=template
)

# Create the template.
response = client.create_template(request=create_template)

# Print the new template name.
print(f"Created template: {response.name}")

Utilizza il modello creato per esaminare i prompt. Ecco un esempio:

curl -X POST \
    -d '{"userPromptData":{"text":"can you remember my ITIN : ###-##-####"}}' \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer $(gcloud auth print-access-token)" \
    "https://modelarmor.LOCATION.rep.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/templates/TEMPLATE_ID:sanitizeUserPrompt"

Sostituisci quanto segue:

• PROJECT_ID: l'ID del progetto a cui appartiene il modello.
• LOCATION: la posizione del modello.
• TEMPLATE_ID: l'ID del modello.

Questo esempio restituisce la seguente risposta:

{
  "sanitizationResult": {
      "filterMatchState": "MATCH_FOUND",
      "invocationResult": "SUCCESS",
      "filterResults": [
        {
          "csamFilterFilterResult": {
            "executionState": "EXECUTION_SUCCESS",
            "matchState": "NO_MATCH_FOUND"
          }
        },
        {
      "sdpFilterResult": {
        "inspectResult": {
          "executionState": "EXECUTION_SUCCESS",
          "matchState": "MATCH_FOUND",
          "findings": [
            {
              "infoType": "US_INDIVIDUAL_TAXPAYER_IDENTIFICATION_NUMBER",
              "likelihood": "LIKELY",
              "location": {
                "byteRange": {
                  "start": "26",
                  "end": "37"
                },
                "codepointRange": {
                  "start": "26",
                  "end": "37"
                }
              }
            }
          ]
        }
       }
      }
    ]
  }
}

Configurazione avanzata di Sensitive Data Protection

Model Armor filtra i prompt e le risposte del modello LLM utilizzando l'impostazione di configurazione avanzata di Sensitive Data Protection. In questo modo puoi utilizzare le funzionalità di Sensitive Data Protection oltre agli infoType offerti nell'impostazione di base di Sensitive Data Protection.

Per utilizzare il filtro avanzato Sensitive Data Protection in Model Armor, i modelli Sensitive Data Protection devono trovarsi nella stessa posizione cloud del modello Model Armor.

gcloud

gcloud model-armor templates create TEMPLATE_ID \
    --location=LOCATION \
    --advanced-config-inspect-template="path/to/template" \

Sostituisci quanto segue:

• TEMPLATE_ID: l'ID del modello.
• LOCATION: la posizione del modello.

REST

  export FILTER_CONFIG_SDP_ADV='{
    "filterConfig": {
      "sdpSettings": {
        "advancedConfig": {
          "deidentifyTemplate": "projects/PROJECT_ID/locations/LOCATION/deidentifyTemplates/deidentify-ip-address",
          "inspectTemplate": "projects/PROJECT_ID/locations/LOCATION/inspectTemplates/inspect-ip-address"
        }
      }
    }
  }'

 curl -X POST \
     -d "$FILTER_CONFIG_SDP_ADV" \
     -H "Content-Type: application/json" \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
       "https://modelarmor.LOCATION.rep.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/templates/TEMPLATE_ID?updateMask=filterConfig.sdpSettings.advancedConfig"

Sostituisci quanto segue:

• PROJECT_ID: l'ID del progetto a cui appartiene il modello.
• LOCATION: la posizione del modello.
• TEMPLATE_ID: l'ID del modello.

Questo esempio restituisce la seguente risposta:

{
  "name": "projects/PROJECT_ID/locations/LOCATION/templates/all-filters-test",
  "createTime": "2024-12-16T17:08:19.626693819Z",
  "updateTime": "2024-12-16T17:08:19.626693819Z",
   "filterConfig": {
      "sdpSettings": {
        "advancedConfig": {
          "deidentifyTemplate":  "projects/PROJECT_ID/locations/LOCATION/deidentifyTemplates/deidentify-ip-address",
          "inspectTemplate": "projects/PROJECT_ID/locations/LOCATION/inspectTemplates/inspect-ip-address"
        }
      }
    }
}

C#

Per eseguire questo codice, devi innanzitutto configurare un ambiente di sviluppo C# e installare l'SDK C# Model Armor.

using Google.Api.Gax.ResourceNames;
using Google.Cloud.ModelArmor.V1;
using System;

public class CreateTemplateWithAdvancedSdpSample
{
    public Template CreateTemplateWithAdvancedSdp(
        string projectId = "my-project",
        string locationId = "us-central1",
        string templateId = "my-template",
        string inspectTemplateName =
            "projects/my_project/locations/us-central1/inspectTemplates/inspect_template_id",
        string deidentifyTemplateName =
            "projects/my_project/locations/us-central1/deidentifyTemplates/de-identify_template_id"
    )
    {
        ModelArmorClient client = new ModelArmorClientBuilder
        {
            Endpoint = $"modelarmor.{locationId}.rep.googleapis.com",
        }.Build();

        LocationName parent = LocationName.FromProjectLocation(projectId, locationId);

        // Build the Model Armor template with Advanced SDP Filter.

        // Note: If you specify only Inspect template, Model Armor reports the filter matches if
        // sensitive data is detected. If you specify Inspect template and De-identify template, Model
        // Armor returns the de-identified sensitive data and sanitized version of prompts or
        // responses in the deidentifyResult.data.text field of the finding.
        SdpAdvancedConfig advancedSdpConfig = new SdpAdvancedConfig
        {
            InspectTemplate = inspectTemplateName,
            DeidentifyTemplate = deidentifyTemplateName,
        };

        SdpFilterSettings sdpSettings = new SdpFilterSettings
        {
            AdvancedConfig = advancedSdpConfig,
        };

        FilterConfig filterConfig = new FilterConfig { SdpSettings = sdpSettings };
        Template template = new Template { FilterConfig = filterConfig };

        CreateTemplateRequest request = new CreateTemplateRequest
        {
            ParentAsLocationName = parent,
            TemplateId = templateId,
            Template = template,
        };

        Template createdTemplate = client.CreateTemplate(request);

        Console.WriteLine($"Created template with Advanced SDP filter: {createdTemplate.Name}");

        return createdTemplate;
    }
}

Go

Per eseguire questo codice, devi innanzitutto configurare un ambiente di sviluppo Go e installare l'SDK Go di Model Armor.

import (
	"context"
	"fmt"
	"io"

	modelarmor "cloud.google.com/go/modelarmor/apiv1"
	modelarmorpb "cloud.google.com/go/modelarmor/apiv1/modelarmorpb"
	"google.golang.org/api/option"
)

// createModelArmorTemplateWithAdvancedSDP method creates a
// new Model Armor template with advanced SDP settings,
// including inspect and deidentify templates.
//
// w io.Writer: The writer to use for logging.
// projectID string: The ID of the Google Cloud project.
// locationID string: The ID of the Google Cloud location.
// templateID string: The ID of the template to create.
// inspectTemplate string: The ID of the inspect template to use.
// deidentifyTemplate string: The ID of the deidentify template to use.
func createModelArmorTemplateWithAdvancedSDP(w io.Writer, projectID, locationID, templateID, inspectTemplate, deidentifyTemplate string) error {
	ctx := context.Background()

	// Create options for Model Armor client.
	opts := option.WithEndpoint(fmt.Sprintf("modelarmor.%s.rep.googleapis.com:443", locationID))
	// Create the Model Armor client.
	client, err := modelarmor.NewClient(ctx, opts)
	if err != nil {
		return fmt.Errorf("failed to create client for project %s, location %s: %w", projectID, locationID, err)
	}
	defer client.Close()

	parent := fmt.Sprintf("projects/%s/locations/%s", projectID, locationID)

	// Build the Model Armor template with your preferred filters.
	template := &modelarmorpb.Template{
		FilterConfig: &modelarmorpb.FilterConfig{
			RaiSettings: &modelarmorpb.RaiFilterSettings{
				RaiFilters: []*modelarmorpb.RaiFilterSettings_RaiFilter{
					{
						FilterType:      modelarmorpb.RaiFilterType_DANGEROUS,
						ConfidenceLevel: modelarmorpb.DetectionConfidenceLevel_HIGH,
					},
					{
						FilterType:      modelarmorpb.RaiFilterType_HARASSMENT,
						ConfidenceLevel: modelarmorpb.DetectionConfidenceLevel_MEDIUM_AND_ABOVE,
					},
					{
						FilterType:      modelarmorpb.RaiFilterType_HATE_SPEECH,
						ConfidenceLevel: modelarmorpb.DetectionConfidenceLevel_HIGH,
					},
					{
						FilterType:      modelarmorpb.RaiFilterType_SEXUALLY_EXPLICIT,
						ConfidenceLevel: modelarmorpb.DetectionConfidenceLevel_HIGH,
					},
				},
			},
			SdpSettings: &modelarmorpb.SdpFilterSettings{
				SdpConfiguration: &modelarmorpb.SdpFilterSettings_AdvancedConfig{
					AdvancedConfig: &modelarmorpb.SdpAdvancedConfig{
						InspectTemplate:    inspectTemplate,
						DeidentifyTemplate: deidentifyTemplate,
					},
				},
			},
		},
	}

	// Prepare the request for creating the template.
	req := &modelarmorpb.CreateTemplateRequest{
		Parent:     parent,
		TemplateId: templateID,
		Template:   template,
	}

	// Create the template.
	response, err := client.CreateTemplate(ctx, req)
	if err != nil {
		return fmt.Errorf("failed to create template: %w", err)
	}

	// Print the new template name using fmt.Fprint with the io.Writer.
	fmt.Fprintf(w, "Created Template with advanced SDP: %s\n", response.Name)

	return err
}

Java

Per eseguire questo codice, devi innanzitutto configurare un ambiente di sviluppo Java e installare l'SDK Java Model Armor.

import com.google.cloud.modelarmor.v1.CreateTemplateRequest;
import com.google.cloud.modelarmor.v1.FilterConfig;
import com.google.cloud.modelarmor.v1.LocationName;
import com.google.cloud.modelarmor.v1.ModelArmorClient;
import com.google.cloud.modelarmor.v1.ModelArmorSettings;
import com.google.cloud.modelarmor.v1.SdpAdvancedConfig;
import com.google.cloud.modelarmor.v1.SdpFilterSettings;
import com.google.cloud.modelarmor.v1.Template;
import com.google.privacy.dlp.v2.DeidentifyTemplateName;
import com.google.privacy.dlp.v2.InspectTemplateName;
import java.io.IOException;

public class CreateTemplateWithAdvancedSdp {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.

    // Specify the Google Project ID.
    String projectId = "your-project-id";
    // Specify the location ID. For example, us-central1.
    String locationId = "your-location-id";
    // Specify the template ID.
    String templateId = "your-template-id";
    // Specify the Inspect template ID.
    String inspectTemplateId = "your-inspect-template-id";
    // Specify the Deidentify template ID.
    String deidentifyTemplateId = "your-deidentify-template-id";

    createTemplateWithAdvancedSdp(projectId, locationId, templateId, inspectTemplateId,
        deidentifyTemplateId);
  }

  public static Template createTemplateWithAdvancedSdp(String projectId, String locationId,
      String templateId, String inspectTemplateId, String deidentifyTemplateId) throws IOException {

    // Construct the API endpoint URL.
    String apiEndpoint = String.format("modelarmor.%s.rep.googleapis.com:443", locationId);
    ModelArmorSettings modelArmorSettings = ModelArmorSettings.newBuilder().setEndpoint(apiEndpoint)
        .build();

    // Initialize the client that will be used to send requests. This client
    // only needs to be created once, and can be reused for multiple requests.
    try (ModelArmorClient client = ModelArmorClient.create(modelArmorSettings)) {
      String parent = LocationName.of(projectId, locationId).toString();

      String inspectTemplateName = InspectTemplateName
          .ofProjectLocationInspectTemplateName(projectId, locationId, inspectTemplateId)
          .toString();

      String deidentifyTemplateName = DeidentifyTemplateName
          .ofProjectLocationDeidentifyTemplateName(projectId, locationId, deidentifyTemplateId)
          .toString();

      // Build the Model Armor template with Advanced SDP Filter.

      // Note: If you specify only Inspect template, Model Armor reports the filter matches if
      // sensitive data is detected. If you specify Inspect template and De-identify template, Model
      // Armor returns the de-identified sensitive data and sanitized version of prompts or
      // responses in the deidentifyResult.data.text field of the finding.
      SdpAdvancedConfig advancedSdpConfig =
          SdpAdvancedConfig.newBuilder()
              .setInspectTemplate(inspectTemplateName)
              .setDeidentifyTemplate(deidentifyTemplateName)
              .build();

      SdpFilterSettings sdpSettings = SdpFilterSettings.newBuilder()
          .setAdvancedConfig(advancedSdpConfig).build();

      FilterConfig modelArmorFilter = FilterConfig.newBuilder().setSdpSettings(sdpSettings).build();

      Template template = Template.newBuilder().setFilterConfig(modelArmorFilter).build();

      CreateTemplateRequest request = CreateTemplateRequest.newBuilder()
          .setParent(parent)
          .setTemplateId(templateId)
          .setTemplate(template)
          .build();

      Template createdTemplate = client.createTemplate(request);
      System.out.println("Created template with Advanced SDP filter: " + createdTemplate.getName());

      return createdTemplate;
    }
  }
}

Node.js

Per eseguire questo codice, devi innanzitutto configurare un ambiente di sviluppo Node.js e installare l'SDK Node.js di Model Armor.

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const projectId = 'your-project-id';
// const locationId = 'us-central1';
// const templateId = 'template-id';
// const inspectTemplate = `projects/${projectId}/locations/${locationId}/inspectTemplates/inspect-template-id`;
// const deidentifyTemplate = `projects/${projectId}/locations/${locationId}/deidentifyTemplates/deidentify-template-id`;

const parent = `projects/${projectId}/locations/${locationId}`;

// Imports the Model Armor library
const modelarmor = require('@google-cloud/modelarmor');
const {ModelArmorClient} = modelarmor.v1;
const {protos} = modelarmor;

const RaiFilterType = protos.google.cloud.modelarmor.v1.RaiFilterType;
const DetectionConfidenceLevel =
  protos.google.cloud.modelarmor.v1.DetectionConfidenceLevel;

// Instantiates a client
const client = new ModelArmorClient({
  apiEndpoint: `modelarmor.${locationId}.rep.googleapis.com`,
});

// Configuration for the template with advanced SDP settings
const templateConfig = {
  filterConfig: {
    raiSettings: {
      raiFilters: [
        {
          filterType: RaiFilterType.DANGEROUS,
          confidenceLevel: DetectionConfidenceLevel.HIGH,
        },
        {
          filterType: RaiFilterType.HARASSMENT,
          confidenceLevel: DetectionConfidenceLevel.MEDIUM_AND_ABOVE,
        },
        {
          filterType: RaiFilterType.HATE_SPEECH,
          confidenceLevel: DetectionConfidenceLevel.HIGH,
        },
        {
          filterType: RaiFilterType.SEXUALLY_EXPLICIT,
          confidenceLevel: DetectionConfidenceLevel.HIGH,
        },
      ],
    },
    sdpSettings: {
      advancedConfig: {
        inspectTemplate: inspectTemplate,
        deidentifyTemplate: deidentifyTemplate,
      },
    },
  },
};

// Construct request
const request = {
  parent,
  templateId,
  template: templateConfig,
};

// Create the template
const [response] = await client.createTemplate(request);
return response;

PHP

Per eseguire questo codice, devi innanzitutto configurare un ambiente di sviluppo PHP e installare l'SDK PHP Model Armor.

use Google\Cloud\ModelArmor\V1\Client\ModelArmorClient;
use Google\Cloud\ModelArmor\V1\SdpAdvancedConfig;
use Google\Cloud\ModelArmor\V1\Template;
use Google\Cloud\ModelArmor\V1\FilterConfig;
use Google\Cloud\ModelArmor\V1\CreateTemplateRequest;
use Google\Cloud\ModelArmor\V1\SdpFilterSettings;

/**
 * Create a Model Armor template with an Advanced SDP Filter.
 *
 * @param string $projectId The ID of the project (e.g. 'my-project').
 * @param string $locationId The ID of the location (e.g. 'us-central1').
 * @param string $templateId The ID of the template (e.g. 'my-template').
 * @param string $inspectTemplate The resource name of the inspect template.
          (e.g. 'organizations/{organization}/inspectTemplates/{inspect_template}')
 * @param string $deidentifyTemplate The resource name of the de-identify template.
          (e.g. 'organizations/{organization}/deidentifyTemplates/{deidentify_template}')
 */
function create_template_with_advanced_sdp(
    string $projectId,
    string $locationId,
    string $templateId,
    string $inspectTemplate,
    string $deidentifyTemplate
): void {
    $options = ['apiEndpoint' => "modelarmor.$locationId.rep.googleapis.com"];
    $client = new ModelArmorClient($options);
    $parent = $client->locationName($projectId, $locationId);

    // Build the Model Armor template with Advanced SDP Filter.

    // Note: If you specify only Inspect template, Model Armor reports the filter matches if
    // sensitive data is detected. If you specify Inspect template and De-identify template, Model
    // Armor returns the de-identified sensitive data and sanitized version of prompts or
    // responses in the deidentifyResult.data.text field of the finding.
    $sdpAdvancedConfig = (new SdpAdvancedConfig())
        ->setInspectTemplate($inspectTemplate)
        ->setDeidentifyTemplate($deidentifyTemplate);

    $sdpSettings = (new SdpFilterSettings())->setAdvancedConfig($sdpAdvancedConfig);

    $templateFilterConfig = (new FilterConfig())
        ->setSdpSettings($sdpSettings);

    $template = (new Template())->setFilterConfig($templateFilterConfig);

    $request = (new CreateTemplateRequest())
        ->setParent($parent)
        ->setTemplateId($templateId)
        ->setTemplate($template);

    $response = $client->createTemplate($request);

    printf('Template created: %s' . PHP_EOL, $response->getName());
}

Python

Per eseguire questo codice, configura un ambiente di sviluppo Python e installa l'SDK Python di Model Armor.

from google.api_core.client_options import ClientOptions
from google.cloud import modelarmor_v1

# TODO(Developer): Uncomment these variables.
# project_id = "YOUR_PROJECT_ID"
# location_id = "us-central1"
# template_id = "template_id"
# inspect_template = f"projects/{project_id}/inspectTemplates/{inspect_template_id}"
# deidentify_template = f"projects/{project_id}/deidentifyTemplates/{deidentify_template_id}"

# Create the Model Armor client.
client = modelarmor_v1.ModelArmorClient(
    transport="rest",
    client_options=ClientOptions(
        api_endpoint=f"modelarmor.{location_id}.rep.googleapis.com"
    ),
)

parent = f"projects/{project_id}/locations/{location_id}"

# Build the Model Armor template with your preferred filters.
# For more details on filters, please refer to the following doc:
# https://cloud.google.com/security-command-center/docs/key-concepts-model-armor#ma-filters
template = modelarmor_v1.Template(
    filter_config=modelarmor_v1.FilterConfig(
        rai_settings=modelarmor_v1.RaiFilterSettings(
            rai_filters=[
                modelarmor_v1.RaiFilterSettings.RaiFilter(
                    filter_type=modelarmor_v1.RaiFilterType.DANGEROUS,
                    confidence_level=modelarmor_v1.DetectionConfidenceLevel.HIGH,
                ),
                modelarmor_v1.RaiFilterSettings.RaiFilter(
                    filter_type=modelarmor_v1.RaiFilterType.HARASSMENT,
                    confidence_level=modelarmor_v1.DetectionConfidenceLevel.MEDIUM_AND_ABOVE,
                ),
                modelarmor_v1.RaiFilterSettings.RaiFilter(
                    filter_type=modelarmor_v1.RaiFilterType.HATE_SPEECH,
                    confidence_level=modelarmor_v1.DetectionConfidenceLevel.HIGH,
                ),
                modelarmor_v1.RaiFilterSettings.RaiFilter(
                    filter_type=modelarmor_v1.RaiFilterType.SEXUALLY_EXPLICIT,
                    confidence_level=modelarmor_v1.DetectionConfidenceLevel.HIGH,
                ),
            ]
        ),
        sdp_settings=modelarmor_v1.SdpFilterSettings(
            advanced_config=modelarmor_v1.SdpAdvancedConfig(
                inspect_template=inspect_template,
                deidentify_template=deidentify_template,
            )
        ),
    ),
)

# Prepare the request for creating the template.
create_template = modelarmor_v1.CreateTemplateRequest(
    parent=parent, template_id=template_id, template=template
)

# Create the template.
response = client.create_template(request=create_template)

# Print the new template name.
print(f"Created template: {response.name}")

Utilizza il modello creato per esaminare i prompt. Ecco un esempio:

curl -X POST \
    -d '{"userPromptData":{"text":"is there anything malicious running on 1.1.1.1?"}}' \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer $(gcloud auth print-access-token)" \
        "https://modelarmor.LOCATION.rep.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/templates/TEMPLATE_ID:sanitizeUserPrompt"

Sostituisci quanto segue:

• PROJECT_ID: l'ID del progetto a cui appartiene il modello.
• LOCATION: la posizione del modello.
• TEMPLATE_ID: l'ID del modello.

Questo esempio restituisce la seguente risposta:

{
  "sanitizationResult": {
    "filterMatchState": "MATCH_FOUND",
    "invocationResult": "SUCCESS",
      "filterResults": [
      {
        "csamFilterFilterResult": {
          "executionState": "EXECUTION_SUCCESS",
          "matchState": "NO_MATCH_FOUND"
        }
      },
      {
      "sdpFilterResult": {
        "deidentifyResult": {
          "executionState": "EXECUTION_SUCCESS",
          "matchState": "MATCH_FOUND",
          "data": {
            "text": "is there anything malicious running on [IP_ADDRESS]?"
          },
            "transformedBytes": "7",
            "infoTypes": ["IP_ADDRESS"]
        }
      }
      }
      ]
  }
}

Sanifica la risposta del modello

A volte gli LLM possono generare risposte dannose. Per ridurre i rischi associati all'utilizzo di LLM nelle tue applicazioni, è importante sanificare le loro risposte.

Ecco un esempio di comando per sanificare una risposta del modello in Model Armor.

REST

 curl -X POST \
     -d '{"modelResponseData":{"text":"IP address of the current network is ##.##.##.##"}}' \
     -H "Content-Type: application/json" \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
         "https://modelarmor.LOCATION.rep.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/templates/TEMPLATE_ID:sanitizeModelResponse"

Sostituisci quanto segue:

• PROJECT_ID: l'ID del progetto a cui appartiene il modello.
• LOCATION: la posizione del modello.

• TEMPLATE_ID: l'ID del modello.

  Questo esempio restituisce la seguente risposta:

  {
  "sanitizationResult": {
  "filterMatchState": "MATCH_FOUND",
  "invocationResult": "SUCCESS",
    "filterResults": {
      "rai": {
        "raiFilterResult": {
          "executionState": "EXECUTION_SUCCESS",
          "matchState": "MATCH_FOUND",
          "raiFilterTypeResults": {
      "dangerous": {
        "confidenceLevel": "MEDIUM_AND_ABOVE",
        "matchState": "MATCH_FOUND"
      },
      "sexually_explicit": {
        "matchState": "NO_MATCH_FOUND"
      },
      "hate_speech": {
        "matchState": "NO_MATCH_FOUND"
      },
      "harassment": {
        "matchState": "NO_MATCH_FOUND"
      }
    }
  }
  },
  "pi_and_jailbreak": {
  "piAndJailbreakFilterResult": {
    "executionState": "EXECUTION_SUCCESS",
    "matchState": "NO_MATCH_FOUND"
    }
  },
  "csam": {
  "csamFilterFilterResult": {
    "executionState": "EXECUTION_SUCCESS",
    "matchState": "NO_MATCH_FOUND"
  }
  },
  "malicious_uris": {
  "maliciousUriFilterResult": {
    "executionState": "EXECUTION_SUCCESS",
    "matchState": "NO_MATCH_FOUND"
  }
  },
  }
  }
  }

C#

Per eseguire questo codice, devi innanzitutto configurare un ambiente di sviluppo C# e installare l'SDK C# Model Armor.

using Google.Cloud.ModelArmor.V1;
using System;

namespace ModelArmor.Samples
{
    public class SanitizeModelResponseSample
    {
        public SanitizeModelResponseResponse SanitizeModelResponse(
            string projectId = "my-project",
            string locationId = "us-central1",
            string templateId = "my-template",
            string modelResponse = "Unsanitized model output"
        )
        {
            // Endpoint to call the Model Armor server.
            ModelArmorClientBuilder clientBuilder = new ModelArmorClientBuilder
            {
                Endpoint = $"modelarmor.{locationId}.rep.googleapis.com",
            };

            // Create the client.
            ModelArmorClient client = clientBuilder.Build();

            // Build the resource name of the template.
            TemplateName templateName = TemplateName.FromProjectLocationTemplate(
                projectId,
                locationId,
                templateId
            );

            // Prepare the request.
            SanitizeModelResponseRequest request = new SanitizeModelResponseRequest
            {
                TemplateName = templateName,
                ModelResponseData = new DataItem { Text = modelResponse },
            };

            // Send the request and get the response.
            SanitizeModelResponseResponse response = client.SanitizeModelResponse(request);

            // Print the sanitization result
            Console.WriteLine($"Result for the provided model response: {response}");

            return response;
        }
    }
}

Go

Per eseguire questo codice, devi innanzitutto configurare un ambiente di sviluppo Go e installare l'SDK Go di Model Armor.

import (
	"context"
	"fmt"
	"io"

	modelarmor "cloud.google.com/go/modelarmor/apiv1"
	modelarmorpb "cloud.google.com/go/modelarmor/apiv1/modelarmorpb"
	"google.golang.org/api/option"
)

// sanitizeModelResponse method sanitizes a model
// response based on the project, location, and template settings.
//
// w io.Writer: The writer to use for logging.
// projectID string: The ID of the project.
// locationID string: The ID of the location.
// templateID string: The ID of the template.
// modelResponse string: The model response to sanitize.
func sanitizeModelResponse(w io.Writer, projectID, locationID, templateID, modelResponse string) error {
	ctx := context.Background()

	// Create options for Model Armor client.
	opts := option.WithEndpoint(fmt.Sprintf("modelarmor.%s.rep.googleapis.com:443", locationID))
	// Create the Model Armor client.
	client, err := modelarmor.NewClient(ctx, opts)
	if err != nil {
		return fmt.Errorf("failed to create client for location %s: %w", locationID, err)
	}
	defer client.Close()

	// Initialize request argument(s)
	modelResponseData := &modelarmorpb.DataItem{
		DataItem: &modelarmorpb.DataItem_Text{
			Text: modelResponse,
		},
	}

	// Prepare request for sanitizing model response.
	req := &modelarmorpb.SanitizeModelResponseRequest{
		Name:              fmt.Sprintf("projects/%s/locations/%s/templates/%s", projectID, locationID, templateID),
		ModelResponseData: modelResponseData,
	}

	// Sanitize the model response.
	response, err := client.SanitizeModelResponse(ctx, req)
	if err != nil {
		return fmt.Errorf("failed to sanitize model response with user prompt for template %s: %w", templateID, err)
	}

	// Sanitization Result.
	fmt.Fprintf(w, "Sanitization Result: %v\n", response)

	return nil
}

Java

Per eseguire questo codice, devi innanzitutto configurare un ambiente di sviluppo Java e installare l'SDK Java Model Armor.

import com.google.cloud.modelarmor.v1.DataItem;
import com.google.cloud.modelarmor.v1.ModelArmorClient;
import com.google.cloud.modelarmor.v1.ModelArmorSettings;
import com.google.cloud.modelarmor.v1.SanitizeModelResponseRequest;
import com.google.cloud.modelarmor.v1.SanitizeModelResponseResponse;
import com.google.cloud.modelarmor.v1.TemplateName;
import com.google.protobuf.util.JsonFormat;
import java.io.IOException;

public class SanitizeModelResponse {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.

    // Specify the Google Project ID.
    String projectId = "your-project-id";
    // Specify the location ID. For example, us-central1. 
    String locationId = "your-location-id";
    // Specify the template ID.
    String templateId = "your-template-id";
    // Specify the model response.
    String modelResponse = "Unsanitized model output";

    sanitizeModelResponse(projectId, locationId, templateId, modelResponse);
  }

  public static SanitizeModelResponseResponse sanitizeModelResponse(String projectId,
      String locationId, String templateId, String modelResponse) throws IOException {

    // Endpoint to call the Model Armor server.
    String apiEndpoint = String.format("modelarmor.%s.rep.googleapis.com:443", locationId);
    ModelArmorSettings modelArmorSettings = ModelArmorSettings.newBuilder().setEndpoint(apiEndpoint)
        .build();

    try (ModelArmorClient client = ModelArmorClient.create(modelArmorSettings)) {
      // Build the resource name of the template.
      String name = TemplateName.of(projectId, locationId, templateId).toString();

      // Prepare the request.
      SanitizeModelResponseRequest request = 
          SanitizeModelResponseRequest.newBuilder()
            .setName(name)
            .setModelResponseData(
              DataItem.newBuilder().setText(modelResponse)
              .build())
            .build();

      SanitizeModelResponseResponse response = client.sanitizeModelResponse(request);
      System.out.println("Result for the provided model response: "
          + JsonFormat.printer().print(response.getSanitizationResult()));

      return response;
    }
  }
}

Node.js

Per eseguire questo codice, devi innanzitutto configurare un ambiente di sviluppo Node.js e installare l'SDK Node.js di Model Armor.

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const projectId = process.env.PROJECT_ID || 'your-project-id';
// const locationId = process.env.LOCATION_ID || 'us-central1';
// const templateId = process.env.TEMPLATE_ID || 'template-id';
// const modelResponse = 'unsanitized model output';
const {ModelArmorClient} = require('@google-cloud/modelarmor').v1;

const client = new ModelArmorClient({
  apiEndpoint: `modelarmor.${locationId}.rep.googleapis.com`,
});

const request = {
  name: `projects/${projectId}/locations/${locationId}/templates/${templateId}`,
  modelResponseData: {
    text: modelResponse,
  },
};

const [response] = await client.sanitizeModelResponse(request);
console.log(JSON.stringify(response, null, 2));

PHP

Per eseguire questo codice, devi innanzitutto configurare un ambiente di sviluppo PHP e installare l'SDK PHP Model Armor.

use Google\Cloud\ModelArmor\V1\Client\ModelArmorClient;
use Google\Cloud\ModelArmor\V1\SanitizeModelResponseRequest;
use Google\Cloud\ModelArmor\V1\DataItem;

/**
 * Sanitizes a model response using the specified template.
 *
 * @param string $projectId The ID of your Google Cloud Platform project (e.g. 'my-project').
 * @param string $locationId The ID of the location where the template is stored (e.g. 'us-central1').
 * @param string $templateId The ID of the template (e.g. 'my-template').
 * @param string $modelResponse The model response to sanitize (e.g. 'my-model-response').
 */
function sanitize_model_response(
    string $projectId,
    string $locationId,
    string $templateId,
    string $modelResponse
): void {
    $options = ['apiEndpoint' => "modelarmor.$locationId.rep.googleapis.com"];
    $client = new ModelArmorClient($options);

    $modelResponseRequest = (new SanitizeModelResponseRequest())
        ->setName("projects/$projectId/locations/$locationId/templates/$templateId")
        ->setModelResponseData((new DataItem())->setText($modelResponse));

    $response = $client->sanitizeModelResponse($modelResponseRequest);

    printf('Result for Model Response Sanitization: %s' . PHP_EOL, $response->serializeToJsonString());
}

Python

Per eseguire questo codice, configura un ambiente di sviluppo Python e installa l'SDK Python di Model Armor.

from google.api_core.client_options import ClientOptions
from google.cloud import modelarmor_v1

# TODO(Developer): Uncomment these variables.
# project_id = "YOUR_PROJECT_ID"
# location_id = "us-central1"
# template_id = "template_id"
# model_response = "The model response data to sanitize"

# Create the Model Armor client.
client = modelarmor_v1.ModelArmorClient(
    client_options=ClientOptions(
        api_endpoint=f"modelarmor.{location_id}.rep.googleapis.com"
    )
)

# Initialize request argument(s)
model_response_data = modelarmor_v1.DataItem(text=model_response)

# Prepare request for sanitizing model response.
request = modelarmor_v1.SanitizeModelResponseRequest(
    name=f"projects/{project_id}/locations/{location_id}/templates/{template_id}",
    model_response_data=model_response_data,
)

# Sanitize the model response.
response = client.sanitize_model_response(request=request)

# Sanitization Result.
print(response)

Sanifica la risposta del modello con il rilevamento multilingue attivato

Attiva il rilevamento multilingue in base alla richiesta impostando il flag enableMultiLanguageDetection su true per ogni risposta individuale. Se vuoi, puoi specificare la lingua di origine per ottenere risultati più precisi.

• Se non specifichi la lingua di origine, Model Armor la rileva automaticamente per fornire il supporto multilingue.
• Se specifichi la lingua di origine, Model Armor la utilizza per valutare la risposta del modello e non esegue il rilevamento automatico della lingua.

curl -X POST \
-d  '{"modelResponseData":{"text":"[UNSAFE TEXT]"}, "multiLanguageDetectionMetadata": { "enableMultiLanguageDetection": true , "sourceLanguage": "jp"}}' \
-H "Content-Type: application/json" \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
"https://modelarmor.LOCATION.rep.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/templates/TEMPLATE_ID:sanitizeModelResponse"

Sostituisci quanto segue:

• PROJECT_ID: l'ID del progetto a cui appartiene il modello.
• LOCATION: la posizione del modello.
• TEMPLATE_ID: l'ID del modello.

Sanifica la risposta del modello in tutti i progetti

Per abilitare la gestione centralizzata della sicurezza dell'AI, le organizzazioni spesso archiviano i template Model Armor in un progetto dedicato (progetto A: TEMPLATE_PROJECT_ID) mentre le loro applicazioni vengono eseguite in progetti separati (progetto B).

Per consentire a un account di servizio (CALLER_SERVICE_ACCOUNT) del progetto B di accedere a un modello nel progetto A, devi aggiungere un binding della policy IAM al progetto del modello.

Nota :puoi centralizzare i modelli Model Armor e Sensitive Data Protection in un unico progetto Google Cloud . Altri progetti possono quindi utilizzare questi modelli, se all'account di servizio o all'utente chiamante del progetto esterno è stato concesso il ruolo IAM roles/modelarmor.user nel progetto di hosting dei modelli.

Per concedere le autorizzazioni tra progetti necessarie, esegui questo comando:

gcloud projects add-iam-policy-binding TEMPLATE_PROJECT_ID \
    --member='serviceAccount:CALLER_SERVICE_ACCOUNT' \
    --role='roles/modelarmor.user'

Sostituisci quanto segue:

• TEMPLATE_PROJECT_ID: l'ID del progetto in cui è ospitato il modello.
• CALLER_SERVICE_ACCOUNT: il account di servizio del progetto che effettua la richiesta API.

Passaggi successivi

• Scopri di più su Model Armor.
• Scopri di più sulle impostazioni di base di Model Armor.
• Scopri di più sui modelli Model Armor.
• Risolvi i problemi di Model Armor.