> ## Documentation Index > Fetch the complete documentation index at: https://docs.monobot.ai/llms.txt > Use this file to discover all available pages before exploring further. # Others ## Overview Other actions provide utility functions that help control flow logic, store values, and manage data during a conversation. Use these actions when you need to save information, reuse values later, or support custom flow behavior. Adds or updates a global state variable during the conversation. This action is used to store a value that can be reused later in the flow. *** ### Required data * **Name**\ Type: `string`\ Name of the global state variable. *Example:* `customer_name` * **Value**\ Type: `string`\ Value to save into the state variable. Supports both static values and dynamic variables. *Example:* `John Smith`\ *Example:* `@name` *** ### Notes * Stores data globally for the duration of the flow. * Can be accessed in other nodes, tools, and actions. * If the variable already exists, its value will be overwritten. * Use meaningful names to keep flows readable. * Use `@variable_name` to pass dynamic values * If the same state variable already exists, the value will be overwritten ### When to use * Save user input for later steps * Store intermediate data between actions * Pass values into tools or API calls *** ### Best practices * Use clear variable names (`user_name`, `phone_number`) * Avoid overwriting important values unintentionally * Store only necessary data for later use Returns the current number of messages in the conversation in real time. *** ### Description Retrieves the total number of messages exchanged in the current interaction. Useful for controlling conversation flow, applying limits, or triggering logic based on message count. ### Async mode * **Async**\ Type: `boolean` If enabled, the action runs in the background and the bot continues the conversation without waiting for the result. *** ### Output Returns: ``` 6 ``` Finds the most relevant HS (commodity) code based on a product name or description using an LLM-powered classification search. ### Required data * **Product**\ Type: `string` Product name or short description used to identify the correct commodity code. *Example:* `Wooden dining table` *** ### Optional parameters * **Language**\ Type: `string` Language used for the search and response. *Options:* `en`, `ro`, `ru`, `xx`\ *Default:* `en` Write a custom function in the built-in code editor and return structured output for later steps in the flow. ### Required data * **Function**\ Type: `code` Custom function written in Python that processes input data and returns structured output. *Example:* ```python theme={null} def _foo(tool_params: dict, interaction_data: dict): # do something here return {"result": "ok"} ``` ### Optional parameters * **TTL**\ Type: `number` Time-to-live for cached results (in seconds). *Example:* `30` ### Async mode * **Async**\ Type: `boolean` If enabled, the action runs in the background and the bot continues the conversation without waiting for the result. ### Output Returns structured data defined by the function. ```json theme={null} { "key": "value" } ``` ## Debug Logging Custom logs can be added inside the function and viewed later in the bot Debug Mode. This is useful for troubleshooting, inspecting API responses, validating variables, or debugging function execution flow. ### Example ```python theme={null} interaction_data.get("_LOGGING").warning("LOG api_call_response type:") interaction_data.get("_LOGGING").warning(type(api_call_response).__name__) interaction_data.get("_LOGGING").warning("LOG api_call_response content:") interaction_data.get("_LOGGING").warning(api_call_response) ``` ## Supported Logging Methods * `warning()` * `info()` * `error()` * `debug()` ## Where to View Logs Logs can be viewed in: `Bot Configuration → Debug Mode` ### Notes * Use `tool_params` to access input parameters. * Use `interaction_data` for conversation context. * Define response schemas if needed for structured outputs. * Logging is useful for debugging custom functions and integrations. * Logs can help inspect API responses, variables, and execution flow. * Excessive logging may produce large debug outputs. * Sensitive information should not be logged. Filters CSV data by specific column values based on defined conditions. ### Required data * **Column Name**\ Type: `string`\ Name of the column used for filtering.\ *Example:* `status` * **CSV Category Name**\ Type: `string`\ Name of the CSV dataset (category).\ *Example:* `orders` * **Filter Value**\ Type: `string`\ Value used to filter rows.\ *Example:* `completed` ### Optional parameters * **Comparison Operator**\ Type: `string` Defines how values are compared. *Options:* * `Equal` * `Not Equal` * `Greater Than` * `Less Than` * `Greater Than or Equal` * `Less Than or Equal` * `Contains` * `Does Not Contain` * `Starts With` * `Ends With` *Default:* `Equal` ### Async mode * **Async**\ Type: `boolean` Runs in background without waiting for result. ### Output Returns filtered rows: ```json theme={null} [ { "column": "value" } ] ``` ### Notes * Column names must match CSV exactly * Operators depend on data type (text vs number) * Use `Contains` / `Starts With` for text filtering * Use numeric operators for numbers Retrieves relevant information from a vector store and generates a response using a selected model. This action combines search (retrieval) and reasoning to produce answers based on your knowledge base. ### Use cases * Answer questions based on internal knowledge * Search through documentation or FAQs * Provide contextual responses from stored data * Combine retrieval with AI-generated output ### Required data * **Vector store ID**\ Type: `string`\ Identifier of the vector database used for retrieval. * **Instruction**\ Type: `string`\ Defines how the model should behave and format the response. * **Query**\ Type: `string`\ Search input used to retrieve relevant data. ### Optional data * **Model name**\ Type: `string`\ Model used for response generation. *Example:* `gpt-5 nano` * **Reasoning level**\ Type: `string`\ Controls depth of reasoning. *Example:* `None`, `Low`, `Medium`, `High` * **Web search**\ Type: `boolean`\ Enables fallback to web data if needed. ### Output * Returns a generated response based on retrieved data * Combines vector search results with model reasoning ### Notes * Quality depends on the vector store content * Better queries improve retrieval accuracy * Higher reasoning increases latency but improves results * Use clear instructions to control tone and structure Returns a user-defined value to the LLM, which the assistant uses to generate its response. ### Use cases * Pass calculated or processed data to the model * Override or enrich the assistant response * Inject dynamic values into the conversation * Control final output of a flow ### Required data * **Custom value**\ Type: `string`\ Value returned to the model. *Example:* `Your appointment is confirmed for tomorrow at 3 PM` ### Optional data * **Async**\ Type: `boolean`\ Runs the action in the background without waiting for the result. ### Output * Returns the defined value to the LLM * Used by the assistant to generate or modify the response ### Notes * Value should be clear and ready for direct use * Avoid unnecessary formatting or extra text * Use when you need full control over what the model receives Navigates to a specific conversation step by setting the active flow. This action allows you to redirect the conversation to another flow or node within the workflow. ### Use cases * Redirect user to another flow * Split logic between different workflows * Handle fallback or escalation scenarios * Reuse existing flows ### Required data * **Set current flow**\ Type: `string`\ Name of the target flow or node. *Example:* `booking_flow` ### Optional data * **Make as transition**\ Type: `boolean`\ Treats the action as a transition between nodes. * **Incognito call**\ Type: `boolean`\ Executes the flow without affecting visible conversation state. * **Only if everything was successful**\ Type: `boolean`\ Executes only if previous actions completed successfully. * **Async**\ Type: `boolean`\ Runs the action in the background without waiting for completion. ### Output * Redirects the conversation to the specified flow * Updates the current execution context ### Notes * Target flow must exist in the system * Use clear and consistent naming for flows * Avoid circular flow transitions Displays multiple selectable hints in the chat widget to guide user interaction. This action presents predefined options that users can click instead of typing, improving usability and flow control. ### Use cases * Provide quick reply options * Guide users through predefined flows * Reduce typing effort * Improve conversion in structured scenarios ### Required data * **List of hints**\ Type: `string`\ List of options displayed to the user, one per line. *Example:* ``` Book an appointment Check availability Contact support ``` ### Optional data * **Async**\ Type: `boolean`\ Runs the action in the background without waiting for completion. ### Output * Displays clickable hints in the widget * User selection is returned as input to the conversation ### Notes * One hint per line * Keep hints short and clear * Limit the number of options to avoid overload * Ensure options match available flow paths Uses the LLM to generate relevant hint options and display them as selectable choices in the widget chat. This action dynamically creates suggestions based on context, improving user guidance without predefined options. ### Use cases * Generate dynamic quick replies * Suggest next steps based on user input * Adapt hints to conversation context * Improve engagement without hardcoded options ### Required data * **Custom prompt**\ Type: `string`\ Instruction for the LLM to generate hints. *Example:* ``` Generate 3 short options a user might choose next for booking a service. Keep them concise and action-oriented. ``` ### Optional data * **Async**\ Type: `boolean`\ Runs the action in the background without waiting for completion. ### Output * Displays generated hints in the widget * Each hint is returned as selectable user input ### Notes * Keep prompts clear and specific * Limit number of generated hints (e.g., 3–5) * Ensure hints are short and easy to understand * Avoid vague or overly long suggestions Generates a concise summary of the conversation between the client and the AI assistant based on a custom instruction. This action analyzes the chat and returns structured insights such as key points, conclusions, and important details. ### Use cases * Generate conversation summaries * Extract key facts and decisions * Prepare reports for team review * Send summaries via email or integrations ### Required data * **Instruction**\ Type: `string`\ Defines how the summary should be structured and what to include. *Example:* ``` Summarize the conversation. Include: - Main request - Key details - Final outcome ``` ### Optional data * **Cut conversation**\ Type: `boolean`\ Clears or resets the conversation after summary is generated. * **Run immediately**\ Type: `boolean`\ Executes the action instantly when triggered. * **Only if everything was successful**\ Type: `boolean`\ Runs only if previous actions completed successfully. * **Async**\ Type: `boolean`\ Runs the action in the background without waiting for completion. ### Output * Returns a structured summary of the conversation * Can be used in further actions (email, CRM, logs, etc.) ### Notes * Keep instructions clear and structured * Avoid overly long prompts * Output format depends on the instruction * Useful for automation and reporting workflows Pauses the conversation flow for a specified amount of time before continuing. This action introduces a delay, allowing you to control timing between messages or actions. ### Use cases * Add delay between messages * Simulate human-like response timing * Wait before triggering next action * Control pacing in workflows ### Required data * **Timeout**\ Type: `number`\ Number of seconds the assistant should wait before continuing. *Example:* `5` ### Optional data * **Async**\ Type: `boolean`\ Runs the action in the background without blocking the conversation. ### Output * Delays execution of the next step in the flow * Continues automatically after the specified time ### Notes * Value is in seconds * Use short delays to avoid poor user experience * Async mode allows conversation to continue without waiting Adds or updates Call Attached Data (CAD) values during the interaction. This action allows storing custom key-value data that can later be used by SIP integrations, external systems, APIs, workflows, or reporting tools. CAD values can contain static values, tool parameters, action results, or dynamic interaction variables. ### Use Cases * Store tool execution results in CAD * Attach custom interaction metadata * Pass values to external SIP providers * Save routing or workflow information * Add reporting or analytics fields ## Configuration Before using this action, configure Dynamic Values in: `Bot Configuration → Integrations → SIP Integration → Call Attached Data` See [Call Attached Data](../../actions/telephony/call_attached_data) ## Parameters | Parameter | Description | | ----------------------- | ----------------------------------------------------------------------------- | | Key | CAD field name configured in SIP Integration. | | Value | Static value or dynamic interaction value assigned to the field. | | Append to existing data | Appends new values instead of overwriting existing CAD data. | | Async | Executes the action in the background without blocking the conversation flow. | ## Supported Value Sources Values can contain: * Static text * Tool parameters * Action results * Interaction variables * Bot variables * Dynamic Values ## Example | Key | Value | | -------------------- | ------------------ | | `int_dynamic_value1` | `Interaction Type` | | `summary` | `Tool Result` | | `status` | `finished` | ## Notes * CAD values become available for downstream SIP integrations and APIs. * Configured keys must exist in SIP Integration CAD settings. * Existing values may be overwritten unless "Append to existing data" is enabled. * Async mode allows the bot to continue the conversation without waiting for action completion.