Cómo limpiar instrucciones y respuestas

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
}

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;
        }
    }
}

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;
    }
  }
}

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

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

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)

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
}

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;
        }
    }
}

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;
    }
  }
}

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

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

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)

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
}

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;
    }
}

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;
    }
  }
}

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

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

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

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;
    }
}

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
}

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;
    }
  }
}