Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

Menyaring perintah dan respons

Halaman ini menjelaskan cara membersihkan perintah dan respons secara mendetail. Model Armor menawarkan serangkaian filter untuk melindungi aplikasi AI Anda. Model Armor memeriksa perintah dan respons untuk tingkat keyakinan penapisan yang dikonfigurasi.

Sebelum memulai

Buat template dengan mengikuti petunjuk di Membuat template.

Mendapatkan izin yang diperlukan

Untuk mendapatkan izin yang Anda perlukan untuk membersihkan perintah dan respons, minta administrator Anda untuk memberi Anda peran IAM berikut di Model Armor:

Pengguna Model Armor (roles/modelarmor.user)
Penampil Model Armor (roles/modelarmor.viewer)

Untuk mengetahui informasi selengkapnya tentang pemberian peran, lihat Mengelola akses ke project, folder, dan organisasi.

Anda mungkin juga bisa mendapatkan izin yang diperlukan melalui peran khusus atau peran bawaan lainnya.

Dalam project yang berisi template Sensitive Data Protection, berikan peran Pengguna DLP (roles/dlp.user) dan peran Pembaca DLP (roles/dlp.reader) kepada agen layanan yang dibuat sebagai bagian dari langkah-langkah Perlindungan Data Sensitif Lanjutan di Membuat template. Lewati langkah ini jika template Sensitive Data Protection berada di project yang sama dengan template Model Armor.

gcloud projects add-iam-policy-binding SDP_PROJECT_ID \
    --member=serviceAccount:service-PROJECT_NUMBER@gcp-sa-modelarmor.iam.gserviceaccount.com --role=roles/dlp.user

gcloud projects add-iam-policy-binding SDP_PROJECT_ID \
    --member=serviceAccount:service-PROJECT_NUMBER@gcp-sa-modelarmor.iam.gserviceaccount.com --role=roles/dlp.reader

Ganti kode berikut:

SDP_PROJECT_ID: ID project tempat template Perlindungan Data Sensitif lanjutan berada.
PROJECT_NUMBER: nomor project tempat template berada.

Mengaktifkan API

Anda harus mengaktifkan Model Armor API sebelum dapat menggunakan Model Armor.

Konsol

Aktifkan Model Armor API.
Peran yang diperlukan untuk mengaktifkan API
Untuk mengaktifkan API, Anda memerlukan peran IAM Service Usage Admin (roles/serviceusage.serviceUsageAdmin), yang berisi izin serviceusage.services.enable. Pelajari cara memberikan peran.
Mengaktifkan API
Pilih project tempat Anda ingin mengaktifkan Model Armor.

gcloud

Sebelum memulai, ikuti langkah-langkah berikut menggunakan Google Cloud CLI dengan Model Armor API:

Di konsol Google Cloud , aktifkan Cloud Shell.

Aktifkan Cloud Shell

Di bagian bawah konsol Google Cloud , sesi Cloud Shell akan dimulai dan menampilkan perintah command line. Cloud Shell adalah lingkungan shell dengan Google Cloud CLI yang sudah terinstal, dan dengan nilai yang sudah ditetapkan untuk project Anda saat ini. Diperlukan waktu beberapa detik untuk melakukan inisialisasi pada sesi.
Tetapkan penggantian endpoint API menggunakan gcloud CLI.

Menetapkan penggantian endpoint API menggunakan gcloud CLI

Langkah ini hanya diperlukan jika Anda menggunakan gcloud CLI untuk mengaktifkan Model Armor API. Anda harus menetapkan penggantian endpoint API secara manual untuk memastikan gcloud CLI merutekan permintaan dengan benar ke layanan Model Armor.

Jalankan perintah berikut untuk menetapkan endpoint API untuk layanan Model Armor.

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

Ganti LOCATION dengan region tempat Anda ingin menggunakan Model Armor.

Membersihkan perintah

Bersihkan perintah untuk mencegah input berbahaya dan membantu memastikan perintah yang aman dan sesuai dikirim ke LLM Anda.

Perintah teks

Model Armor membersihkan perintah teks dengan menganalisis teks dan menerapkan berbagai filter untuk mengidentifikasi dan memitigasi potensi ancaman.

REST

Gunakan perintah berikut untuk membersihkan perintah teks di 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"

Ganti kode berikut:

PROJECT_ID: ID project untuk template.
LOCATION: lokasi template.
TEMPLATE_ID: ID template.

Hal ini akan menghasilkan respons berikut. Perhatikan bahwa MATCH_FOUND berada dalam kategori Berbahaya.

  {
  "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

Untuk menjalankan kode ini, siapkan lingkungan pengembangan Go terlebih dahulu dan instal Model Armor Go SDK.


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#

Untuk menjalankan kode ini, siapkan lingkungan pengembangan C# terlebih dahulu dan instal Model Armor C# SDK.

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

Untuk menjalankan kode ini, pertama-tama siapkan lingkungan pengembangan Java dan instal Model Armor Java SDK.


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

Untuk menjalankan kode ini, siapkan lingkungan pengembangan Node.js terlebih dahulu dan instal Model Armor Node.js SDK.

/**
 * 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

Untuk menjalankan kode ini, pertama-tama siapkan lingkungan pengembangan PHP dan instal 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

Untuk menjalankan kode ini, siapkan lingkungan pengembangan Python dan instal Model Armor Python SDK.


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)

Hal ini akan menghasilkan respons berikut.

  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
  }

Praktik terbaik untuk membersihkan perintah dalam AI percakapan

Saat menggunakan Model Armor untuk membersihkan input dalam aplikasi AI percakapan, penting untuk memahami apa yang harus disertakan dalam kolom userPromptData untuk metode SanitizeUserPrompt.

Bersihkan setiap input pengguna secara terpisah: Panggil API SanitizeUserPrompt untuk setiap pesan baru yang diterima dari pengguna. Hal ini memastikan setiap input pengguna dianalisis untuk mendeteksi potensi ancaman sebelum diproses oleh LLM Anda. Kolom userPromptData hanya boleh berisi konten pesan terbaru dari pengguna dalam percakapan saat ini.
Jangan sertakan histori percakapan: Hindari menggabungkan seluruh histori chat ke dalam kolom userPromptData.
Jangan sertakan perintah sistem: Perintah sistem tidak boleh disertakan di kolom userPromptData. Model Armor berfokus untuk mendeteksi ancaman hanya pada input yang disediakan pengguna.

Membersihkan perintah teks dengan deteksi multibahasa diaktifkan

Aktifkan deteksi multi-bahasa berdasarkan per permintaan dengan menyetel flag enableMultiLanguageDetection ke true untuk setiap permintaan. Secara opsional, Anda dapat menentukan bahasa sumber untuk hasil yang lebih akurat.

Jika Anda tidak menentukan bahasa sumber, Model Armor akan otomatis mendeteksi bahasa untuk memberikan dukungan multi-bahasa.
Jika Anda menentukan bahasa sumber, Model Armor akan menggunakan bahasa tersebut untuk mengevaluasi perintah teks dan tidak melakukan deteksi bahasa otomatis.

Gunakan perintah berikut untuk membersihkan perintah teks di Model Armor dengan deteksi multi-bahasa diaktifkan di tingkat permintaan.

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"

Ganti kode berikut:

PROJECT_ID: ID project untuk template.
LOCATION: lokasi template.
TEMPLATE_ID: ID template.

Perintah yang berisi gambar

Untuk mengaktifkan penyaringan gambar, tetapkan modalitas dalam metadata template. Anda dapat mengonfigurasi modalitas di template baru dan yang sudah ada. Jika Anda menentukan satu modalitas (IMAGE atau TEXT), Model Armor akan melewati modalitas lainnya dan menampilkan EXECUTION_SKIPPED. Anda harus menetapkan kolom byteDataType ke IMAGE secara eksplisit dan memberikan gambar berenkode base64 dalam format yang didukung di kolom byteData.

Gunakan perintah berikut untuk membersihkan perintah yang berisi gambar.

curl -X POST \
    -d "$(jq -n \
    --arg data "$(base64 -w 0 -i IMAGE)" \
    '{userPromptData: {byteItem: {byteDataType: "IMAGE", 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"

Ganti kode berikut:

PROJECT_ID: ID project yang berisi template.
LOCATION: lokasi template.
TEMPLATE_ID: ID template.
IMAGE: gambar dalam format yang didukung.

Responsnya mirip dengan hal berikut ini:

{
  "sanitizationResult": {
    "filterMatchState": "MATCH_FOUND",
    "invocationResult": "SUCCESS",
    "filterResults": {
      "csam": {
        "csamFilterFilterResult": {
          "executionState": "EXECUTION_SUCCESS",
          "matchState": "NO_MATCH_FOUND"
        }
      },
      "sdp": {
        "sdpFilterResult": {
          "inspectResult": {
            "executionState": "EXECUTION_SUCCESS",
            "matchState": "MATCH_FOUND"
          }
        }
      }
    },
  }
}

Menyamarkan gambar

Untuk mode lanjutan Sensitive Data Protection, Model Armor mengaburkan gambar hanya jika Anda mengonfigurasi filter Model Armor dengan template pemeriksaan Sensitive Data Protection dan template de-identifikasi Sensitive Data Protection. Untuk mengetahui informasi selengkapnya, lihat Menetapkan setelan Perlindungan Data Sensitif. Pastikan Anda mengonfigurasi penyensoran gambar dalam template de-identifikasi.

Saat menggunakan mode lanjutan Sensitive Data Protection, infoType BASIC_AUTH_HEADER mungkin dilaporkan dalam hasil deteksi meskipun tidak secara eksplisit disertakan dalam template inspeksi yang dikonfigurasi.

Contoh berikut menunjukkan konfigurasi filter dengan Redaksi Sensitive Data Protection diaktifkan.

{
  "filterConfig": {
    "sdpSettings": {
      "advancedConfig": {
        "inspectTemplate": "projects/PROJECT_ID/locations/LOCATION/inspectTemplates/TEMPLATE_ID",
        "deidentifyTemplate": "projects/PROJECT_ID/locations/LOCATION/deidentifyTemplates/TEMPLATE_ID"
      }
    }
  }
}

Ganti kode berikut:

PROJECT_ID: ID project yang berisi template.
LOCATION: lokasi template.
TEMPLATE_ID: ID template.

Hal ini akan menghasilkan respons berikut.

{
  "sanitizationResult": {
    "filterMatchState": "MATCH_FOUND",
    "invocationResult": "SUCCESS",
    "filterResults": {
      "csam": {
        "csamFilterFilterResult": {
          "executionState": "EXECUTION_SUCCESS",
          "matchState": "NO_MATCH_FOUND"
        }
      },
      "sdp": {
        "sdpFilterResult": {
          "redactResult": {
            "executionState": "EXECUTION_SUCCESS",
            "matchState": "MATCH_FOUND",
            "redactedImage": "[REDACTED_IMAGE]",
            "findings": [
              {
                "infoType": "EMAIL_ADDRESS",
                "likelihood": "LIKELY",
                "location": {
                  "contentLocations": [
                    {
                      "imageFindingLocation": {
                        "boundingBox": {
                          "top": 16,
                          "left": 121,
                          "width": 620,
                          "height": 90
                        }
                      }
                    }
                  ]
                }
              }
            ]
          }
        }
      }
    }
  }
}

Membersihkan perintah teks streaming

Metode streaming Model Armor membersihkan perintah dan respons secara real-time sebagai aliran teks, tanpa menunggu hingga seluruh konten tersedia. Kemampuan ini sangat berguna untuk aplikasi yang menangani payload teks berukuran besar atau yang memerlukan interaksi latensi rendah dengan LLM.

Gunakan metode ini untuk mengaktifkan streaming:

StreamSanitizeUserPrompt: Mengalirkan dan membersihkan teks yang disediakan pengguna.
StreamSanitizeModelResponse: Mengalirkan dan membersihkan teks yang dihasilkan LLM.

Model Armor menawarkan mode streaming berikut:

Mode yang di-buffer: Mengumpulkan semua chunk yang di-streaming dan memprosesnya bersama-sama sebagai satu unit.
Mode real-time: Memproses setiap potongan secara terpisah saat diterima, sambil memberikan masukan berkelanjutan.

Model Armor mendukung token tanpa batas saat menggunakan mode streaming real-time, sedangkan mode buffer tunduk pada batas token.

Streaming berfungsi sebagai berikut:

Input yang di-chunk: Aplikasi Anda mengirimkan teks ke Model Armor dalam potongan-potongan yang lebih kecil (chunk), bukan mengirimkan seluruh isi teks sekaligus.
Pemrosesan real-time: Model Armor memproses potongan ini saat tiba dan menerapkan filter keamanan dan keselamatan yang dikonfigurasi dalam template Anda.
Masukan berkelanjutan: Bergantung pada mode (mode real-time atau mode yang di-buffer), Model Armor menampilkan hasil per bagian yang diproses atau setelah semua bagian diterima.

Gunakan perintah berikut untuk membersihkan perintah teks streaming.

Go

Untuk menjalankan kode ini, siapkan lingkungan pengembangan Go terlebih dahulu dan instal Model Armor Go SDK.

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 := "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
  }
}

C#

Untuk menjalankan kode ini, siapkan lingkungan pengembangan C# terlebih dahulu dan instal Model Armor C# SDK.

  using Google.Api.Gax.Grpc;
  using Google.Cloud.ModelArmor.V1Beta;
  using Grpc.Core;
  using System;
  using System.Collections.Generic;
  using System.Threading.Tasks;

  public class StreamSanitizeUserPromptExample
  {
  public static async Task Main(string[] args)
      {
          try
          {
              await RunStreamSanitizeUserPromptExample();
          }
          catch (Exception e)
          {
              Console.WriteLine($"An error occurred: {e}");
          }
      }
      public static async Task RunStreamSanitizeUserPromptExample()
      {
          string projectId = "YOUR_PROJECT_ID";
          string location = "LOCATION_ID";
          string templateId = "YOUR_TEMPLATE_ID";

          var promptChunks = new List<string>
          {
              "This is the first part of the user prompt. ",
              "This is the second part. ",
              "And this is the final part."
          };

          // Construct the regional REP endpoint (without port)
          string regionalEndpoint = $"modelarmor.{location}.rep.googleapis.com";
          Console.WriteLine($"Using endpoint: {regionalEndpoint}");

          // Initialize the Model Armor client using Application Default Credentials.

          var client = new ModelArmorClientBuilder
          {
              Endpoint = regionalEndpoint
          }.Build();

          // Construct the resource name.
          var resourceName = TemplateName.FromProjectLocationTemplate(projectId, location, templateId);

          // Get the bi-directional streaming call object
          using var stream = client.StreamSanitizeUserPrompt();

          Console.WriteLine("Sending requests...");

          // --- Send First Request ---
          var firstRequest = new SanitizeUserPromptRequest
          {
              Name = resourceName.ToString(),
              UserPromptData = new DataItem { Text = promptChunks[0] },
              StreamingMode = StreamingMode.Buffered // Or StreamingMode.Realtime
          };
          await stream.WriteAsync(firstRequest);
          Console.WriteLine($"Sent chunk 1: \"{promptChunks[0]}\"");

        // --- Send Subsequent Requests ---
          for (int i = 1; i < promptChunks.Count; i++)
          {
              var subsequentRequest = new SanitizeUserPromptRequest
              {
                  Name = resourceName.ToString(),
                  UserPromptData = new DataItem { Text = promptChunks[i] }
              };
              await stream.WriteAsync(subsequentRequest);
              Console.WriteLine($"Sent chunk {i + 1}: \"{promptChunks[i]}\"");
          }

        // Signal that the client has finished sending requests.
          await stream.WriteCompleteAsync();
          Console.WriteLine("Client finished sending.");

        // --- Receive Responses ---
          Console.WriteLine("Receiving responses...");
        // This loop waits for responses until the server closes the stream.
          while (await stream.GetResponseStream().MoveNextAsync())
          {
              SanitizeUserPromptResponse response = stream.GetResponseStream().Current;
              if (response.SanitizationResult != null)
              {
                  var result = response.SanitizationResult;
                  Console.WriteLine("Received response:");
                  Console.WriteLine($"  Match State: {result.FilterMatchState}");
                  Console.WriteLine($"  Invocation Result: {result.InvocationResult}");
              }
              else
              {
                  Console.WriteLine("Received empty response.");
              }
          }
          Console.WriteLine("Stream finished and closed.");
      }
  }

Java

Untuk menjalankan kode ini, pertama-tama siapkan lingkungan pengembangan Java dan instal Model Armor Java SDK.

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 = "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();
        }
    }
}

Node.js

Untuk menjalankan kode ini, siapkan lingkungan pengembangan Node.js terlebih dahulu dan instal Model Armor Node.js SDK.

  const { ModelArmorClient } = require('@google-cloud/modelarmor').v1beta;

  async function streamSanitizeUserPromptExample() {
    const projectId = 'YOUR_PROJECT_ID';
    const location = 'LOCATION_ID';
    const templateId = 'YOUR_TEMPLATE_ID';

    const promptChunks = [
      'This is the first part of the user prompt. ',
      'This is the second part. ',
      'And this is the final part.'
    ];

    // Construct the regional REP endpoint
    const regionalEndpoint = `modelarmor.${location}.rep.googleapis.com`;
    console.log(`Using endpoint: ${regionalEndpoint}`);

    // Initialize the Model Armor client with options
    const modelArmorClient = new ModelArmorClient({
      apiEndpoint: regionalEndpoint,
    });

    const resourceName = `projects/${projectId}/locations/${location}/templates/${templateId}`;

    try {
      // Obtain the bidirectional stream object
      const stream = modelArmorClient.streamSanitizeUserPrompt();

      // Setup events for receiving responses
      stream.on('data', (response) => {
        if (response.sanitizationResult) {
          const result = response.sanitizationResult;
          console.log('Received response:');
          console.log(`  Match State: ${result.filterMatchState}`);
          console.log(`  Invocation Result: ${result.invocationResult}`);
        } else {
          console.log('Received empty response.');
        }
      });

      stream.on('error', (err) => {
        console.error('Stream error occurred:', err);
      });

      stream.on('end', () => {
        console.log('Stream finished and closed.');
      });

      console.log('Sending requests...');

      // --- Send First Request ---
      const firstRequest = {
        name: resourceName,
        userPromptData: {
          text: promptChunks[0]
        },
        streamingMode: 'STREAMING_MODE_BUFFERED' // Or 'STREAMING_MODE_REALTIME'
      };
      stream.write(firstRequest);
      console.log(`Sent chunk 1: "${promptChunks[0]}"`);

      // --- Send Subsequent Requests ---
      for (let i = 1; i < promptChunks.length; i++) {
        const subsequentRequest = {
          name: resourceName,
          userPromptData: {
            text: promptChunks[i]
          }
        };
        stream.write(subsequentRequest);
        console.log(`Sent chunk ${i + 1}: "${promptChunks[i]}"`);
      }

      // Signals gRPC end-of-writing from client
      stream.end();
      console.log('Client finished sending.');

    } catch (e) {
      console.error('Error during stream initialization:', e);
    }
  }

  // Execute logic
  streamSanitizeUserPromptExample();
  ```

PHP

Untuk menjalankan kode ini, pertama-tama siapkan lingkungan pengembangan PHP dan instal SDK PHP Model Armor.

  use Google\ApiCore\ApiException;
  use Google\ApiCore\BidiStream;
  use Google\Cloud\ModelArmor\V1beta\Client\ModelArmorClient;
  use Google\Cloud\ModelArmor\V1beta\DataItem;
  use Google\Cloud\ModelArmor\V1beta\SanitizeUserPromptRequest;
  use Google\Cloud\ModelArmor\V1beta\SanitizeUserPromptResponse;
  use Google\Cloud\ModelArmor\V1beta\StreamingMode;
  use Google\Cloud\ModelArmor\V1beta\FilterMatchState;
  use Google\Cloud\ModelArmor\V1beta\InvocationResult;

  function stream_sanitize_user_prompt_example()
  {
      $projectId = 'YOUR_PROJECT_ID';
      $location = 'LOCATION_ID';
      $templateId = 'YOUR_TEMPLATE_ID';

      $promptChunks = [
          "This is the first part of the user prompt. ",
          "This is the second part. ",
          "And this is the final part."
      ];

      // Construct the regional REP endpoint (without port)
      $regionalEndpoint = sprintf('modelarmor.%s.rep.googleapis.com', $location);
      echo "Using endpoint: " . $regionalEndpoint . PHP_EOL;

      try {
          // Initialize the Model Armor client
          $modelArmorClient = new ModelArmorClient([
              'apiEndpoint' => $regionalEndpoint,
          ]);

          // Construct the resource name.
          $resourceName = sprintf('projects/%s/locations/%s/templates/%s', $projectId, $location, $templateId);

          // Get a stream object for the StreamSanitizeUserPrompt API method.
          $stream = $modelArmorClient->streamSanitizeUserPrompt();

          echo "Sending requests..." . PHP_EOL;

          // --- Send First Request ---
          $firstRequest = (new SanitizeUserPromptRequest())
              ->setName($resourceName)
              ->setUserPromptData((new DataItem())->setText($promptChunks[0]))
          ->setStreamingMode(StreamingMode::STREAMING_MODE_BUFFERED); // Or STREAMING_MODE_REALTIME

          $stream->write($firstRequest);
          echo "Sent chunk 1: \"" . $promptChunks[0] . "\"" . PHP_EOL;

        // --- Send Subsequent Requests ---
          for ($i = 1; $i < count($promptChunks); $i++) {
              $subsequentRequest = (new SanitizeUserPromptRequest())
                  ->setName($resourceName)
                  ->setUserPromptData((new DataItem())->setText($promptChunks[$i]));
              $stream->write($subsequentRequest);
              echo "Sent chunk " . ($i + 1) . ": \"" . $promptChunks[$i] . "\"" . PHP_EOL;
          }

        // Signal that the client has finished sending requests.
          $stream->closeWrite();
          echo "Client finished sending." . PHP_EOL;

          // --- Receive Responses ---
          echo "Receiving responses..." . PHP_EOL;

        /** @var SanitizeUserPromptResponse $response */
          foreach ($stream->closeWriteAndReadAll() as $response) {
              if ($response->hasSanitizationResult()) {
                  $result = $response->getSanitizationResult();
                  echo "Received response:" . PHP_EOL;
                  echo "  Match State: " . FilterMatchState::name($result->getFilterMatchState()) . PHP_EOL;
                  echo "  Invocation Result: " . InvocationResult::name($result->getInvocationResult()) . PHP_EOL;
              } else {
                  echo "Received empty response." . PHP_EOL;
              }
          }
          echo "Stream finished and closed." . PHP_EOL;

      } catch (ApiException $e) {
          echo "Error during streaming: " . $e->getMessage() . PHP_EOL;
          foreach ($e->getMetadata() as $key => $value) {
              echo $key . ": " . print_r($value, true) . PHP_EOL;
          }
      } catch (Exception $e) {
          echo "An unexpected error occurred: " . $e->getMessage() . PHP_EOL;
      } finally {
          if (isset($modelArmorClient)) {
              $modelArmorClient->close();
          }
      }
  }

  stream_sanitize_user_prompt_example();

Python

Untuk menjalankan kode ini, siapkan lingkungan pengembangan Python dan instal Model Armor Python SDK.

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 = "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()

Pertimbangkan hal berikut saat membersihkan perintah atau respons teks streaming:

Untuk membersihkan konten secara efektif, pastikan setiap bagian tidak melebihi batas token.
Metode streaming Model Armor hanya mendukung input tekstual, bukan lampiran seperti gambar dan file.
Gunakan ID korelasi untuk melacak log pembersihan streaming untuk permintaan tertentu.
Metode streaming Model Armor tidak mendukung de-identifikasi Sensitive Data Protection.

Perintah berbasis file

Untuk membersihkan perintah yang disimpan dalam file, berikan konten file dalam format base64. Model Armor tidak otomatis mendeteksi jenis file. Anda harus menetapkan kolom byteDataType secara eksplisit untuk menunjukkan format file. Jika kolom tidak ada atau tidak ditentukan, permintaan akan gagal. Kemungkinan nilai byteDataType adalah PLAINTEXT_UTF8, PDF, WORD_DOCUMENT, EXCEL_DOCUMENT, POWERPOINT_DOCUMENT, TXT, dan CSV. De-identifikasi Perlindungan Data Sensitif tidak didukung untuk perintah berbasis 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"

Ganti kode berikut:

PROJECT_ID: ID project tempat template berada.
LOCATION: lokasi template.
TEMPLATE_ID: ID template.
FILE_TYPE: format file input.

Go

Untuk menjalankan kode ini, siapkan lingkungan pengembangan Go terlebih dahulu dan instal Model Armor Go SDK.


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#

Untuk menjalankan kode ini, siapkan lingkungan pengembangan C# terlebih dahulu dan instal Model Armor C# SDK.

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

Untuk menjalankan kode ini, pertama-tama siapkan lingkungan pengembangan Java dan instal Model Armor Java SDK.


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

Untuk menjalankan kode ini, siapkan lingkungan pengembangan Node.js terlebih dahulu dan instal Model Armor Node.js SDK.

/**
 * 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

Untuk menjalankan kode ini, pertama-tama siapkan lingkungan pengembangan PHP dan instal 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

Untuk menjalankan kode ini, siapkan lingkungan pengembangan Python dan instal Model Armor Python SDK.


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)

Konfigurasi Perlindungan Data Sensitif dasar

Model Armor terintegrasi dengan Sensitive Data Protection untuk membantu mencegah eksposur informasi pribadi yang tidak disengaja. Buat template dengan setelan Sensitive Data Protection dasar yang diaktifkan. Perlindungan Data Sensitif Dasar membantu Anda menyaring serangkaian infoType Sensitive Data Protection tetap.

InfoType Sensitive Data Protection berikut dipindai dalam perintah untuk semua region:

CREDIT_CARD_NUMBER: Nomor kartu kredit memiliki panjang 12 hingga 19 digit. Kartu ini digunakan untuk transaksi pembayaran secara global.
FINANCIAL_ACCOUNT_NUMBER: Nomor yang merujuk ke rekening keuangan tertentu, misalnya, nomor rekening bank atau nomor rekening pensiun.
GCP_CREDENTIALS: Google Cloud kredensial akun layanan. Kredensial yang dapat digunakan untuk melakukan autentikasi dengan {api_client_lib_name} dan akun layanan.
GCP_API_KEY: Google Cloud Kunci API. String terenkripsi yang digunakan saat memanggil API Google Cloud yang tidak perlu mengakses data pengguna pribadi.
PASSWORD: Hapus sandi teks di konfigurasi, kode, dan teks lainnya.

InfoType Sensitive Data Protection tambahan berikut dipindai dalam perintah untuk region berbasis AS:

US_SOCIAL_SECURITY_NUMBER: Nomor Jaminan Sosial (SSN) Amerika Serikat adalah nomor 9 digit yang dikeluarkan untuk warga negara AS, penduduk tetap, dan penduduk sementara. Detektor ini tidak akan cocok dengan angka yang berisi nol dalam kelompok digit mana pun (yaitu, 000-##-####, ###-00-####, atau ###-##-0000), dengan angka yang berisi 666 pada kelompok digit pertama, atau dengan angka yang digit pertamanya adalah 9.
US_INDIVIDUAL_TAXPAYER_IDENTIFICATION_NUMBER: Nomor Identifikasi Wajib Pajak Pribadi (ITIN) Amerika Serikat adalah jenis Nomor Identifikasi Pajak (TIN) yang dikeluarkan oleh Internal Revenue Service (IRS). ITIN adalah nomor pemrosesan pajak yang hanya tersedia untuk orang asing non-penduduk dan penduduk tertentu, pasangan, dan anak-anak mereka yang tidak bisa mendapatkan Nomor Jaminan Sosial (SSN).

Berikut adalah contoh konfigurasi dasar Sensitive Data Protection:

gcloud

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

Ganti kode berikut:

TEMPLATE_ID: ID template.
LOCATION: lokasi template.

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"

Ganti kode berikut:

PROJECT_ID: ID project tempat template berada.
LOCATION: lokasi template.
TEMPLATE_ID: ID template.

Go

Untuk menjalankan kode ini, siapkan lingkungan pengembangan Go terlebih dahulu dan instal Model Armor Go SDK.


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#

Untuk menjalankan kode ini, siapkan lingkungan pengembangan C# terlebih dahulu dan instal Model Armor C# SDK.

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

Untuk menjalankan kode ini, pertama-tama siapkan lingkungan pengembangan Java dan instal Model Armor Java SDK.


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

Untuk menjalankan kode ini, siapkan lingkungan pengembangan Node.js terlebih dahulu dan instal Model Armor Node.js SDK.

/**
 * 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

Untuk menjalankan kode ini, pertama-tama siapkan lingkungan pengembangan PHP dan instal 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

Untuk menjalankan kode ini, siapkan lingkungan pengembangan Python dan instal Model Armor Python SDK.


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}")

Gunakan template yang dibuat untuk menyaring perintah Anda. Berikut contohnya:

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"

Ganti kode berikut:

PROJECT_ID: ID project tempat template berada.
LOCATION: lokasi template.
TEMPLATE_ID: ID template.

Contoh ini menampilkan respons berikut:

{
  "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"
                }
              }
            }
          ]
        }
       }
      }
    ]
  }
}

Konfigurasi Sensitive Data Protection lanjutan

Model Armor menyaring perintah dan respons LLM menggunakan setelan konfigurasi Perlindungan Data Sensitif tingkat lanjut. Dengan begitu, Anda dapat menggunakan kemampuan Sensitive Data Protection di luar infoType yang ditawarkan dalam setelan Sensitive Data Protection dasar.

Untuk menggunakan filter lanjutan Sensitive Data Protection di Model Armor, template Sensitive Data Protection harus berada di lokasi cloud yang sama dengan template Model Armor.

gcloud

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

Ganti kode berikut:

TEMPLATE_ID: ID template.
LOCATION: lokasi template.

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"

Ganti kode berikut:

PROJECT_ID: ID project tempat template berada.
LOCATION: lokasi template.
TEMPLATE_ID: ID template.

Contoh ini menampilkan respons berikut:

{
  "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#

Untuk menjalankan kode ini, siapkan lingkungan pengembangan C# terlebih dahulu dan instal Model Armor C# SDK.

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

Untuk menjalankan kode ini, siapkan lingkungan pengembangan Go terlebih dahulu dan instal Model Armor Go SDK.


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

Untuk menjalankan kode ini, pertama-tama siapkan lingkungan pengembangan Java dan instal Model Armor Java SDK.


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

Untuk menjalankan kode ini, siapkan lingkungan pengembangan Node.js terlebih dahulu dan instal Model Armor Node.js SDK.

/**
 * 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

Untuk menjalankan kode ini, pertama-tama siapkan lingkungan pengembangan PHP dan instal 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

Untuk menjalankan kode ini, siapkan lingkungan pengembangan Python dan instal Model Armor Python SDK.


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}")

Gunakan template yang dibuat untuk menyaring perintah Anda. Berikut contohnya:

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"

Ganti kode berikut:

PROJECT_ID: ID project tempat template berada.
LOCATION: lokasi template.
TEMPLATE_ID: ID template.

Contoh ini menampilkan respons berikut:

{
  "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"]
        }
      }
      }
      ]
  }
}

Untuk mengetahui informasi tentang permintaan dan respons penyamaran gambar, lihat Menyamarkan gambar.

Membersihkan respons model

LLM terkadang dapat menghasilkan respons yang berbahaya. Untuk mengurangi risiko yang terkait dengan penggunaan LLM dalam aplikasi Anda, penting untuk membersihkan responsnya.

Berikut adalah contoh perintah untuk menyanitasi respons model di 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"

Ganti kode berikut:

PROJECT_ID: ID project tempat template berada.
LOCATION: lokasi template.

TEMPLATE_ID: ID template.

Contoh ini menampilkan respons berikut:

{
"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#

Untuk menjalankan kode ini, siapkan lingkungan pengembangan C# terlebih dahulu dan instal Model Armor C# SDK.

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

Untuk menjalankan kode ini, siapkan lingkungan pengembangan Go terlebih dahulu dan instal Model Armor Go SDK.


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

Untuk menjalankan kode ini, pertama-tama siapkan lingkungan pengembangan Java dan instal Model Armor Java SDK.


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

Untuk menjalankan kode ini, siapkan lingkungan pengembangan Node.js terlebih dahulu dan instal Model Armor Node.js SDK.

/**
 * 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

Untuk menjalankan kode ini, pertama-tama siapkan lingkungan pengembangan PHP dan instal 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

Untuk menjalankan kode ini, siapkan lingkungan pengembangan Python dan instal Model Armor Python SDK.


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)

Membersihkan respons model dengan deteksi multibahasa diaktifkan

Aktifkan deteksi multi-bahasa berdasarkan per permintaan dengan menyetel flag enableMultiLanguageDetection ke true untuk setiap respons. Secara opsional, Anda dapat menentukan bahasa sumber untuk hasil yang lebih akurat.

Jika Anda tidak menentukan bahasa sumber, Model Armor akan otomatis mendeteksi bahasa untuk memberikan dukungan multi-bahasa.
Jika Anda menentukan bahasa sumber, Model Armor akan menggunakan bahasa tersebut untuk mengevaluasi respons model dan tidak melakukan deteksi bahasa otomatis.

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"

Ganti kode berikut:

PROJECT_ID: ID project tempat template berada.
LOCATION: lokasi template.
TEMPLATE_ID: ID template.

Menyaring respons model di seluruh project

Untuk mengaktifkan pengelolaan keamanan AI terpusat, organisasi sering kali menyimpan template Model Armor di project khusus (project A: TEMPLATE_PROJECT_ID), sementara aplikasi mereka berjalan di project terpisah (project B).

Untuk mengizinkan akun layanan (CALLER_SERVICE_ACCOUNT) dari project B mengakses template di project A, Anda harus menambahkan binding kebijakan IAM ke project template.

Untuk memberikan izin lintas project yang diperlukan, jalankan perintah berikut:

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

Ganti kode berikut:

TEMPLATE_PROJECT_ID: ID project tempat template dihosting.
CALLER_SERVICE_ACCOUNT: akun layanan dari project yang membuat permintaan API.

Menyaring perintah dan respons Tetap teratur dengan koleksi Simpan dan kategorikan konten berdasarkan preferensi Anda.

Sebelum memulai

Mendapatkan izin yang diperlukan

Mengaktifkan API

Konsol

gcloud

Menetapkan penggantian endpoint API menggunakan gcloud CLI

Membersihkan perintah

Perintah teks

REST

Go

C#

Java

Node.js

PHP

Python

Praktik terbaik untuk membersihkan perintah dalam AI percakapan

Membersihkan perintah teks dengan deteksi multibahasa diaktifkan

Perintah yang berisi gambar

Menyamarkan gambar

Membersihkan perintah teks streaming

Go

C#

Java

Node.js

PHP

Python

Perintah berbasis file

REST

Go

C#

Java

Node.js

PHP

Python

Konfigurasi Perlindungan Data Sensitif dasar

gcloud

REST

Go

C#

Java

Node.js

PHP

Python

Konfigurasi Sensitive Data Protection lanjutan

gcloud

REST

C#

Go

Java

Node.js

PHP

Python

Membersihkan respons model

REST

C#

Go

Java

Node.js

PHP

Python

Membersihkan respons model dengan deteksi multibahasa diaktifkan

Menyaring respons model di seluruh project

Langkah berikutnya

Menyaring perintah dan respons