> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.nvidia.com/nemo-platform/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.nvidia.com/nemo-platform/_mcp/server.

# Update Config

PATCH /apis/guardrails/v2/workspaces/{workspace}/configs/{name}
Content-Type: application/json

Update model metadata. If the request body has an empty field,
keep the old value.

Reference: https://docs.nvidia.com/nemo-platform/nemo-platform/v0.3.0/documentation/reference/api-reference/guardrails/update-config-apis-guardrails-v-2-workspaces-workspace-configs-name-patch

## Request

### Path parameters

- `workspace` (string, required)
- `name` (string, required)

### Body (application/json)

- `description` (string, optional) — Description of the guardrail config
- `data` (map from string to any, optional) — Guardrail configuration data

## Response

### 200

Successful Response

- `workspace` (string, required) — Workspace identifier
- `id` (string, required)
- `created_at` (datetime, required)
- `created_by` (string, required, nullable)
- `updated_at` (datetime, required)
- `updated_by` (string, required, nullable)
- `entity_id` (string, required) — Alias for id for backwards compatibility.
- `parent` (string, required) — Parent entity ID for nested entities.
- `db_version` (integer, required) — Database version of the entity for optimistic locking.
- `name` (string, optional, default: ) — Entity name within the workspace
- `project` (string, optional) — The name of the project associated with this entity.
- `description` (string, optional) — Description of the guardrail config
- `data` (object, optional) — Guardrail configuration data
  - `models` (list of object, optional) — The list of models used by the rails configuration.
    - `type` (string, required)
    - `engine` (string, required)
    - `model` (string, optional) — The model name. If using Inference Gateway, this should be the Model Entity reference ('workspace/model_name').
    - `parameters` (object, optional) — Additional parameters to configure how to interact with the model.
      - `base_url` (string, optional) — The URL to use for inference with this model.
      - `default_headers` (map from string to string, optional) — Custom HTTP headers to include in requests to this model. Each key-value pair represents a header name (key) and its default value (value). You can override the default value for a header by populating it in the request headers.
    - `mode` (enum, optional, default: chat) — Whether the mode is 'text' completion or 'chat' completion. Allowed values are 'chat' or 'text'.
      - Allowed values: `chat`, `text`
    - `cache` (object, optional) — Cache configuration for this specific model (primarily used for content safety models)
      - `enabled` (boolean, optional, default: false) — Whether caching is enabled (default: False - no caching)
      - `maxsize` (integer, optional, default: 50000) — Maximum number of entries in the cache per model
      - `stats` (object, optional) — Configuration for cache statistics tracking and logging
        - `enabled` (boolean, optional, default: false) — Whether cache statistics tracking is enabled
        - `log_interval` (double, optional) — Seconds between periodic cache stats logging to logs (None disables logging)
  - `instructions` (list of object, optional, default: [{"type":"general","content":"Below is a conversation between a helpful AI assistant and a user. The bot is designed to generate human-like text based on the input that it receives. The bot is talkative and provides lots of specific details. If the bot does not know the answer to a question, it truthfully says it does not know."}]) — List of instructions in natural language that the LLM should use.
    - `type` (string, required)
    - `content` (string, required)
  - `actions_server_url` (string, optional) — The URL of the actions server that should be used for the rails.
  - `sample_conversation` (string, optional, default: user "Hello there!"
  express greeting
bot express greeting
  "Hello! How can I assist you today?"
user "What can you do for me?"
  ask about capabilities
bot respond about capabilities
  "As an AI assistant, I can help you with a wide range of tasks. This includes question answering on various topics, generating text for various purposes and providing suggestions based on your preferences."
user "Tell me a bit about the history of NVIDIA."
  ask general question
bot response for general question
  "NVIDIA is a technology company that specializes in designing and manufacturing graphics processing units (GPUs) and other computer hardware. The company was founded in 1993 by Jen-Hsun Huang, Chris Malachowsky, and Curtis Priem."
user "tell me more"
  request more information
bot provide more information
  "Initially, the company focused on developing 3D graphics processing technology for the PC gaming market. In 1999, NVIDIA released the GeForce 256, the world's first GPU, which was a major breakthrough for the gaming industry. The company continued to innovate in the GPU space, releasing new products and expanding into other markets such as professional graphics, mobile devices, and artificial intelligence."
user "thanks"
  express appreciation
bot express appreciation and offer additional help
  "You're welcome. If you have any more questions or if there's anything else I can help you with, please don't hesitate to ask."
) — The sample conversation that should be used inside the prompts.
  - `prompts` (list of object, optional) — The prompts that should be used for the various LLM tasks.
    - `task` (string, required) — The id of the task associated with this prompt.
    - `content` (string, optional) — The content of the prompt, if it's a string.
    - `messages` (list of object or string, optional) — The list of messages included in the prompt. Used for chat models.
      - MessageTemplate
        - `type` (string, required) — The type of message, e.g., 'assistant', 'user', 'system'.
        - `content` (string, required) — The content of the message.
    - `models` (list of string, optional) — If specified, the prompt will be used only for the given LLM engines/models. The format is a list of strings with the format: \<engine> or \<engine>/\<model>.
    - `output_parser` (string, optional) — The name of the output parser to use for this prompt.
    - `max_length` (integer, optional, default: 16000) — The maximum length of the prompt in number of characters.
    - `mode` (string, optional, default: standard) — Corresponds to the `prompting_mode` for which this prompt is fetched. Default is 'standard'.
    - `stop` (list of string, optional) — If specified, will be configure stop tokens for models that support this.
    - `max_tokens` (integer, optional) — The maximum number of tokens that can be generated in the chat completion.
  - `prompting_mode` (string, optional, default: standard) — Allows choosing between different prompting strategies.
  - `lowest_temperature` (double, optional, default: 0.001) — The lowest temperature that should be used for the LLM.
  - `enable_multi_step_generation` (boolean, optional, default: false) — Whether to enable multi-step generation for the LLM.
  - `colang_version` (string, optional, default: 1.0) — The Colang version to use.
  - `custom_data` (map from string to any, optional) — Any custom configuration data that might be needed.
  - `rails` (object, optional) — Configuration for the various rails (input, output, etc.).
    - `config` (object, optional) — Configuration data for specific rails that are supported out-of-the-box.
      - `fact_checking` (object, optional) — Configuration data for the fact-checking rail.
        - `parameters` (map from string to any, optional)
        - `fallback_to_self_check` (boolean, optional, default: false) — Whether to fall back to self-check if another method fail.
      - `autoalign` (object, optional) — Configuration data for the AutoAlign guardrails API.
        - `parameters` (map from string to any, optional)
        - `input` (object, optional) — Input configuration for AutoAlign guardrails
          - `guardrails_config` (map from string to any, optional) — The guardrails configuration that is passed to the AutoAlign endpoint
        - `output` (object, optional) — Output configuration for AutoAlign guardrails
          - `guardrails_config` (map from string to any, optional) — The guardrails configuration that is passed to the AutoAlign endpoint
      - `patronus` (object, optional) — Configuration data for the Patronus Evaluate API.
        - `input` (object, optional) — Patronus Evaluate API configuration for an Input Guardrail
          - `evaluate_config` (object, optional) — Configuration passed to the Patronus Evaluate API
            - `success_strategy` (enum, optional, default: all_pass) — Strategy to determine whether the Patronus Evaluate API Guardrail passes or not.
            - `params` (map from string to any, optional) — Parameters to the Patronus Evaluate API
        - `output` (object, optional) — Patronus Evaluate API configuration for an Output Guardrail
          - `evaluate_config` (object, optional) — Configuration passed to the Patronus Evaluate API
            - `success_strategy` (enum, optional, default: all_pass) — Strategy to determine whether the Patronus Evaluate API Guardrail passes or not.
            - `params` (map from string to any, optional) — Parameters to the Patronus Evaluate API
      - `sensitive_data_detection` (object, optional) — Configuration for detecting sensitive data.
        - `recognizers` (list of map from string to any, optional) — Additional custom recognizers. Check out https://microsoft.github.io/presidio/tutorial/08_no_code/ for more details.
        - `input` (object, optional) — Configuration of the entities to be detected on the user input.
          - `entities` (list of string, optional) — The list of entities that should be detected. Check out https://microsoft.github.io/presidio/supported_entities/ forthe list of supported entities.
          - `mask_token` (string, optional, default: *) — The token that should be used to mask the sensitive data.
          - `score_threshold` (double, optional, default: 0.2) — The score threshold that should be used to detect the sensitive data.
        - `output` (object, optional) — Configuration of the entities to be detected on the bot output.
          - `entities` (list of string, optional) — The list of entities that should be detected. Check out https://microsoft.github.io/presidio/supported_entities/ forthe list of supported entities.
          - `mask_token` (string, optional, default: *) — The token that should be used to mask the sensitive data.
          - `score_threshold` (double, optional, default: 0.2) — The score threshold that should be used to detect the sensitive data.
        - `retrieval` (object, optional) — Configuration of the entities to be detected on retrieved relevant chunks.
          - `entities` (list of string, optional) — The list of entities that should be detected. Check out https://microsoft.github.io/presidio/supported_entities/ forthe list of supported entities.
          - `mask_token` (string, optional, default: *) — The token that should be used to mask the sensitive data.
          - `score_threshold` (double, optional, default: 0.2) — The score threshold that should be used to detect the sensitive data.
      - `regex_detection` (object, optional) — Configuration for regex pattern detection.
        - `input` (object, optional) — Configuration for regex patterns to detect on user input.
          - `patterns` (list of string, optional) — List of regex patterns to match against the text.
          - `case_insensitive` (boolean, optional, default: false) — Whether to perform case-insensitive matching.
        - `output` (object, optional) — Configuration for regex patterns to detect on bot output.
          - `patterns` (list of string, optional) — List of regex patterns to match against the text.
          - `case_insensitive` (boolean, optional, default: false) — Whether to perform case-insensitive matching.
        - `retrieval` (object, optional) — Configuration for regex patterns to detect on retrieved relevant chunks.
          - `patterns` (list of string, optional) — List of regex patterns to match against the text.
          - `case_insensitive` (boolean, optional, default: false) — Whether to perform case-insensitive matching.
      - `jailbreak_detection` (object, optional) — Configuration for jailbreak detection.
        - `server_endpoint` (string, optional) — The endpoint for the jailbreak detection heuristics/model container.
        - `length_per_perplexity_threshold` (double, optional, default: 89.79) — The length/perplexity threshold.
        - `prefix_suffix_perplexity_threshold` (double, optional, default: 1845.65) — The prefix/suffix perplexity threshold.
        - `nim_base_url` (string, optional) — Base URL for jailbreak detection model. Example: http://localhost:8000/v1
        - `nim_server_endpoint` (string, optional, default: classify) — Classification path uri. Defaults to 'classify' for NemoGuard JailbreakDetect.
        - `api_key` (string, optional) — Secret String with API key for use in Jailbreak requests. Takes precedence over api_key_env_var
        - `api_key_env_var` (string, optional) — Environment variable containing API key for jailbreak detection model
        - `nim_url` (string, optional, deprecated) — DEPRECATED: Use nim_base_url instead
        - `nim_port` (integer, optional, deprecated) — DEPRECATED: Include port in nim_base_url instead
        - `embedding` (string, optional, deprecated)
      - `injection_detection` (object, optional) — Configuration for injection detection.
        - `injections` (list of string, optional) — The list of injection types to detect. Options are 'sqli', 'template', 'code', 'xss'.Currently, only SQL injection, template injection, code injection, and markdown cross-site scripting are supported. Custom rules can be added, provided they are in the `yara_path` and have a `.yara` file extension.
        - `action` (string, optional, default: reject) — Action to take. Options are 'reject' to offer a rejection message, 'omit' to mask the offending content, and 'sanitize' to pass the content as-is in the safest way. These options are listed in descending order of relative safety. 'sanitize' is not implemented at this time.
        - `yara_rules` (map from string to string, optional) — Dictionary mapping rule names to YARA rule strings. If provided, these rules will be used instead of loading rules from yara_path. Each rule should be a valid YARA rule string.
      - `privateai` (object, optional) — Configuration for Private AI.
        - `server_endpoint` (string, optional) — The endpoint for the private AI detection server.
        - `input` (object, optional) — Configuration of the entities to be detected on the user input.
          - `entities` (list of string, optional) — The list of entities that should be detected.
        - `output` (object, optional) — Configuration of the entities to be detected on the bot output.
          - `entities` (list of string, optional) — The list of entities that should be detected.
        - `retrieval` (object, optional) — Configuration of the entities to be detected on retrieved relevant chunks.
          - `entities` (list of string, optional) — The list of entities that should be detected.
      - `gliner` (object, optional) — Configuration for GLiNER PII detection.
        - `server_endpoint` (string, optional, default: http://localhost:8000/v1/chat/completions) — The endpoint for the GLiNER detection server. By default, this is for a locally hosted NIM instance running the GLiNER model. Changed from http://localhost:1235/v1/extract (custom server) to http://localhost:8000/v1/chat/completions (NIM) in this release. If you use the custom gliner_server, set this explicitly to http://localhost:1235/v1/extract.
        - `model` (string, optional, default: nvidia/gliner-pii) — Model identifier sent in NIM API requests (only used when server_endpoint ends with /v1/chat/completions).
        - `api_key_env_var` (string, optional) — Name of the environment variable containing the API key for authenticated endpoints (e.g., NVIDIA_API_KEY).
        - `threshold` (double, optional, default: 0.5) — Confidence threshold for entity detection (0.0 to 1.0).
        - `chunk_length` (integer, optional, default: 384) — Length of text chunks for processing.
        - `overlap` (integer, optional, default: 128) — Overlap between chunks.
        - `flat_ner` (boolean, optional, default: false) — Whether to use flat NER mode. Setting to False allows for nested entities.
        - `input` (object, optional) — Configuration of the entities to be detected on the user input.
          - `entities` (list of string, optional) — The list of entity labels to detect (e.g., 'email', 'phone_number', 'ssn').
        - `output` (object, optional) — Configuration of the entities to be detected on the bot output.
          - `entities` (list of string, optional) — The list of entity labels to detect (e.g., 'email', 'phone_number', 'ssn').
        - `retrieval` (object, optional) — Configuration of the entities to be detected on retrieved relevant chunks.
          - `entities` (list of string, optional) — The list of entity labels to detect (e.g., 'email', 'phone_number', 'ssn').
      - `polygraf` (object, optional) — Configuration for Polygraf PII detection.
        - `server_endpoint` (string, optional, default: http://localhost:8000/v1/pii/text-detect) — The endpoint for the Polygraf detection server.
        - `input` (object, optional) — Configuration of the entities to be detected on the user input.
          - `entities` (list of string, optional) — The list of entities that should be detected.
        - `output` (object, optional) — Configuration of the entities to be detected on the bot output.
          - `entities` (list of string, optional) — The list of entities that should be detected.
        - `retrieval` (object, optional) — Configuration of the entities to be detected on retrieved relevant chunks.
          - `entities` (list of string, optional) — The list of entities that should be detected.
      - `fiddler` (object, optional) — Configuration for Fiddler Guardrails.
        - `fiddler_endpoint` (string, optional, default: http://localhost:8080/process/text) — The global endpoint for Fiddler Guardrails requests.
        - `safety_threshold` (double, optional, default: 0.1) — Fiddler Guardrails safety detection threshold.
        - `faithfulness_threshold` (double, optional, default: 0.05) — Fiddler Guardrails faithfulness detection threshold.
      - `clavata` (object, optional) — Configuration for Clavata.
        - `server_endpoint` (string, optional, default: https://gateway.app.clavata.ai:8443) — The endpoint for the Clavata API
        - `policies` (map from string to string, optional) — A dictionary of policy aliases and their corresponding IDs.
        - `label_match_logic` (enum, optional, default: ANY) — The logic to use when deciding whether the evaluation matched. If ANY, only one of the configured labels needs to be found in the input or output. If ALL, all configured labels must be found in the input or output.
          - Allowed values: `ANY`, `ALL`
        - `input` (object, optional) — Clavata configuration for an Input Guardrail
          - `policy` (string, required) — The policy alias to use when evaluating inputs or outputs.
          - `labels` (list of string, optional) — A list of labels to match against the policy. If no labels are provided, the overall policy result will be returned. If labels are provided, only hits on the provided labels will be considered a hit.
        - `output` (object, optional) — Clavata configuration for an Output Guardrail
          - `policy` (string, required) — The policy alias to use when evaluating inputs or outputs.
          - `labels` (list of string, optional) — A list of labels to match against the policy. If no labels are provided, the overall policy result will be returned. If labels are provided, only hits on the provided labels will be considered a hit.
      - `crowdstrike_aidr` (object, optional) — Configuration for CrowdStrike AIDR.
        - `timeout` (double, optional, default: 30) — Timeout in seconds for API requests to CrowdStrike AIDR
      - `pangea` (object, optional) — Configuration for Pangea.
        - `input` (object, optional) — Pangea configuration for an Input Guardrail
          - `recipe` (string, required) — Recipe key of a configuration of data types and settings defined in the Pangea User Console. It specifies the rules that are to be applied to the text, such as defang malicious URLs.
        - `output` (object, optional) — Pangea configuration for an Output Guardrail
          - `recipe` (string, required) — Recipe key of a configuration of data types and settings defined in the Pangea User Console. It specifies the rules that are to be applied to the text, such as defang malicious URLs.
      - `guardrails_ai` (object, optional) — Configuration for Guardrails AI validators.
        - `validators` (list of object, optional) — List of Guardrails AI validators to apply. Each validator can have its own parameters and metadata.
          - `name` (string, required) — Unique identifier or import path for the Guardrails AI validator (e.g., 'toxic_language', 'pii', 'regex_match', or 'guardrails/competitor_check').
          - `parameters` (map from string to any, optional) — Parameters to pass to the validator during initialization (e.g., threshold, regex pattern).
          - `metadata` (map from string to any, optional) — Metadata to pass to the validator during validation (e.g., valid_topics, context).
      - `trend_micro` (object, optional) — Configuration for Trend Micro.
        - `v1_url` (string, optional, default: https://api.xdr.trendmicro.com/v3.0/aiSecurity/applyGuardrails) — The endpoint for the Trend Micro AI Guard API. For other regions, use: [https://api.\{region}.xdr.trendmicro.com/v3.0/aiSecurity/applyGuardrails](https://api.\{region}.xdr.trendmicro.com/v3.0/aiSecurity/applyGuardrails) where region is eu, jp, au, in, sg, or mea.
        - `api_key_env_var` (string, optional) — Environment variable containing API key for Trend Micro AI Guard
        - `application_name` (string, optional, default: nemo-guardrails) — Application name for TMV1-Application-Name header (REQUIRED). Must contain only letters, numbers, hyphens, and underscores, with a maximum length of 64 characters.
        - `detailed_response` (boolean, optional, default: false) — If True, returns detailed AI Guard results with confidence scores (Prefer: return=representation). If False, returns minimal response with only action and reasons (Prefer: return=minimal).
      - `ai_defense` (object, optional) — Configuration for Cisco AI Defense.
        - `timeout` (double, optional, default: 30) — Timeout in seconds for API requests to AI Defense service
        - `fail_open` (boolean, optional, default: false) — If True, allow content when AI Defense API call fails (fail open). If False, block content when API call fails (fail closed). Does not affect missing configuration validation.
      - `content_safety` (object, optional) — Configuration for content safety rails.
        - `multilingual` (object, optional) — Configuration for multilingual refusal messages.
          - `enabled` (boolean, optional, default: false) — If True, detect the language of user input and return refusal messages in the same language. Supported languages: en (English), es (Spanish), zh (Chinese), de (German), fr (French), hi (Hindi), ja (Japanese), ar (Arabic), th (Thai).
          - `refusal_messages` (map from string to string, optional) — Custom refusal messages per language code. If not specified, built-in defaults are used. Example: \{'en': 'Sorry, I cannot help.', 'es': 'Lo siento, no puedo ayudar.'}
        - `reasoning` (object, optional) — Configuration for reasoning mode in content safety models.
          - `enabled` (boolean, optional, default: false) — If True, enable reasoning mode (with \<think> traces) for content safety models. If False, use low-latency mode without reasoning traces.
      - `hf_classifier` (map from string to object, optional) — Named HF classifier configurations. Keys are classifier names referenced by flows.
        - `engine`: `fms` (RemoteHFClassifierConfig)
          - `base_url` (string, required) — Base URL for the inference server (e.g. 'http://host:8000').
          - `model` (string, required) — HF model ID, local path, or server-side model identifier.
          - `api_key_env_var` (string, optional) — Environment variable name holding the API key. Resolved at runtime to an Authorization: Bearer header.
          - `blocked_labels` (list of string, optional) — Labels that should trigger blocking when detected above threshold.
          - `parameters` (map from string to any, optional) — Remote backend parameters: 'timeout' (float, seconds), 'verify_ssl' (bool), 'ca_cert'/'client_cert'/'client_key' (str, paths). Note: 'ca_cert' replaces (not extends) system CAs; use a concatenated bundle to include both custom and system CAs.
          - `threshold` (double, optional, default: 0.5) — Minimum score for a detection to trigger blocking.
        - `engine`: `kserve` (RemoteHFClassifierConfig)
          - `base_url` (string, required) — Base URL for the inference server (e.g. 'http://host:8000').
          - `model` (string, required) — HF model ID, local path, or server-side model identifier.
          - `api_key_env_var` (string, optional) — Environment variable name holding the API key. Resolved at runtime to an Authorization: Bearer header.
          - `blocked_labels` (list of string, optional) — Labels that should trigger blocking when detected above threshold.
          - `parameters` (map from string to any, optional) — Remote backend parameters: 'timeout' (float, seconds), 'verify_ssl' (bool), 'ca_cert'/'client_cert'/'client_key' (str, paths). Note: 'ca_cert' replaces (not extends) system CAs; use a concatenated bundle to include both custom and system CAs.
          - `threshold` (double, optional, default: 0.5) — Minimum score for a detection to trigger blocking.
        - `engine`: `local` (LocalHFClassifierConfig)
          - `model` (string, required) — HF model ID, local path, or server-side model identifier.
          - `blocked_labels` (list of string, optional) — Labels that should trigger blocking when detected above threshold.
          - `parameters` (map from string to any, optional) — Forwarded as kwargs to transformers.pipeline() (e.g. device, dtype, trust_remote_code, token, revision, aggregation_strategy).
          - `task` (enum, optional, default: text-classification) — HuggingFace pipeline task type.
            - Allowed values: `text-classification`, `token-classification`
          - `threshold` (double, optional, default: 0.5) — Minimum score for a detection to trigger blocking.
        - `engine`: `vllm` (RemoteHFClassifierConfig)
          - `base_url` (string, required) — Base URL for the inference server (e.g. 'http://host:8000').
          - `model` (string, required) — HF model ID, local path, or server-side model identifier.
          - `api_key_env_var` (string, optional) — Environment variable name holding the API key. Resolved at runtime to an Authorization: Bearer header.
          - `blocked_labels` (list of string, optional) — Labels that should trigger blocking when detected above threshold.
          - `parameters` (map from string to any, optional) — Remote backend parameters: 'timeout' (float, seconds), 'verify_ssl' (bool), 'ca_cert'/'client_cert'/'client_key' (str, paths). Note: 'ca_cert' replaces (not extends) system CAs; use a concatenated bundle to include both custom and system CAs.
          - `threshold` (double, optional, default: 0.5) — Minimum score for a detection to trigger blocking.
      - `context_bloat_detection` (object, optional) — Configuration for context bloat / context manipulation detection.
        - `max_chars` (integer, optional, default: 5000) — Size cap in characters. Inputs exceeding this are flagged.
        - `min_chars` (integer, optional, default: 50) — Minimum characters before entropy/run/repetition checks apply. Shorter texts are only checked against size cap.
        - `min_entropy` (double, optional, default: 3.5) — Shannon entropy floor (bits/char). English prose is ~4.0-4.5.
        - `max_repetition_ratio` (double, optional, default: 0.4) — Max fraction of repeated n-grams (0.0-1.0).
        - `ngram_size` (integer, optional, default: 3) — Size of n-grams used for repetition detection.
        - `max_run_ratio` (double, optional, default: 0.1) — Max fraction of text that is the longest single-char run.
        - `action` (enum, optional, default: reject) — Action on detection: 'reject', 'truncate', or 'warn'.
          - Allowed values: `reject`, `truncate`, `warn`
    - `input` (object, optional) — Configuration of the input rails.
      - `parallel` (boolean, optional, default: false) — If True, the input rails are executed in parallel.
      - `flows` (list of string, optional) — The names of all the flows that implement input rails.
    - `output` (object, optional) — Configuration of the output rails.
      - `parallel` (boolean, optional, default: false) — If True, the output rails are executed in parallel.
      - `flows` (list of string, optional) — The names of all the flows that implement output rails.
      - `streaming` (object, optional) — Configuration for streaming output rails.
        - `enabled` (boolean, optional, default: true) — Enables streaming mode when True.
        - `chunk_size` (integer, optional, default: 200) — The number of tokens in each processing chunk. This is the size of the token block on which output rails are applied.
        - `context_size` (integer, optional, default: 50) — The number of tokens carried over from the previous chunk to provide context for continuity in processing.
        - `stream_first` (boolean, optional, default: true) — If True, token chunks are streamed immediately before output rails are applied.
      - `apply_to_reasoning_traces` (boolean, optional, default: false) — If True, output rails will apply guardrails to both reasoning traces and output response. If False, output rails will only apply guardrails to the output response excluding the reasoning traces, thus keeping reasoning traces unaltered.
    - `retrieval` (object, optional) — Configuration of the retrieval rails.
      - `flows` (list of string, optional) — The names of all the flows that implement retrieval rails.
    - `dialog` (object, optional) — Configuration of the dialog rails.
      - `single_call` (object, optional) — Configuration for the single LLM call option.
        - `enabled` (boolean, optional, default: false)
        - `fallback_to_multiple_calls` (boolean, optional, default: true) — Whether to fall back to multiple calls if a single call is not possible.
      - `user_messages` (object, optional) — Configuration for how the user messages are interpreted.
        - `embeddings_only` (boolean, optional, default: false) — Whether to use only embeddings for computing the user canonical form messages.
        - `embeddings_only_similarity_threshold` (double, optional) — The similarity threshold to use when using only embeddings for computing the user canonical form messages.
        - `embeddings_only_fallback_intent` (string, optional) — Defines the fallback intent when the similarity is below the threshold. If set to None, the user intent is computed normally using the LLM. If set to a string value, that string is used as the intent.
    - `actions` (object, optional) — Configuration of action rails.
      - `instant_actions` (list of string, optional) — The names of all actions which should finish instantly.
    - `tool_output` (object, optional) — Configuration of tool output rails.
      - `flows` (list of string, optional) — The names of all the flows that implement tool output rails.
      - `parallel` (boolean, optional, default: false) — If True, the tool output rails are executed in parallel.
    - `tool_input` (object, optional) — Configuration of tool input rails.
      - `flows` (list of string, optional) — The names of all the flows that implement tool input rails.
      - `parallel` (boolean, optional, default: false) — If True, the tool input rails are executed in parallel.
  - `enable_rails_exceptions` (boolean, optional, default: false) — If set, the pre-defined guardrails raise exceptions instead of returning pre-defined messages.
  - `passthrough` (boolean, optional) — Whether the original prompt should pass through the guardrails configuration as is. This means it will not be altered in any way.
  - `tracing` (object, optional) — Configuration for tracing.
    - `enabled` (boolean, optional, default: false)
    - `adapters` (list of object, optional) — The list of tracing adapters to use. If not specified, the default adapters are used.
      - `name` (string, optional, default: FileSystem) — The name of the adapter.
    - `span_format` (string, optional, default: opentelemetry) — The span format to use. Options are 'legacy' (simple metrics) or 'opentelemetry' (OpenTelemetry semantic conventions).
    - `enable_content_capture` (boolean, optional, default: false) — Capture prompts and responses (user/assistant/tool message content) in tracing/telemetry events. Disabled by default for privacy and alignment with OpenTelemetry GenAI semantic conventions. WARNING: Enabling this may include PII and sensitive data in your telemetry backend.

## Examples

**Request**

```json
{}
```

**Response**

```json
{
  "workspace": "string",
  "id": "string",
  "created_at": "2024-01-15T09:30:00Z",
  "created_by": "string",
  "updated_at": "2024-01-15T09:30:00Z",
  "updated_by": "string",
  "entity_id": "string",
  "parent": "string",
  "db_version": 1,
  "name": "",
  "project": "string",
  "description": "string",
  "data": {
    "models": [
      {
        "type": "string",
        "engine": "string",
        "model": "string",
        "parameters": {
          "base_url": "string",
          "default_headers": {}
        },
        "mode": "chat",
        "cache": {
          "enabled": false,
          "maxsize": 50000,
          "stats": {
            "enabled": false,
            "log_interval": 1.1
          }
        }
      }
    ],
    "instructions": [
      {
        "type": "string",
        "content": "string"
      }
    ],
    "actions_server_url": "string",
    "sample_conversation": "user \"Hello there!\"\n  express greeting\nbot express greeting\n  \"Hello! How can I assist you today?\"\nuser \"What can you do for me?\"\n  ask about capabilities\nbot respond about capabilities\n  \"As an AI assistant, I can help you with a wide range of tasks. This includes question answering on various topics, generating text for various purposes and providing suggestions based on your preferences.\"\nuser \"Tell me a bit about the history of NVIDIA.\"\n  ask general question\nbot response for general question\n  \"NVIDIA is a technology company that specializes in designing and manufacturing graphics processing units (GPUs) and other computer hardware. The company was founded in 1993 by Jen-Hsun Huang, Chris Malachowsky, and Curtis Priem.\"\nuser \"tell me more\"\n  request more information\nbot provide more information\n  \"Initially, the company focused on developing 3D graphics processing technology for the PC gaming market. In 1999, NVIDIA released the GeForce 256, the world's first GPU, which was a major breakthrough for the gaming industry. The company continued to innovate in the GPU space, releasing new products and expanding into other markets such as professional graphics, mobile devices, and artificial intelligence.\"\nuser \"thanks\"\n  express appreciation\nbot express appreciation and offer additional help\n  \"You're welcome. If you have any more questions or if there's anything else I can help you with, please don't hesitate to ask.\"\n",
    "prompts": [
      {
        "task": "string",
        "content": "string",
        "messages": [
          {
            "type": "string",
            "content": "string"
          }
        ],
        "models": [
          "string"
        ],
        "output_parser": "string",
        "max_length": 16000,
        "mode": "standard",
        "stop": [
          "string"
        ],
        "max_tokens": 1
      }
    ],
    "prompting_mode": "standard",
    "lowest_temperature": 0.001,
    "enable_multi_step_generation": false,
    "colang_version": "1.0",
    "custom_data": {},
    "rails": {
      "config": {
        "fact_checking": {
          "parameters": {},
          "fallback_to_self_check": false
        },
        "autoalign": {
          "parameters": {},
          "input": {
            "guardrails_config": {}
          },
          "output": {
            "guardrails_config": {}
          }
        },
        "patronus": {
          "input": {
            "evaluate_config": {
              "success_strategy": "all_pass",
              "params": {}
            }
          },
          "output": {
            "evaluate_config": {
              "success_strategy": "all_pass",
              "params": {}
            }
          }
        },
        "sensitive_data_detection": {
          "recognizers": [
            {}
          ],
          "input": {
            "entities": [
              "string"
            ],
            "mask_token": "*",
            "score_threshold": 0.2
          },
          "output": {
            "entities": [
              "string"
            ],
            "mask_token": "*",
            "score_threshold": 0.2
          },
          "retrieval": {
            "entities": [
              "string"
            ],
            "mask_token": "*",
            "score_threshold": 0.2
          }
        },
        "regex_detection": {
          "input": {
            "patterns": [
              "string"
            ],
            "case_insensitive": false
          },
          "output": {
            "patterns": [
              "string"
            ],
            "case_insensitive": false
          },
          "retrieval": {
            "patterns": [
              "string"
            ],
            "case_insensitive": false
          }
        },
        "jailbreak_detection": {
          "server_endpoint": "string",
          "length_per_perplexity_threshold": 89.79,
          "prefix_suffix_perplexity_threshold": 1845.65,
          "nim_base_url": "string",
          "nim_server_endpoint": "classify",
          "api_key_env_var": "string",
          "nim_url": "string",
          "nim_port": 1,
          "embedding": "string"
        },
        "injection_detection": {
          "injections": [
            "string"
          ],
          "action": "reject",
          "yara_rules": {}
        },
        "privateai": {
          "server_endpoint": "string",
          "input": {
            "entities": [
              "string"
            ]
          },
          "output": {
            "entities": [
              "string"
            ]
          },
          "retrieval": {
            "entities": [
              "string"
            ]
          }
        },
        "gliner": {
          "server_endpoint": "http://localhost:8000/v1/chat/completions",
          "model": "nvidia/gliner-pii",
          "api_key_env_var": "string",
          "threshold": 0.5,
          "chunk_length": 384,
          "overlap": 128,
          "flat_ner": false,
          "input": {
            "entities": [
              "string"
            ]
          },
          "output": {
            "entities": [
              "string"
            ]
          },
          "retrieval": {
            "entities": [
              "string"
            ]
          }
        },
        "polygraf": {
          "server_endpoint": "http://localhost:8000/v1/pii/text-detect",
          "input": {
            "entities": [
              "string"
            ]
          },
          "output": {
            "entities": [
              "string"
            ]
          },
          "retrieval": {
            "entities": [
              "string"
            ]
          }
        },
        "fiddler": {
          "fiddler_endpoint": "http://localhost:8080/process/text",
          "safety_threshold": 0.1,
          "faithfulness_threshold": 0.05
        },
        "clavata": {
          "server_endpoint": "https://gateway.app.clavata.ai:8443",
          "policies": {},
          "label_match_logic": "ANY",
          "input": {
            "policy": "string",
            "labels": [
              "string"
            ]
          },
          "output": {
            "policy": "string",
            "labels": [
              "string"
            ]
          }
        },
        "crowdstrike_aidr": {
          "timeout": 30
        },
        "pangea": {
          "input": {
            "recipe": "string"
          },
          "output": {
            "recipe": "string"
          }
        },
        "guardrails_ai": {
          "validators": [
            {
              "name": "string",
              "parameters": {},
              "metadata": {}
            }
          ]
        },
        "trend_micro": {
          "v1_url": "https://api.xdr.trendmicro.com/v3.0/aiSecurity/applyGuardrails",
          "api_key_env_var": "string",
          "application_name": "nemo-guardrails",
          "detailed_response": false
        },
        "ai_defense": {
          "timeout": 30,
          "fail_open": false
        },
        "content_safety": {
          "multilingual": {
            "enabled": false,
            "refusal_messages": {}
          },
          "reasoning": {
            "enabled": false
          }
        },
        "hf_classifier": {},
        "context_bloat_detection": {
          "max_chars": 5000,
          "min_chars": 50,
          "min_entropy": 3.5,
          "max_repetition_ratio": 0.4,
          "ngram_size": 3,
          "max_run_ratio": 0.1,
          "action": "reject"
        }
      },
      "input": {
        "parallel": false,
        "flows": [
          "string"
        ]
      },
      "output": {
        "parallel": false,
        "flows": [
          "string"
        ],
        "streaming": {
          "enabled": true,
          "chunk_size": 200,
          "context_size": 50,
          "stream_first": true
        },
        "apply_to_reasoning_traces": false
      },
      "retrieval": {
        "flows": [
          "string"
        ]
      },
      "dialog": {
        "single_call": {
          "enabled": false,
          "fallback_to_multiple_calls": true
        },
        "user_messages": {
          "embeddings_only": false,
          "embeddings_only_similarity_threshold": 0.5,
          "embeddings_only_fallback_intent": "string"
        }
      },
      "actions": {
        "instant_actions": [
          "string"
        ]
      },
      "tool_output": {
        "flows": [
          "string"
        ],
        "parallel": false
      },
      "tool_input": {
        "flows": [
          "string"
        ],
        "parallel": false
      }
    },
    "enable_rails_exceptions": false,
    "passthrough": true,
    "tracing": {
      "enabled": false,
      "adapters": [
        {
          "name": "FileSystem"
        }
      ],
      "span_format": "opentelemetry",
      "enable_content_capture": false
    }
  }
}
```

**SDK Code**

```python
import requests

url = "https://api.example.com/apis/guardrails/v2/workspaces/workspace/configs/name"

payload = {}
headers = {"Content-Type": "application/json"}

response = requests.patch(url, json=payload, headers=headers)

print(response.json())
```

```javascript
const url = 'https://api.example.com/apis/guardrails/v2/workspaces/workspace/configs/name';
const options = {method: 'PATCH', headers: {'Content-Type': 'application/json'}, body: '{}'};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://api.example.com/apis/guardrails/v2/workspaces/workspace/configs/name"

	payload := strings.NewReader("{}")

	req, _ := http.NewRequest("PATCH", url, payload)

	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby
require 'uri'
require 'net/http'

url = URI("https://api.example.com/apis/guardrails/v2/workspaces/workspace/configs/name")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Patch.new(url)
request["Content-Type"] = 'application/json'
request.body = "{}"

response = http.request(request)
puts response.read_body
```

```java
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.patch("https://api.example.com/apis/guardrails/v2/workspaces/workspace/configs/name")
  .header("Content-Type", "application/json")
  .body("{}")
  .asString();
```

```php
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('PATCH', 'https://api.example.com/apis/guardrails/v2/workspaces/workspace/configs/name', [
  'body' => '{}',
  'headers' => [
    'Content-Type' => 'application/json',
  ],
]);

echo $response->getBody();
```

```csharp
using RestSharp;

var client = new RestClient("https://api.example.com/apis/guardrails/v2/workspaces/workspace/configs/name");
var request = new RestRequest(Method.PATCH);
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let headers = ["Content-Type": "application/json"]
let parameters = [] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://api.example.com/apis/guardrails/v2/workspaces/workspace/configs/name")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PATCH"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```