> ## Documentation Index
> Fetch the complete documentation index at: https://docs-classic.cognigy.com/llms.txt
> Use this file to discover all available pages before exploring further.

# LLM Prompt

> The Cognigy LLM Prompt Node integrates Generative AI into your AI Agent to generate answers. This Node supports tools, including MCP tools, image recognition, and conversation transcripts.

[Updated in 2026.21.0](https://docs-classic.cognigy.com/release-notes/2026.20.md)

![LLM Prompt Node](https://mintcdn.com/cognigy-docs-legacy/sbu8K_1z3Hht9e7i/_assets/ai/develop/node-reference/services/llm-prompt.png?fit=max\&auto=format\&n=sbu8K_1z3Hht9e7i\&q=85\&s=65abbf54294562c2bb7cf352e1a29bd3)

## Description

> [!WARNING]
>
> As of Cognigy 2026.18.0, the following parameters are deprecated:
>
> * **Sampling Method**
> * **Temperature**
> * **Top Percentage**
> * **Maximal Tokens**
> * **Frequency Penalty**
> * **Presence Penalty**
> * **Use Stops**
> * **Stops**
> * **Seed**
>
> The removal is planned for April 2027. For models that don't support these parameters, activate the **Ignore deprecated parameters** toggle to exclude them from the request to the LLM provider. Otherwise, the request to the LLM provider might fail. If you plan to use these parameters, migrate them to the [Custom Options section](#custom-options) and activate the **Ignore deprecated parameters** toggle. Otherwise, Custom Options might not override them for every provider and model combination.
>
> For example, OpenAI models such as `gpt-5`, `gpt-5.1`, and `gpt-5.2` don't support these parameters. Similar models from other LLM providers might also not support these parameters. Check your LLM provider's documentation for model-specific support.

The LLM Prompt Node lets you configure LLMs for your AI Agent and their system prompt to generate both text and structured content. With this Node, you can also:

* Add [tools](#tools) for specific use cases.
* Activate [image handling](#image-handling).
* Set advanced LLM request options.

Additionally, you can refer to your AI Agent configuration using the [Load AI Agent Node](https://docs-classic.cognigy.com/ai/agents/develop/node-reference/ai/load-ai-agent.md).

> [!TIP]
>
> In comparison to the [AI Agent Node](https://docs-classic.cognigy.com/ai/agents/develop/node-reference/ai/ai-agent.md), the LLM Prompt Node doesn't include the [AI Agent persona](https://docs-classic.cognigy.com/ai/agents/develop/persona.md). If you want to have centralized control over the personality, tone, and voice of different AI Agents, use different AI Agent Nodes with the same persona.

## Prerequisites

* Configure an LLM provider in the [Project settings](https://docs-classic.cognigy.com/ai/agents/develop/gen-ai-and-llms/generative-ai.md).

## Limitations

* The **Description** and **Enum** fields in the **Parameters** section of an [AI Agent tool](#parameters) don't support CognigyScript.

## Parameters

### Parent Node

> [accordion] Large Language Model
>
> The preselected **Default** model is the model configured in the **Generative AI Settings** section of the [Project settings](https://docs-classic.cognigy.com/ai/administer/access/project-settings.md#generative-ai-settings).
>
> To use another model in this Node, select a different one from the list or override the default model with the [Custom Options parameter](#custom-options).

> [accordion] System Prompt
>
> The system prompt is the message sent to the LLM to guide its responses. This parameter supports CognigyScript, allowing dynamic content and logic in the prompt. This prompt can work either as the input for completion tasks or as the system message in chat-based interactions, setting context and behavior for the AI Agent.
>
> Additionally, you can inject the recent conversation into the **System Prompt** field by using these tags:
>
> * `@cognigyRecentConversation` — injects a string that contains up to the 10 most recent conversation turns, for example:
>   ```text theme={null}
>   Bot: agentOutput1
>   User: userOutput1
>   Bot: agentOutput2
>   User: userOutput2
>   ```
> * `@cognigyRecentUserInputs` — injects a string that contains up to the 10 most recent user outputs, for example:
>
>   ```text theme={null}
>   User: userOutput1
>   User: userOutput2
>   ```
>
> To access only the last user input, enter `{{ci.text}}` or the **Text** token in the **System Prompt** field.
>
> When you use tags, add a line break before and after the tag, for example:
>
> ```text theme={null}
> A user had a conversation with an AI Agent. The conversation history so far is:
> @cognigyRecentConversation
>
> Describe the user sentiment in one very short line.
> ```
>
> Both tags include an optional limit parameter, which is appended to the tag, for example:
>
> ```typescript theme={null}
> @cognigyRecentConversation:3 // returns the last 3 turns of the conversation.
> @cognigyRecentUserInputs:2 // returns the last 2 user inputs.
> ```

> [accordion] Advanced
>
> | Parameter | Type | Description |
> | - | - | - |
> | Ignore deprecated parameters | Toggle | Excludes the deprecated **Sampling Method**, **Temperature**, **Top Percentage**, **Maximal Tokens**, **Frequency Penalty**, **Presence Penalty**, **Use Stops**, **Stops**, and **Seed** parameters from the request to the LLM provider. Activate this toggle if your model doesn't support these parameters. If you activate this toggle for a model that supports them, the model uses default values. |
> | Maximal Tokens | Slider | Sets the maximum number of tokens to generate in the LLM response. |
> | Use Single Prompt Mode | Toggle | Sends a prompt from the **System Prompt** parameter to the model without any conversation context. The **Use Single Prompt Mode** parameter is deactivated by default and doesn't support multi-turn conversations, making it suitable for simple, one-off completions. When the parameter is activated, the **System Prompt** parameter must not be empty. Empty prompts return no data and might produce empty responses or errors depending on the model you use. |
> | Transcript Turns | Slider | Sets the number of previous conversation turns included in the LLM request. A conversation turn includes a user input and the AI Agent’s response. The default value is `50`. This parameter affects only past turns. The current turn is always included and contains the user input, LLM processing, tool calls, tool results, and multi-step tool workflows. For example, setting **Transcript Turns** to `0` excludes all previous turns, while the current turn is still fully included. |
> | Response Format | List | Sets the format for the model's output result from the following options:<ul><li>**None** — no response format is specified. With this option, the provider's built-in response format is used. This option is selected by default.</li><li>**Text** — the model returns messages in text format.</li><li>**JSON Object** — the model returns messages in JSON format. To use this option, instruct the model to generate JSON via a system or user message in the **Instruction (System Message/Prompt)** field. For example, `Take the user message and return it as JSON in the following format {"message": "THE_MESSAGE"}`. For Amazon Bedrock and Anthropic models, you can [set the JSON structure](#custom-options) with the `output_config` parameter in **Custom Options**. This parameter might not be supported by all LLMs. For more information, refer to the LLM provider's API documentation.</li></ul> |
> | Timeout | Number | Sets the maximum number of milliseconds to wait for a response from the LLM provider. |
> | Sampling Method | List | Sets the sampling method from the following options:<ul><li>**Temperature** — determines the level of randomness in the generated text. A higher temperature allows for more diverse and creative outputs, while a lower temperature leads to more predictable outputs consistent with the training data.</li><li>**Top Percentage** — determines the percentage of the most probable outputs for generation. A lower top percentage limits the most probable outputs and leads to more consistent outputs.</li></ul> |
> | Temperature | Slider | Defines the sampling temperature, which ranges between 0 and 1. Higher values, such as 0.8, make the output more random, while lower values, such as 0.2, make it more focused and deterministic. |
> | Top Percentage | Slider | Controls the Top-p (nucleus) sampling, ranging from 0 to 1. Higher values allow more diverse word choices, while lower values make the output more focused. For example, 0.9 means the model selects from the smallest set of words with a combined probability of 90%. |
> | Presence Penalty | Slider | Controls whether the LLM penalizes already generated tokens. You can set a number between -2.0 and 2.0. Positive values prevent the LLM from outputting tokens that have already been generated and increase the likelihood that the LLM will refer to new topics. |
> | Frequency Penalty | Slider | Controls whether the LLM penalizes tokens based on how often they have already been generated. You can set a number between -2.0 and 2.0. Positive values reduce the likelihood of the LLM repeating the same words or phrases, encouraging more diverse and varied output. |
> | Use Stops | Toggle | Sets whether to use a list of strings as stop words to let the LLM know where the sentence stops. |
> | Stops | Text | Defines up to 4 strings to stop the API from generating further tokens. The returned text doesn't contain the provided strings. |
> | Seed | Number | Ensures consistent output when the same LLM Prompt Node is referenced multiple times. Specify any integer number, for example, `123`. The number in the **Seed** field and the prompt in the **Instruction (System Message/Prompt)** field must remain unchanged during subsequent references to the Node. In OpenAI, this parameter is in [Beta](https://platform.openai.com/docs/api-reference/chat/create#chat-create-seed) and is supported only by [certain models](https://cookbook.openai.com/examples/reproducible_outputs_with_the_seed_parameter). |
> | Include Rich Media Context | Toggle | Controls whether the text from the [Textual Description](https://docs-classic.cognigy.com/ai/agents/develop/node-reference/basic/say.md#output-type) field in Say, Question, and Optional Questions Nodes is added to the AI Agent's prompt. This text provides AI Agents with additional information, improving their responses. If you have filled in a **Textual Description** field in other Nodes, this text is added to the prompt as context for rich media, such as Text with Quick Replies. If the **Textual Description** field is empty, the button titles and alt text from the rich media are added to the prompt. By default, the **Include Rich Media Context** parameter is active. When this parameter is inactive, nothing related to the rich media is added to the prompt. **Examples**:<ul><li>If **Textual Description** is filled in:Textual Description: `Select your preferred delivery option: Standard Delivery or Express Delivery`.Quick Replies buttons: `Standard Delivery`, `Express Delivery`.Context added to the prompt: `Select your preferred delivery option: Standard Delivery or Express Delivery`.</li><li>If **Textual Description** is empty:Textual Description: empty.Quick Replies buttons: `Standard Delivery`, `Express Delivery`.Context added to the prompt: `Standard Delivery`, `Express Delivery`.</li><li>If **Include Rich Media Context** is inactive:No information related to the rich media is added to the prompt.</li></ul> |

> [accordion] Storage & Streaming Options
>
> | Parameter | Type | Description |
> | - | - | - |
> | How to handle the result | List | Determines how to handle the prompt result:<ul><li>**Store in Input** — stores the result in the Input object. To print the prompt result, use the LLM Prompt Result token or `{{ci.promptResult.result}}` in the Say Node, or activate the **Output result immediately** option.</li><li>**Store in Context** — stores the result in the Context object. To print the prompt result, use `{{cc.promptResult.result}}` in the Say Node or activate the **Output result immediately** option.</li><li>**Stream to Output** — streams the result directly into the output. This means that the model provides outputs directly into the conversation chat as soon as Cognigy matches a Stream Buffer Flush Token, and you don't need to use the LLM Prompt Result token and Say Node. By default, this result won't be stored in either the Input or the Context. You can change this behavior by activating the **Store Copy in Input** option. Streaming might not be supported by all [Cognigy LLM Prompt Node](https://docs-classic.cognigy.com/ai/agents/develop/gen-ai-and-llms/model-support-by-feature.md) providers, such as Google<sup>[1](#footnote1)</sup>. If streaming isn't supported, enabling the **Store Copy in Input** option saves the result to the Input object.</li></ul> |
> | Input Key to store Result | CognigyScript | This parameter appears when **Store in Input** is selected or when **Stream to Output** is selected and **Store Copy in Input** is activated. Enter a JSON key under which to store the result object in the Input object. The default key is `promptResult`. |
> | Context Key to store Result | CognigyScript | This parameter appears when **Store in Context** is selected. Enter a JSON key under which to store the result object in the Context object. The default key is `promptResult`. |
> | Stream Buffer Flush Tokens | Text Array | This parameter appears when **Stream to Output** is selected. Defines tokens that trigger the stream buffer to print the output to the user. The tokens can be punctuation marks or symbols, such as `\n`. |
> | Stream Buffer Flush Overrides | Text Array | This parameter appears when **Stream to Output** is selected. Sets regular expressions (without leading or trailing slashes) to prevent stream buffer flushing in specific cases. A trailing `$` is automatically added to match patterns at the end of the buffer. For example, `\d+\.` checks for a number followed by a dot at the end of the string. |
> | Output result immediately | Toggle | This parameter appears when you select either **Store in Input** or **Store in Context**. Outputs prompt results immediately to the user without using the Say Node and LLM Prompt Result token. This parameter is activated by default. |
> | Store Copy in Input | Toggle | This parameter appears when **Stream to Output** is selected. Stores a copy of the streamed output in the Input object. Enter the JSON key under which to store the result object in the **Input Key to store Result** field. |
>
> **Streaming Results**
>
> When you select **Stream to Output**, the LLM generates tokens and returns them one by one to Cognigy to ensure low-latency responses. Cognigy monitors delimiter tokens (Stream Buffer Flush Tokens), which serve as markers indicating when to output the token buffer. These tokens can be `.`, `!`, `?`, or any other symbols that act as delimiters for complete logical statements. When Cognigy detects one of these tokens, it promptly flushes the token buffer into the voice or chat output.
>
> The preconfigured overrides are listed in the table.
>
> | Regex | Description | Example |
> | - | - | - |
> | `\d+\.` | A number followed by a dot. | `26.08` |
> | `\b(?:Dr\|Ms\|Mr\|Mrs\|Prof\|Sr\|Jr\|ca)\.` | Common abbreviations followed by a dot. | `Mr.` |
> | `\b[A-Z]\.` | A single capital letter followed by a dot. | `M. Smith` |
> | `\.\.\.` | Three dots used for omission. | `...` |
> | `\b.\..\.` | Two-letter abbreviations. | `i.e.`, `e.g.` |

> [accordion] Tool Settings
>
> The process of setting up a tool is the same as for the AI Agent Node. See the example in the [AI Agent Tool Settings](https://docs-classic.cognigy.com/ai/agents/develop/node-reference/ai/ai-agent.md#child-nodes) section.
>
> | Parameter | Type | Description |
> | - | - | - |
> | Tool Choice | List | If supported by your LLM, determines how the AI Agent selects tools:<ul><li>**Auto** — tools are automatically selected by the AI Agent when available and needed.</li><li>**Required** — your AI Agent always uses one of its tools.</li><li>**None** — your AI Agent doesn't use tools.</li></ul> |
> | Use Strict mode | Toggle | If supported by the LLM provider, ensures that the arguments passed to a tool call precisely match the expected parameters. Activating this mode can help prevent errors. However, it might cause a slight delay in the response, especially during the first call after making changes. |

> [accordion] Image Handling
>
> | Parameter | Type | Description |
> | - | - | - |
> | Process Images | Toggle | Allows the AI Agent to read and understand image attachments. Ensure that your LLM supports image processing; refer to your LLM provider's documentation. In addition, ensure that attachments are supported by and activated in your Endpoint, for example, Webchat. |
> | Images in Transcript | List | Sets how images uploaded before the last turn are handled to reduce token usage. You can select the following options: <ul><li>**Minify** — reduces the size of these images to 512x512px.</li><li>**Drop** — excludes the images.</li><li>**Keep** — sends the maximum size (this option consumes more tokens).</li></ul>Limitations and token consumption depend on the LLM used. |

> [accordion] Error Handling
>
> | Parameter | Type | Description |
> | - | - | - |
> | Log to System Logs | Toggle | Logs errors to the system logs. They can be viewed on the [Logs](https://docs-classic.cognigy.com/ai/agents/test/logs.md) page of your Project. This parameter is inactive by default. |
> | Select Error Handling Approach | List | Sets how Flow execution behaves if the LLM Prompt Node throws an error. You can select one of the following options:<ul><li>**Stop Flow Execution** — terminates the current Flow execution.</li><li>**Continue Flow Execution** — allows the Flow to continue executing, bypassing the error and proceeding to the next steps.</li><li>**Go to Node** — redirects Flow execution to a specific Node, which can be useful for error recovery or customized error handling.</li></ul> |
> | Error Message (optional) | Text | This parameter appears when you select **Continue Flow Execution** in **Select Error Handling Approach**. Add a message to output if the LLM Prompt Node fails. |
> | Select Flow | List | This parameter appears when you select **Go to Node** in **Select Error Handling Approach**. Sets the Flow that includes the Node to which you want to redirect Flow execution. |
> | Select Node | List | This parameter appears when **Go to Node** in **Select Error Handling Approach** is selected. Sets the Node to which you want to redirect Flow execution. |

> [accordion] Custom Options
>
> These options let you use parameters that aren't included in the LLM Prompt Node or override existing configurations.
>
> | Parameter | Type | Description | Example |
> | - | - | - | - |
> | Custom Options | JSON | Sets custom parameters to the LLM configuration. You can set individual parameters as well as entire functions. These parameters customize the behavior of the model, such as adjusting `temperature`, `top_k`, or `presence_penalty`. This field overrides the parameters set in the LLM Prompt Node. To view the full list of available parameters for your model, refer to the LLM provider's API documentation, for example, [OpenAI](https://platform.openai.com/docs/api-reference/chat/create) or [Azure OpenAI](https://learn.microsoft.com/en-us/azure/ai-services/openai/). For Amazon Bedrock and Anthropic models, you must use the `output_config` parameter to [customize the JSON structure in the output](#custom-options). | `{ "model": "gpt-4o", "temperature": 0.7, "max_tokens": 4000 }` |
> | Custom Request Options | JSON | Sets parameters to customize the request to the LLM provider. These parameters override the configurations set in this Node. For example, setting a `{ "stream": true }` parameter overrides the **Output result immediately** option. For more information, refer to the LLM provider's API documentation. | `{ "stream": true }`, `{ "headers": { "Authorization": "Bearer <token>" } }` |
>
> **Forcing Model Versions**
>
> You can force the LLM Prompt Node to use a specific model version by including it in the Custom Options.
> This means that the LLM Prompt Node uses the specified version of the language model instead of the default or any other available versions. This gives you more control over the behavior of the LLM Prompt Node, ensuring it uses a specific model version for generating prompts or responses.
>
> You can use any models from [LLM providers](https://docs-classic.cognigy.com/ai/agents/develop/gen-ai-and-llms/providers/all-providers.md) supported by Cognigy, including those not yet directly integrated. However, you can only replace a model with another from the same provider.
>
> Consider an example with Anthropic as the LLM provider:
>
> You can force the LLM Prompt Node to use the model version `claude-opus-4-8-20260101`, despite the LLM resource defaulting to the `claude-sonnet-4-6` model:
>
> 1. [Create an Anthropic LLM resource](https://docs-classic.cognigy.com/ai/agents/develop/gen-ai-and-llms/providers/anthropic.md) for Claude, for example, `claude-sonnet-4-6`.
> 2. Create a Flow and add an LLM Prompt Node to it.
> 3. In the LLM Prompt Node, select the model `claude-sonnet-4-6` from the **Large Language Model** list.
> 4. In the **Custom Options** field, add `{ "model": "claude-opus-4-8-20260101" }` to force the use of the `claude-opus-4-8-20260101` model.
> 5. Click **Save Node**.
>
> The LLM Prompt Node then uses the `claude-opus-4-8-20260101` model.
>
> For more information on supported models, see:
>
> * [Aleph Alpha models](https://docs.aleph-alpha.com/)
> * [Anthropic models](https://docs.anthropic.com/claude/docs/models-overview)
> * [Azure OpenAI models](https://learn.microsoft.com/en-us/azure/ai-services/openai/concepts/models)
> * [OpenAI models](https://platform.openai.com/docs/models)
>
> **Forcing JSON Output on Amazon Bedrock and Anthropic**
>
> For [Amazon Bedrock](https://docs-classic.cognigy.com/ai/agents/develop/gen-ai-and-llms/providers/amazon-bedrock.md) and [Anthropic](https://docs-classic.cognigy.com/ai/agents/develop/gen-ai-and-llms/providers/anthropic.md) models, add the `output_config` parameter to the **Custom Options** field to force the model to return a specific JSON response.
>
> For example, to force the model to return JSON matching a specific schema:
>
> ```json theme={null}
> {
>   "output_config": {
>     "format": {
>       "type": "json_schema",
>       "schema": {
>         "type": "object",
>         "properties": { "answer": {} },
>         "required": ["answer"]
>       }
>     }
>   }
> }
> ```
>
> With this configuration, a prompt such as "What is 1+1?" returns a response like `{"answer": 2}` instead of plain text.

> [accordion] Debugging Settings
>
> These settings provide two approaches for debug logging:
>
> * Debug messages in the Interaction Panel — appear only during testing with the Interaction Panel and aren't intended for production.
> * Webhook request logs — can be used in production to inspect LLM requests and completions.
>
> You can use both approaches at the same time.
>
> | Parameter | Type | Description |
> | - | - | - |
> | Show Token Count | Toggle | Sends a debug message containing the input, output, and total token count. The message appears in the Interaction Panel when [debug mode](https://docs-classic.cognigy.com/ai/agents/test/interaction-panel/chat.md#debug-mode) is active. Cognigy uses the GPT-3 tokenizer algorithm, so actual token usage may vary depending on the model used. This parameter is inactive by default. |
> | Log System Prompt & Completion | Toggle | Sends a debug message containing the system prompt sent to the LLM provider and the subsequent completion. The message appears in the Interaction Panel when [debug mode](https://docs-classic.cognigy.com/ai/agents/test/interaction-panel/chat.md#debug-mode) is active. This parameter is inactive by default. |
> | Log Tool Definitions | Toggle | Sends a debug message containing information about the configured AI Agent tools. The message appears in the Interaction Panel when [debug mode](https://docs-classic.cognigy.com/ai/agents/test/interaction-panel/chat.md#debug-mode) is enabled. This parameter is inactive by default. |
> | Log LLM Latency | Toggle | Sends a debug message containing key latency metrics for the request to the model, including the time taken for the first output and the total time to complete the request. The message appears in the Interaction Panel when [debug mode](https://docs-classic.cognigy.com/ai/agents/test/interaction-panel/chat.md#debug-mode) is enabled. This parameter is inactive by default. |
> | Send request logs to Webhook | Toggle | Sends the request sent to the LLM provider and the subsequent completion to a webhook service, including metadata, the request body, and custom logging data. With this parameter, you can use a webhook service to view detailed logs of the request to the LLM. This parameter is inactive by default. |
> | Webhook URL | CognigyScript | This parameter appears when you toggle on **Send request logs to Webhook**. Sets the URL of the webhook service to send the request logs to. |
> | Custom Logging Data | CognigyScript | This parameter appears when you toggle on **Send request logs to Webhook**. Sets custom data to send with the request to the webhook service. |
> | Condition for Webhook Logging | CognigyScript | This parameter appears when you toggle on **Send request logs to Webhook**. Sets the condition for the webhook logging. |
> | Webhook Headers | Input fields | Sets the headers to send with the request to the webhook service. You can switch between the graphical and JSON editors to enter the header key and value either in the **Key** and **Value** fields or in the code field in JSON format. When using the JSON editor, follow the [JSON Schema specification](https://json-schema.org). |
> | Key | Text | Sets the header name. After entering the header key, new empty **Key** and **Value** fields are automatically added, in case you need to add more headers. |
> | Value | CognigyScript | Sets the header value. |

### Child Nodes

#### Tool

Tools are child Nodes of AI Agent Nodes. They define the actions the AI Agent can take. If an AI Agent wants to execute the tool, the branch below the child Node is executed.

> [!TIP]
>
> To better guide your AI Agent, use a [Resolve Tool Action](https://docs-classic.cognigy.com/ai/agents/develop/node-reference/ai/resolve-tool-action.md) Node at the end of a tool branch to return to the AI Agent after tool execution.

Clicking the Tool Node lets you define a tool, set its parameters, and enable debugging by turning on detailed messages about the tool's execution.

> [accordion] Tool
>
> | Parameter | Type | Description |
> | - | - | - |
> | Tool ID | CognigyScript | Defines the tool ID. This ID can contain only letters, numbers, underscores (`_`), or dashes (`-`). If you use more than one tool, the tool ID provides context to trigger the correct tool. In this case, enter a clear tool ID for each tool, for example, `update_user-1`. |
> | Description | CognigyScript | Defines instructions to guide the AI Agent to call the tool. The description field provides context to trigger the tool. Enter a detailed description of what the tool does, when it should be used, and what parameters it requires. |

> [accordion] Parameters
>
> Configure the parameters that the AI Agent collects before the tool is called. You can switch between the graphical and JSON editors. When using the JSON editor, follow the [JSON Schema specification](https://json-schema.org).
>
> | Parameter | Type | Description |
> | - | - | - |
> | Use Parameters | Toggle | Displays the **Parameters** section in the Node editor. In this section, you can define additional parameters for the tool. The AI Agent collects all data it needs and calls a tool with these parameters filled as arguments. This parameter values can be accessed directly in the `input.aiAgent.toolArgs` object. |
> | Name | Text | Sets the name of the parameter. The name must be clear and concise, and describe the purpose of the parameter. |
> | Type | List | Sets the parameter type:<ul><li>**String** — a sequence of characters. For example, `"hello"`, `"123"`.</li><li>**Number** — a numerical value, which can be either an integer, for example,`5`, or a floating point number, for example, `3.14`.</li><li>**Boolean** — a logical value representing `true` or `false`.</li><li>**Array** — a collection of elements, which can contain multiple values of any type. For example, `["apple", "banana", "cherry"]`.</li><li>**Object** — a collection of key-value pairs, where each key is a string and the value can be of any type. For example, `{"name": "John", "age": 30}`.</li></ul> |
> | Description | Text | Describes the parameter's purpose. |
> | Enum (optional) | Enum | Defines a set of values that the parameter can accept. The enum restricts the input to one of the specified values, ensuring only valid options are chosen. The enum is only available for string-type parameters in the graphical editor. For other types, use the JSON editor. Might not be supported by all LLM providers. |
> | Add Parameter | Button | Adds another parameter. |

> [accordion] Debug Settings
>
> | Parameter | Type | Description |
> | - | - | - |
> | Debug Message when called | Toggle | Activates the output of a debug message when the tool is called to provide detailed information about the tool call. |

> [accordion] Advanced
>
> | Parameter | Type | Description |
> | - | - | - |
> | Condition | CognigyScript | Sets a condition that must be evaluated as true to activate the tool. If false, the AI Agent can't access the tool during execution. For example, when using an `unlock_account` tool, you can enter a condition like `context.accountStatus === "locked"`. With this condition, the AI Agent checks the value of the `context.accountStatus` key in the Context object, and if the key is missing or the value is different from `"locked"`, the AI Agent can't use the tool. |

#### MCP Tool

An MCP Tool Node is a type of Tool Node that connects to a remote [MCP server](https://modelcontextprotocol.io/introduction) to load tools that the AI Agent can execute. If an AI Agent wants to execute one of the loaded tools, the branch below the MCP Tool Node is triggered.

In the MCP Tool Node, you can define the connection, filter loaded tools, and turn on detailed messages about the tool's execution for debugging.

> [accordion] MCP Tool
>
> | Parameter | Type | Description |
> | - | - | - |
> | Name | CognigyScript | Defines a name for the MCP connection. This name helps you identify the source of the loaded tool. |
> | MCP Server SSE URL | CognigyScript | Defines the URL to an SSE (server-sent events) endpoint from a remote [MCP server](https://modelcontextprotocol.io/introduction). Ensure that you connect only to trusted MCP servers. |
> | Timeout | Slider | Sets the timeout for the MCP connection in seconds. |

> [accordion] Authentication
>
> | Parameter | Type | Description |
> | - | - | - |
> | Authentication Type | List | Sets the authentication type to use for the MCP server connection. Select one of the following options: <ul><li>**None** — no authentication. This option is used by default.</li><li>**OAuth2** — authenticate using OAuth 2.0, which provides improved security and control compared to API keys. OAuth 2.0 supports scoped permissions, expiring tokens, and reduced exposure through short-lived tokens.</li></ul>If you want to use a different authentication method, such as an API key, you can add it as a custom header in **Custom Headers** of the **Advanced** section. |
> | OAuth2 Parameters | List | Opens the dialog to configure OAuth 2.0 authentication. The dialog includes fields that allow the AI Agent to securely request and use access tokens when communicating with the MCP server. Configure the following fields: <ul><li>**Connection Name** — enter a descriptive name for the connection, for example, `MCP Tool OAuth`.</li><li>**OAuth URL** — enter the token endpoint URL exposed by the MCP server, for example: `https://mcp.example.com/oauth2/token`.</li><li>**Client ID** — enter the application (client) ID issued by the MCP server.</li><li>**Client Secret** — enter the application secret issued by the MCP server. Keep this secret secure.</li><li>**Scope** — add a list of scopes that define the permissions required by your application, for example: `read write admin`. Separate multiple scopes with spaces.</li></ul> |

> [accordion] Debug Settings
>
> | Parameter | Type | Description |
> | - | - | - |
> | Debug Loaded Tools | Toggle | Displays a debug message listing all tools loaded from the MCP server. The debug message also includes tools filtered out in the [Advanced section](#advanced-2-accordion-title). This parameter shows whether tools were loaded from the cache or directly from the MCP server. |
> | Debug with Parameters | Toggle | Includes the tool parameters in the debug message. |
> | Debug calling Tool | Toggle | Outputs a debug message with detailed information about the tool call each time it is triggered. |

> [accordion] Advanced
>
> | Parameter | Type | Description |
> | - | - | - |
> | Cache Tools | Toggle | Disables caching of loaded tools during development. Ensure that caching is enabled in production for performance reasons. The caching time is 10 minutes. In [debug mode](https://docs-classic.cognigy.com/ai/agents/test/interaction-panel/chat.md#debug-mode), you can verify whether the cache was used. To do this, make sure **Debug Loaded Tools** is enabled. For more information, see the [Debug Settings](#debug-settings) section. |
> | Condition | CognigyScript | Sets a condition that must be evaluated as true to activate the MCP tool. If false, the AI Agent can't access the tool during execution. For example, when using an `unlock_account` tool, you can enter a condition like `context.accountStatus === "locked"`. With this condition, the AI Agent checks the value of the `context.accountStatus` key in the Context object, and if the key is missing or the value is different from `"locked"`, the AI Agent can't use the tool. |
> | Tool Filter | Select | Excludes tools from execution. You can select one of the following options:<ul><li>**None** — no tool filtering is applied, and all tools are available for execution. This option is selected by default.</li><li>**Whitelist** — only tools on the list are available for execution, while all other tools are excluded.</li><li>**Blacklist** — excludes the tools on the list from execution, while all other tools remain available.</li></ul> |
> | Blacklist | CognigyScript | This parameter appears if you select **Blacklist** in **Tool Filter**. Defines which tools to block from execution. Enter only one tool per field. |
> | Whitelist | CognigyScript | This parameter appears if you select **Whitelist** in **Tool Filter**. Sets the tools you want to allow for execution. Enter only one tool per field. |
> | Custom Headers | Input fields | Sets the headers to send with the request to the MCP server. You can switch between the graphical and JSON editors to enter the header key and value either in the **Key** and **Value** fields or in the code field in JSON format. |
> | Key | Text | Sets the header name. After entering the header key, new empty **Key** and **Value** fields are automatically added, in case you need to add more headers. |
> | Value | CognigyScript | Sets the header value. |

#### Call MCP Tool

In the Flow editor, when you add an MCP Tool Node, a Call MCP Tool Node is automatically created below it. These two Nodes work together to define and execute the chosen tool. The Call MCP Tool Node sets the actual execution point of the chosen tool. This way, you can verify or modify the tool call arguments in the `input.aiAgent.toolArgs` object, or add a Say Node before the tool call. When the Call MCP Tool Node is executed, the tool call is sent to the remote MCP server, where the tool is executed remotely with any arguments set by the AI Agent.

To return the tool result to the AI Agent, enable **Resolve Immediately** to send the full result from the remote MCP server to the AI Agent.

As an alternative, use a [Resolve Tool Action](https://docs-classic.cognigy.com/ai/agents/develop/node-reference/ai/resolve-tool-action.md) Node to return a specific result to the AI Agent.

> [accordion] Call MCP Tool
>
> | Parameter | Type | Description |
> | - | - | - |
> | Resolve Immediately | Toggle | Immediately resolves the tool action with the full result as the tool answer. |

> [accordion] Storage Options
>
> | Parameter | Type | Description |
> | - | - | - |
> | How to handle the result | Select | Sets how to handle the MCP tool call result:<ul><li>**Store in Input** — stores the result in the Input object.</li><li>**Store in Context** — stores the result in the Context object.</li></ul> |
> | Input Key to store Result | CognigyScript | This parameter appears when **Store in Input** is selected. The result is stored in the `input.aiAgent.toolResult` object by default. You can specify another value, but the **MCP Tool Result** Token won't work if the value is changed. |
> | Context Key to store Result | CognigyScript | This parameter appears when **Store in Context** is selected. The result is stored in the `context.aiAgent.toolResult` object by default. |

> [accordion] Debug Settings
>
> | Parameter | Type | Description |
> | - | - | - |
> | Debug Tool Result | Toggle | Outputs a debug message with the tool call result after a successful call. |

#### A2A Agent

A2A Agent Nodes are child Nodes of AI Agent and LLM Prompt Nodes. An A2A Agent Node allows the parent Node to connect to a remote A2A agent and use it as a single tool.

The remote A2A agent can advertise multiple skills, but the parent Node always sees them as a single tool. The skills are summarized in the tool description to help the parent Node decide when to use it.

In the A2A Agent Node, configure the A2A agent connection, authentication, skill filtering, and debugging options.

> [accordion] A2A Agent
>
> | Parameter | Type | Description |
> | - | - | - |
> | Name | CognigyScript | Defines the name of the A2A Agent connection. |
> | A2A Agent Base URL | CognigyScript | Defines the base URL of the A2A agent. Connect only to trusted A2A agents. |
> | Custom Agent Card Path | CognigyScript | Overrides the default Agent Card discovery path. |
> | Test Connection | Button | Tests the connection and verifies that the remote Agent Card can be retrieved. |
> | Timeout | Slider | Sets the request timeout in seconds when **Execution mode** is **Blocking**. Ranges from 1 to 30 seconds. The default value is `12`. |
> | Execution mode | List | Determines how the Node waits for the remote A2A agent:<ul><li>**Blocking** — waits for the final result.</li><li>**Non-blocking** — sends the message and polls the task until it completes or the **Task timeout** is reached.</li></ul> |
> | Task timeout | Slider | Sets the maximum time in seconds to poll a task when **Execution mode** is **Non-blocking**. Ranges from 10 to 300 seconds. The default value is `60`. |
> | Max autonomous calls per turn | Slider | Limits the number of times the parent Node can call this tool autonomously during one turn. Ranges from 1 to 10. The default value is `4`. |
> | Cache Agent Card | Toggle | Caches the remote Agent Card for 10 minutes. This parameter is active by default. When developing, set the parameter to inactive to fetch the Agent Card on every turn. |

> [accordion] Authentication
>
> | Parameter | Type | Description |
> | - | - | - |
> | Authentication Type | List | Authentication method for requests to the remote A2A agent: **None**, **OAuth2**, **Bearer Token**, **Basic Auth**, or **API Key**. |
> | OAuth2 Parameters | Connection | Appears when **OAuth2** is selected. Configures the connection used to obtain and cache an access token. |
> | Basic Auth Parameters | Connection | Appears when **Basic Auth** is selected. Configures the username and password. |
> | Bearer Token | Connection | Appears when **Bearer Token** is selected. Configures the token sent in the `Authorization` header. |
> | API Key | Connection | Appears when **API Key** is selected. Configures the API key value. |
> | API Key Header Name | CognigyScript | Appears when **API Key** is selected. Specifies the header used for the API key. Default: `X-API-Key`. |
> | Use Authentication for Agent Discovery | Toggle | Applies the configured authentication to Agent Card discovery. Inactive by default. |

> [accordion] Debug Settings
>
> | Parameter | Type | Description |
> | - | - | - |
> | Debug loaded A2A Skills | Toggle | Displays the skills loaded from the remote Agent Card and indicates whether the Agent Card came from the cache. This parameter is active by default. |
> | Debug calling A2A Skill | Toggle | Displays a debug message when the tool is called. This parameter is active by default. |

> [accordion] Advanced
>
> | Parameter | Type | Description |
> | - | - | - |
> | Condition | CognigyScript | Enables the tool only when the condition evaluates to `true`. |
> | A2A Skill Filter | Select | Controls which remote skills are summarized in the tool description. The A2A Agent Node remains a single tool regardless of the filter. Options:<ul><li>**None** — includes all skills.</li><li>**Whitelist** — includes only the specified skills.</li><li>**Blacklist** — excludes the specified skills.</li></ul> |
> | Whitelist | CognigyScript | Appears when **Whitelist** is selected. Specifies the skill IDs to include. |
> | Blacklist | CognigyScript | Appears when **Blacklist** is selected. Specifies the skill IDs to exclude. |
> | Custom Headers | - | Adds custom headers to requests sent to the remote A2A agent. Supports CognigyScript values. |

The A2A Agent Node covers the following use cases:

> [accordion] Specialist Delegation
>
> Delegate a subtask to a specialist A2A agent, such as an SAP or IT operations agent. The parent Node remains in control of the conversation.

> [accordion] Cross-Company Delegation
>
> Connect to an A2A agent operated by a partner organization for tasks such as booking, procurement, or support.

#### Call A2A Agent

Cognigy.AI automatically creates a Call A2A Agent Node below an A2A Agent Node. The A2A Agent Node defines the A2A agent connection, while the Call A2A Agent Node executes the call.

Use the Call A2A Agent Node to modify or inspect the message before it is sent, add a Say Node, and configure how the result is returned to the AI Agent Node.

When the Call A2A Agent Node runs, it sends the message to the remote A2A agent and handles the response according to the configured execution mode. The Agent Card determines the supported A2A protocol version, so no version configuration is required.

If the remote A2A agent supports streaming, the Node consumes the response as it arrives. Otherwise, it sends a request. In Non-blocking mode, the Node polls the resulting task until it completes or the task times out.

To return the result to the AI Agent Node, enable **Resolve Immediately**. Alternatively, use a [Resolve Tool Action](https://docs-classic.cognigy.com/ai/agents/develop/node-reference/ai/resolve-tool-action.md) Node to return a specific result.

If the remote A2A agent requires additional input or authentication, the AI Agent Node calls the tool again. **Max autonomous calls per turn** limits how often this can happen.

> [accordion] Call A2A Agent
>
> | Parameter | Type | Description |
> | - | - | - |
> | Resolve Immediately | Toggle | Immediately returns the full result to the AI Agent Node as the tool answer. This parameter is active by default. |
> | Progress Message | CognigyScript | Sends an optional status message to the A2A client. The message is sent only to a client connected via an [A2A Server Endpoint](https://docs-classic.cognigy.com/ai/agents/deploy/endpoint-reference/a2a-server.md) with streaming enabled. This setting is relevant only when this Cognigy.AI Flow is called via an A2A Server Endpoint. If the parameter is empty, an automatically generated message such as `Delegating to <agent name>...` is shown instead. |

> [accordion] Storage Options
>
> | Parameter | Type | Description |
> | - | - | - |
> | How to handle the result | Select | Determines where to store the result: **Input** or **Context**. **Store in Input** is selected by default. |
> | Input Key to store Result | CognigyScript | Appears when **Store in Input** is selected. Stores the result in `input.aiAgent.toolResult` by default. |
> | Context Key to store Result | CognigyScript | Appears when **Store in Context** is selected. Stores the result in `context.aiAgent.toolResult` by default. |

> [accordion] Debug Settings
>
> | Parameter | Type | Description |
> | - | - | - |
> | Debug A2A Skill Result | Toggle | Displays a debug message with the result after a successful call. This parameter is inactive by default. |
> | Debug Raw Request | Toggle | Displays the raw JSON-RPC request sent to the A2A agent. This parameter is inactive by default. |

#### Knowledge Tool

The Knowledge Tool Node is a child Node of the AI Agent Node. It lets the AI Agent directly access [Knowledge Stores](https://docs-classic.cognigy.com/ai/agents/develop/knowledge-ai/knowledge-store.md) to provide context-aware responses.

In the Knowledge Tool Node, you can select the [Knowledge Store](https://docs-classic.cognigy.com/ai/agents/develop/knowledge-ai/knowledge-store.md) to search, [Source Tags](https://docs-classic.cognigy.com/ai/agents/develop/knowledge-ai/knowledge-source/knowledge-source-tags.md) to refine the search, and output detailed debug messages about the tool's execution.

> [accordion] Knowledge Tool
>
> | Parameter | Type | Description |
> | - | - | - |
> | Knowledge Store | List | Sets the Knowledge Store to read information from. |
> | Tool ID | CognigyScript | Defines the tool ID. This ID can contain only letters, numbers, underscores (`_`), or dashes (`-`). If you use more than one Knowledge tool, the tool ID provides context to trigger the correct Knowledge tool. In this case, enter a clear tool ID for each Knowledge tool, for example, `search_appliances` |
> | Description | CognigyScript | Defines instructions to guide the AI Agent to call the Knowledge tool. The description field provides context to trigger the Knowledge tool. If you want to use more than one Knowledge tool, enter clear instructions for the cases when each Knowledge tool should be used. For example, `Find the answer to prompts or questions about appliances by searching the attached data sources. Use this tool when a customer asks about appliance items such as washing machines, dryers, and other household appliances. Focus exclusively on a knowledge search and don't execute tasks like small talk, calculations, or script running.` |

> [accordion] Debug Settings
>
> | Parameter | Type | Description |
> | - | - | - |
> | Debug Message when called | Toggle | Activates the output of a debug message when the tool is called to provide detailed information about the tool call. |

> [accordion] Advanced
>
> | Parameter | Type | Description |
> | - | - | - |
> | Top K | Slider | Sets how many Knowledge Chunks to return. The default value is 5, and the maximum value is 10. Providing more results gives the AI Agent additional context, but it also increases noise and token usage. |
> | Store Location | List | Sets whether and where to store the knowledge search results. Select one of the following options:<ul><li>**Don't store** — the content isn't stored. This option is set by default.</li><li>**Input** — the content is stored in the Input object.</li><li>**Context** — the content is stored in the Context object.</li></ul> |
> | Input Key to store result | CognigyScript | This parameter appears when **Store Location** is set to **Input**. The property in the Input object where the result is stored. For example, if you enter `knowledgeSearch`, you can retrieve the knowledge search result from `input.knowledgeSearch`. |
> | Context Key to store result | CognigyScript | This parameter appears when **Store Location** is set to **Context**. The property in the Context object where the result is stored. For example, if you enter `knowledgeSearch`, you can retrieve the knowledge search result from `context.knowledgeSearch`. |
> | Source Tags | CognigyScript | Defines [Knowledge Source Tags](https://docs-classic.cognigy.com/ai/agents/develop/knowledge-ai/knowledge-source/knowledge-source-tags.md) to refine the scope of your knowledge search, including only the most relevant Knowledge Chunks in the Knowledge Store. Before entering the tags, ensure they are included in the Knowledge Sources. Add a tag by entering it in the field and pressing <kbd>Enter</kbd>. You can add up to 5 Source Tags. When multiple Source Tags are added, the Search Extract Output Node defaults to the `AND` operator, meaning it only considers Sources that have all specified tags. To change this behavior, adjust the **Match Type for Source Tags** parameter. |
> | Match type for Source Tags | List | The operator to filter Knowledge Sources by Source Tags. Select one of the following options:<ul><li>**AND** —  requires all Source Tags to match across multiple Knowledge Sources. This option is selected by default. Consider the following example: there are Knowledge Sources with Source Tags `S-a`, `S-b`, and `S-c`. When you use the `AND` operator to filter by `S-a` and `S-b`, only Sources with both Tags `S-a` and `S-b` are included in the search results.</li><li>**OR** — requires at least one Source Tag to match across multiple Knowledge Sources. Consider the following example: there are Knowledge Sources with Source Tags `S-a`, `S-b`, and `S-c`. When you use the `OR` operator to filter by `S-a` or `S-b`, any Source with either Tag `S-a` or `S-b` is included in the search results.</li></ul> |
> | Condition | CognigyScript | Sets a condition that must be evaluated as true to activate the Knowledge tool. If false, the AI Agent can't access the tool during execution. For example, when using the Knowledge tool, you can enter a condition like `context.productCategory === "appliances"`. With this condition, the AI Agent checks the value of the `context.productCategory` key in the Context object, and if the key is missing or the value is different from `"appliances"`, the AI Agent can't use the tool. |

#### Send Email Tool

The Send Email tool lets your AI Agent send emails directly to users. The Send Email tool uses the same configuration and restrictions as the [Email Notification Node](https://docs-classic.cognigy.com/ai/agents/develop/node-reference/data/email-notification.md) but adds more flexibility. While the Email Notification Node sends emails at a fixed step in a Flow, the Send Email tool allows the AI Agent to send emails dynamically, based on user input, conversation context, or instructions. This tool makes automation more flexible and minimizes extra Flow steps.

> [accordion] Tool
>
> | Parameter | Type | Description |
> | - | - | - |
> | Tool ID | CognigyScript | Defines the tool ID. This ID can contain only letters, numbers, underscores (`_`), or dashes (`-`). The default ID is `send_email`. If you use more than one Send Email tool, the tool ID provides context to trigger the correct Send Email tool. In this case, enter a clear tool ID for each Send Email tool, for example, `send_order_confirmation`. |
> | Description | CognigyScript | Defines instructions to guide the AI Agent to call the Send Email tool. The description field provides context to trigger the Send Email tool. The default description is `Create and send a new email message.` |
> | Recipient TO Email Addresses | CognigyScript | A comma-separated list of email addresses to which the email will be sent. |

> [accordion] Debug Settings
>
> | Parameter | Type | Description |
> | - | - | - |
> | Debug Message when called | Toggle | Activates the output of a debug message when the tool is called to provide detailed information about the tool call. |

> [accordion] Advanced
>
> | Parameter | Type | Description |
> | - | - | - |
> | Condition | CognigyScript | Sets a condition that must be evaluated as true to activate the Send Email tool. If false, the AI Agent can't access the tool during execution. For example, when using the Send Email tool, you can enter a condition like `context.orderFinished === true`. With this condition, the AI Agent checks the value of the `context.orderFinished` key in the Context object, and if the key is missing or the value is different from `true`, the AI Agent can't use the tool. |

#### Handover to AI Agent Tool

The Handover to AI Agent tool lets you transfer a conversation to another AI Agent in the same or a different Flow. This approach ensures the conversation keeps its context, different AI Agents can handle specific tasks, and multi-step conversations run smoothly across Flows.

> [accordion] Tool
>
> | Parameter | Type | Description |
> | - | - | - |
> | Tool ID | CognigyScript | Defines the tool ID. This ID can contain only letters, numbers, underscores (`_`), or dashes (`-`). The default ID is `handover_to_ai_agent`. If you use more than one Handover to AI Agent tool, the tool ID provides context to trigger the correct Handover to AI Agent tool. In this case, enter a clear tool ID for each Handover to AI Agent tool, for example, `handover_to_billing_agent`. |
> | Description | CognigyScript | Defines instructions to guide the AI Agent to call the Handover to AI Agent tool. The description field provides context to trigger the correct receiving AI Agent. If you use more than one Handover to AI Agent tool, enter clear instructions for the cases when each receiving AI Agent should take over. For example, `Handle product recommendations`, `Perform technical troubleshooting`, or `Assist with billing questions`. |
> | Select Flow | List | Sets the target Flow to hand over to. By default, all Flows in the Project are displayed in the list. The selected Flow must contain an AI Agent Node. |
> | Select Node | List | Sets the AI Agent Node to hand over to. |

> [accordion] Debug Settings
>
> | Parameter | Type | Description |
> | - | - | - |
> | Debug Message when called | Toggle | Activates the output of a debug message when the tool is called to provide detailed information about the tool call. |

> [accordion] Advanced
>
> | Parameter | Type | Description |
> | - | - | - |
> | Condition | CognigyScript | Sets a condition that must be evaluated as true to activate the Handover to AI Agent tool. If false, the AI Agent can't access the tool during execution. For example, when using the Handover to AI Agent tool, you can enter a condition like `context.accountStatus === "locked"`. With this condition, the AI Agent checks the value of the `context.accountStatus` key in the Context object, and if the key is missing or the value is different from `"locked"`, the AI Agent can't use the tool. |

#### Handover to Human Agent Tool

The Handover to Human Agent tool lets you transfer a conversation to a human agent through handover providers. This tool lets your AI Agents refer complex tasks to a human agent if they can't address the user's request.

> [accordion] Tool
>
> | Parameter | Type | Description |
> | - | - | - |
> | Tool ID | CognigyScript | Defines the tool ID. This ID can contain only letters, numbers, underscores (`_`), or dashes (`-`). The default ID is `handover_to_human_agent`. If you use more than one Handover to Human Agent tool, the tool ID provides context to trigger the correct Handover to Human Agent tool. In this case, enter a clear tool ID for each Handover to Human Agent tool, for example, `handover_to_billing_support`. |
> | Description | CognigyScript | Defines instructions to guide the AI Agent to call the Handover to Human Agent tool. The description field provides context to trigger the handover. Enter clear instructions for the situations when the AI Agent should refer to a human agent. For example, `Use this tool if the user explicitly asks for a human.` or `Use this tool if you fail to answer the user's question three times.` |
> | Handover Provider | List | Sets a handover provider that you previously created in **Deploy > Handover Providers**. A section with handover provider-specific settings appears. [Configure the handover accordingly](https://docs-classic.cognigy.com/ai/escalate/handover-reference/overview):<ul><li>[Live Agent](https://docs-classic.cognigy.com/live-agent/getting-started/live-agent-setup/live-agent-setup-handover-flow.md#set-up-flows-for-handover)</li><li>[Chatwoot](https://docs-classic.cognigy.com/ai/escalate/handover-reference/chatwoot.md#2-add-a-handover-to-human-agent-node)</li><li>[Salesforce](https://docs-classic.cognigy.com/ai/escalate/handover-reference/salesforce.md#2-add-a-handover-to-human-agent-node)</li><li>[NiCE CXone](https://docs-classic.cognigy.com/ai/escalate/handover-reference/nice-cxone/overview)</li><li>[Genesys Cloud Open Messaging](https://docs-classic.cognigy.com/ai/escalate/handover-reference/genesys-cloud-open-messaging#2-configure-handover-settings) or [Genesys Cloud Guest Chat](https://docs-classic.cognigy.com/ai/escalate/handover-reference/genesys-cloud-guest-chat.md#2-configure-handover-settings)</li><li>[8x8](https://docs-classic.cognigy.com/ai/escalate/handover-reference/8x8.md#2-configure-handover-settings)</li><li>[RingCentral Engage](https://docs-classic.cognigy.com/ai/escalate/handover-reference/ring-central-engage.md#2-add-a-handover-to-human-agent-node)</li></ul> |
> | Handover Accepted Message | CognigyScript | Defines the message sent to the user when the handover is requested. |
> | Repeat Handover Accepted Message | Toggle | Repeatedly outputs the text in **Handover Accepted Message** if the user sends a message while waiting in the queue for an agent. |

> [accordion] Cancel Handover Options
>
> | Parameter | Type | Description |
> | - | - | - |
> | Cancel Intent | CognigyScript | Defines the Intent the user must trigger to cancel the handover request. |
> | Cancel Button Text | CognigyScript | Defines the text for a Quick Reply button that cancels the handover request when clicked. |

> [accordion] On Resolve Options
>
> | Parameter | Type | Description |
> | - | - | - |
> | Flow Continuation | List | Controls where the Flow continues after the human agent leaves the conversation. When the user needs assistance completing the Flow with the AI Agent, the conversation is handed over to a human agent. The human agent can trigger the Flow by sending a `/bot` command as a reply in the conversation interface. For example, the user enters their date of birth in an incorrect format, and the AI Agent can't process the response. The conversation is handed over to a human agent, who identifies the incorrect format and sends the corrected date using `/bot MM/DD/YYYY`. The AI Agent takes over and continues the Flow. <ul><li>**Below this Node** — the Flow continues from the first Node below the Human Agent Node, regardless of where the human agent stopped assisting the user. This option is selected by default.</li><li>**At current AgentInject Entrypoint** — the Flow continues from the Node where the human agent stopped assisting the user.</li></ul> |
> | Send resolve event to Virtual Agent | Toggle | Controls whether the Flow receives the `conversation_status_changed` event with the status set to `resolved`. This parameter is activated by default.<ul><li>When the parameter is activated, the event is sent when the human agent leaves the conversation. As a result, the Flow continues immediately, without waiting for the user to send another message. If the [Lookup Case](https://docs-classic.cognigy.com/ai/agents/develop/node-reference/logic/lookup.md) Node is configured with **Handover Status** set to **Completed**, the Node can detect the completed handover and continue the Flow.</li><li>When the parameter is deactivated, the event isn't sent when the human agent leaves the conversation. The Flow continues after the user sends their next message.</li></ul> |

> [accordion] Event Settings
>
> | Parameter | Type | Description |
> | - | - | - |
> | Send Queue Event | Toggle | Sends an event to the Flow once the handover is queued. |
> | Send Active Event | Toggle | Sends an event to the Flow once the handover is active. |

> [accordion] Debug Settings
>
> | Parameter | Type | Description |
> | - | - | - |
> | Debug Message when called | Toggle | Activates the output of a debug message when the tool is called to provide detailed information about the tool call. |

> [accordion] Advanced
>
> | Parameter | Type | Description |
> | - | - | - |
> | Condition | CognigyScript | Sets a condition that must be evaluated as true to activate the Handover to Human Agent tool. If false, the AI Agent can't access the tool during execution. For example, when using the Handover to Human Agent tool, you can enter a condition like `context.issueType === "complaint"`. With this condition, the AI Agent checks the value of the `context.issueType` key in the Context object, and if the key is missing or the value is different from `"complaint"`, the AI Agent can't use the tool. |

#### Execute Workflow Tool

The Execute Workflow tool lets the AI Agent execute another Flow. After the target Flow executes, the conversation returns to the AI Agent.

The target Flow inherits the [Context object](https://docs-classic.cognigy.com/ai/agents/develop/ai-agent-memory/context.md) from the AI Agent. If the target Flow changes the Context object, these changes are also available to the AI Agent.

| Parameter | Type | Description |
| - | - | - |
| Tool ID | CognigyScript | Defines the tool ID. This ID can contain only letters, numbers, underscores (`_`), or dashes (`-`). The default ID is `execute_workflow`. If you use more than one Execute Workflow tool, the tool ID provides context to trigger the correct Execute Workflow tool. In this case, enter a clear tool ID for each Execute Workflow tool, for example, `execute_returns_workflow`. |
| Description | CognigyScript | Defines instructions to guide the AI Agent to call the Execute Workflow tool. The description field provides context to trigger the Execute Workflow tool. Describe when the AI Agent should execute the target Flow. For example, `Use this tool if the user explicitly asks to return a package.` |
| Target Flow | List | Sets the target Flow that the AI Agent executes when this tool is called. Click ![target-flow](https://mintcdn.com/cognigy-docs-legacy/eGdkyf6N-EPpPKZA/_assets/icons/black-and-white/target-flow.svg?fit=max\&auto=format\&n=eGdkyf6N-EPpPKZA\&q=85\&s=abd2ce7a21aecf6da16dfc24b4f994e1) to open the target Flow. |
| Select Node | List | Sets the target Node that the AI Agent executes when the target Flow is called. You must set the Node you want to select as an Entrypoint with the [Set Entrypoint](https://docs-classic.cognigy.com/ai/agents/develop/nodes/overview#set-nodes-as-entrypoints) setting before you can select it. |

> [accordion] Debug Settings
>
> | Parameter | Type | Description |
> | - | - | - |
> | Debug Message when called | Toggle | Activates the output of a debug message when the tool is called to provide detailed information about the tool call. |

> [accordion] Advanced
>
> | Parameter | Type | Description |
> | - | - | - |
> | Parse Intents | Toggle | Sets whether Intents should be parsed in the target Flow. This parameter is activated by default. If this parameter is enabled, Cognigy NLU reparses the Intents in the target Flow based on `text` in the [Input object](https://docs-classic.cognigy.com/ai/agents/develop/ai-agent-memory/input.md#accessing-input-properties) and generates Intent scores using the Intents in the target Flow instead of the ones in the AI Agent's current Flow. |
> | Parse Slots | Toggle | Sets whether Slots should be parsed in the target Flow. This parameter is activated by default. If this parameter is enabled, Cognigy NLU reparses the Slots in the target Flow based on `text` in the [Input object](https://docs-classic.cognigy.com/ai/agents/develop/ai-agent-memory/input.md#accessing-input-properties) and generates Slot scores using the Slots in the target Flow instead of the ones in the AI Agent's current Flow. |
> | Absorb Context | Toggle | Sets whether the [default Context object](https://docs-classic.cognigy.com/ai/agents/develop/ai-agent-memory/context.md#default-context) of the target Flow is used in the context of the Flow the AI Agent is currently in. If the default Context of the target Flow has a value, it is copied into the Context object of the AI Agent as soon as the target Flow is executed. |

## Examples

### Tool

In this example, the `unlock_account` tool unlocks a user account by providing the email and specifying the reason for the unlocking.

Parameter configuration in JSON:

```json theme={null}
{
  "type": "object",
  "properties": {
    "email": {
      "type": "string",
      "description": "User's login email for their account."
    }
  },
  "required": ["email"],
  "additionalProperties": false
}
```

where:

* `type` — the type for a tool parameter schema, which must always be `object`.
* `properties` — defines the parameters for the tool configuration:
  * `email` — a required tool parameter for unlocking the account.
    * `type` — defines the data type for the tool parameter.
    * `description` — a brief explanation of what the property represents.
* `required` — lists `email` as a required parameter, ensuring that this value is always provided when the tool is called.
* `additionalProperties` — ensures that the input contains only the `email` tool parameter, and no others are allowed.

### MCP Tool and Call MCP Tool

#### Use Zapier's Remote MCP server

You can create a custom MCP server with personalized tools by using one of the [provided SDKs](https://github.com/modelcontextprotocol). For a quicker setup, you can use a third-party provider. For example, [Zapier](https://zapier.com/) allows you to [configure your MCP server](https://actions.zapier.com/settings/mcp/), which can be connected to multiple application APIs.

To use Zapier as a remote MCP server, follow these steps:

1. Log in to your Zapier account, go to the [MCP settings](https://actions.zapier.com/settings/mcp/) page, and configure your MCP server.
2. Copy the SSE URL and paste it into the **MCP Server SSE URL** field of your MCP Tool Node.
3. In the Zapier MCP settings, create an action to connect to various APIs. For example, you can create a Zapier action to automatically generate a Google Doc.

Once the setup is complete, the configured MCP Actions will be loaded when the AI Agent is executed.

You will see the following debug message in the Interaction Panel, indicating the result of the tool call after a successful execution:

```txt theme={null}
AI Agent: MCP Tool
Fetched tools from MCP Tool "zapier"

- google_docs_create_document_from_: Create a new document from text. Also supports limited HTML.
  Parameters:
  - title (string): Document Name
  - file (string): Document Content
```

### Knowledge Tool

In this example, you have two Knowledge tools to search two different Knowledge Stores. Each Knowledge Store refers to a different product category, in this example, appliances and furniture. To guide the AI Agent to use the correct Knowledge tool, enter a clear tool ID and description:

* Knowledge Tool 1:
  * Tool ID: `search_appliances`
  * Description: `Find the answer to prompts or questions about appliances by searching the attached data sources. Use this tool when a customer asks about appliance items such as washing machines, dryers, and other household appliances. Focus exclusively on a knowledge search and does not execute tasks like small talk, calculations, or script running.`
* Knowledge Tool 2:
  * Tool ID: `search_furniture`
  * Description: `Find the answer to prompts or questions about furniture by searching the attached data sources. Use this tool when a customer asks about furniture items such as sofas, tables, and other items. Focus exclusively on a knowledge search and does not execute tasks like small talk, calculations, or script running.`

## More Information

* [LLM](https://docs-classic.cognigy.com/ai/agents/develop/gen-ai-and-llms/llms.md)
* [Generative AI](https://docs-classic.cognigy.com/ai/agents/develop/gen-ai-and-llms/generative-ai.md)

***

<sup id="footnote1">1</sup>: Note that not all LLMs support streaming.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.