> For the complete documentation index, see [llms.txt](https://atlas.anywhere.now/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://atlas.anywhere.now/contact-center-configuration/building-your-callflow/via-dialogue-studio/ai-nodes.md).

# Use AI-driven nodes in Dialogue Studio

Configure Azure OpenAI and use the 11 Dialogue Studio AI nodes, including their inputs, outputs, options, and failure behavior.

Dialogue Studio includes 11 Azure OpenAI action nodes for generating responses, extracting information, analyzing messages, and routing conversations. Configure a shared **Azure OpenAI Config** node before adding an action node to a flow. The **Dialogue AI Assist** integration uses a separate node family; see [Integrate Dialogue AI Assist with Dialogue Studio](/channels-integrations/dialogue-studio-integrations/integrate-dialogue-ai-assist-with-dialogue-studio.md).

## Configure Azure OpenAI

You need a deployed model in an Azure OpenAI resource, its resource endpoint, deployment name, and API key. In Dialogue Studio, drag an AI node onto the canvas, select **+** next to **Azure OpenAI Config**, and enter:

| Field                     | What to enter                                                                                                                                                                                                                      |
| ------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Name**                  | Optional label for this configuration, such as the deployment name.                                                                                                                                                                |
| **Azure OpenAI endpoint** | Either the base resource URL (`https://<resource>.openai.azure.com/`) or the full Responses API URL (`https://<resource>.openai.azure.com/openai/v1/responses`). The config node accepts both forms.                               |
| **Model Name**            | The Azure deployment name, not merely the underlying model family name.                                                                                                                                                            |
| **Model Type**            | Select **Reasoning** for reasoning models (such as o1 or GPT-5) or **Standard** for models such as GPT-4o. Reasoning models receive reasoning-effort and text-verbosity settings; standard models use classic sampling parameters. |
| **API Key**               | The key for your Azure OpenAI resource. The node stores it in the credentials store. Do not put it in a flow export or debug message.                                                                                              |
| **Timeout (ms)**          | Request timeout; default `10000`, clamped to `1000`-`60000`.                                                                                                                                                                       |
| **Max Retries**           | Retries for transient errors/timeouts with exponential backoff; default `2`, maximum `10`. Set to `0` to disable retries.                                                                                                          |
| **Input Token Cap**       | Estimated input-token limit before oldest content is truncated; default `20000`.                                                                                                                                                   |

You can reuse one config node across AI nodes or create separate configs for different models. Select the config on each action node. Enable **Include Diagnostics** on an action node to add `usage` (token counts) and `latencyMs` (API round-trip time) to its result. Use **Debug Mode** only while troubleshooting: it can expose request content in the Dialogue Studio debug sidebar.

### Select the input source

Each action node's **Select Source** field reads text from one of these message locations:

| Source                           | Input                                                     |
| -------------------------------- | --------------------------------------------------------- |
| **Payload**                      | `msg.payload`, as text or a supported structured message. |
| **AnywhereNow Audio Transcript** | `msg.payload.transcriptor.transcript`.                    |
| **AnywhereNow Text Transcript**  | `msg.payload.message`.                                    |

Choose the source that actually contains your flow's text. Most nodes return a new `msg.payload` object; retain any correlation data your later nodes need before replacing or branching on that payload. Large inputs can be truncated from the oldest content when they exceed the configured token cap or model context window.

## Generate text and transcripts

### AI Custom Prompt

Use **System Prompt** to define the assistant's role, constraints, and desired response. If you leave it empty, the node uses a general-purpose assistant prompt. With the shared input-source selection and Azure OpenAI Config set, the result is `msg.payload.content` (generated text), `originalMessage`, and `timestamp`. Optional diagnostics add `usage` and `latencyMs`. A blue status dot indicates processing, green success, red an error, and a yellow ring Azure OpenAI rate limiting. Route errors and rate limits to a safe response instead of assuming every output contains `content`.

### AI Response Generator

Generate a reply from the selected message source. Set **Response Style** to **Professional**, **Casual**, **Technical**, or **Empathetic**; optionally add a greeting and signature or provide **Custom Templates** in YAML. **Max Length** is a word limit (50-1000). The result includes `msg.payload.response`, `style`, `wordCount`, `originalMessage`, and `timestamp`, plus optional diagnostics. Check for invalid input, missing configuration, API errors, or an invalid JSON response before sending the reply to a customer.

### AI Transcript Generator

Generate a *synthetic* conversation transcript from a message or topic; this node does not transcribe a live call. Set **Lines** to the target number of generated lines (1-200; default 20). The output contains `msg.payload.transcript` with timestamped speaker lines (`HH:MM:SS Speaker: dialogue`) and `timestamp`, plus optional diagnostics. Handle missing configuration, invalid input, or request failures before consuming the transcript.

## Extract and classify information

### AI Action Detector

Extract commitments and tasks from the selected text. Turn on **Detect Assignees**, **Detect Deadlines**, **Detect Priority**, or **Detect State** as needed. `msg.payload.actions` is an array of objects with `text` and `confidence` (0-1); depending on the input and enabled options, objects can also have `assignee`, `deadline` (ISO 8601 when possible), `priority` (`high`, `medium`, `low`), and `state` (`pending`, `in progress`, `completed`). The payload also includes `originalMessage`, `timestamp`, and optional diagnostics. Treat inferred dates and assignees as model output to verify, not authoritative task records.

### AI Entity Extractor

Select built-in **Entity Types**: names, emails, phones, dates, accounts, and products. Add **Custom Entities** one per line, optionally followed by a colon or dash and a description, such as `order_id: customer order identifier`. Custom names become lowercase `snake_case` keys. If you select no types and define no custom entities, the node requests the default built-in set. `msg.payload.entities` groups extracted values by type as arrays with `value` and `confidence`; some values also include `associated_name`. Only values with confidence at least 0.8 are included, and types without matches have empty arrays. The payload also contains `originalMessage`, `timestamp`, and optional diagnostics. Handle absent text, API errors, and invalid JSON separately from a valid empty result.

### AI Summarizer

Set **Number of Words** to a target summary length of 1-100. The result includes `msg.payload.summary`, `keyPoints` (array), `wordCount`, `originalMessage`, and `timestamp`, plus optional diagnostics. On failure, inspect `msg.payload.error` instead of treating an empty summary as successful. A yellow status dot can indicate a JSON parsing issue.

### AI Sentiment Analyzer

The result contains `msg.payload.positive`, `neutral`, and `negative` scores between 0 and 1, with a `rationale`, `originalMessage`, and `timestamp`. The three scores sum to 1. Optional diagnostics add `usage` and `latencyMs`; error cases can add `error` and `details`. Handle a yellow JSON/format warning or red configuration, input, or API error before using the scores in routing.

### AI Intent Recognizer

Define **Intents** in YAML, giving each category an `intent`, `description`, and example phrases. For example:

```yaml
- intent: Billing
  description: Questions about invoices and payments
  examples:
    - I need a copy of my invoice
- intent: Technical support
  description: Problems using the service
  examples:
    - I cannot sign in
```

The result includes `msg.payload.intent`, `confidence` (0-1), `rationale`, `originalMessage`, and `timestamp`, plus optional diagnostics. It can return `Other` if no defined intent matches. Handle invalid YAML, missing input, API failures, and invalid JSON before routing; a parsing failure can produce an `error` field.

### AI Priority Analyzer

Set **Priority Levels** (default 10), then give distinct **High Priority Example** and **Low Priority Example** messages. The result includes `msg.payload.priority` (1 is highest; the configured maximum is lowest), `rationale`, `originalMessage`, and `timestamp`, plus optional diagnostics. An `error` field can accompany failed processing. Do not treat a JSON warning or missing result as a valid low-priority classification.

## Route and escalate

### AI Escalation Detector

The top **Escalate** output carries messages needing human attention; the bottom **Continue** output carries messages that can continue through the AI flow. The output payload includes `shouldEscalate`, `reason`, `originalMessage`, and `timestamp`, plus optional diagnostics. The node considers requests for a human, strong negative sentiment, sensitive or complex issues, failed resolution attempts, and verification or policy needs. Supply sufficient conversation context. A red status ring indicates an error, not a decision to continue; provide a separate failure route.

### AI Pathfinder

This node uses the **CC Settings Ingest** cache to match a question to an enabled skill. Before using it, configure [CC Settings nodes](/contact-center-configuration/building-your-callflow/via-dialogue-studio/cc-settings-nodes.md), set a specific **Description** on each eligible skill, and set its **PathFinderEnabled** field to **Yes**. Use **UccName** to identify the contact center; it can be a literal value or read from `msg`, flow, or global context. Consider a skill called **Other** as the unmatched fallback and leave **PathFinderEnabled** off for that fallback skill.

The result includes `msg.payload.department` (the selected skill name or `Other`), `availableDepartments`, `originalMessage`, and `timestamp`. Enable **Add Rationale** if the flow needs `rationale`; this increases token use. Optional diagnostics add `usage` and `latencyMs`. The node looks up `cc-settings:<UccName>` in the global cache. A missing cache can return `{ error: "UCC not available" }`; no enabled skills, invalid text, API errors, and invalid model output also need explicit handling. Switch on `department` only after checking for an error or an unrecognized skill. The older DC2025.01 Pathfinder connection-string procedure is not the configuration path for these current AI nodes.

## Verification

1. Confirm the target environment exposes the AI-driven capability that the flow design requires.
2. Test one success path and one fallback path for the AI-driven branch.
3. Confirm the flow reaches a safe next step when the AI response is empty, delayed, or unusable.
4. Confirm the stored endpoint, credential, and model-selection values match the intended environment.
5. Confirm that the node settings and runtime behavior match the production flow design in your deployed version.

## Related topics

Go to **Configure advanced Dialogue Studio features** for the broader admin guidance on AI-driven flow behavior and contact center settings access.

{% content-ref url="/pages/tVbNw2DZ0Mb6w6i0kFlM" %}
[Configure advanced Dialogue Studio features](/contact-center-configuration/building-your-callflow/via-dialogue-studio/configure-advanced-dialogue-studio-features.md)
{% endcontent-ref %}

Go to **Integrate external services with Dialogue Studio** for the durable credential, request, response, and fallback pattern used by external AI services.

{% content-ref url="/spaces/iTek8gfJMjuAJhfqvtuU/pages/HOLQTTPFTbI5AMesxcMD" %}
[Integrate external services with Dialogue Studio](/channels-integrations/dialogue-studio-integrations/integrate-external-services-with-dialogue-studio.md)
{% endcontent-ref %}


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://atlas.anywhere.now/contact-center-configuration/building-your-callflow/via-dialogue-studio/ai-nodes.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.