How can I build an AI chat agent workflow with OTP validation for CRM account retrieval?

Below is an example outline of what such a workflow might look like. Note that there isn’t an official, published workflow that exactly implements OTP validation for an AI chat agent. However, you can build one by combining several of n8n’s nodes. One approach is to:

1. Trigger the Chat:
   Use a Chat Trigger node to start the conversation.

2. Generate and Send OTP:
   – Use a Function node to generate a random OTP.
   – Send the OTP to the user (for example, by replying directly in the chat or via another channel).

3. Collect User Input:
   Use a Webhook node (or a dedicated chat input node) to capture the OTP the user submits.

4. Validate the OTP:
   – Use a Function node or an HTTP Request node (if your CRM or database exposes an API) to compare the submitted OTP with what was generated/stored.
   – Optionally, look up the user’s account details in your external CRM at this point.

5. Route Based on Verification:
   If the OTP matches, continue to process the chat request (for example, by passing control to your AI Agent node or by calling your AI Chat workflow). Otherwise, end the workflow with an appropriate error message.

6. Return the Final Output:
   The last node could be a Set node (or another integration node) that packages the account data (or an error message) and sends it back to the user.

Below is a sample workflow skeleton (in JSON format) to illustrate the idea. This example is only a starting point—you’d need to refine the actual nodes, credentials, and custom code to match your environment and CRM integration.

JSONCopied
{
  "name": "AI Agent with OTP Validation",
  "nodes": [
    {
      "name": "Chat Trigger",
      "type": "n8n-nodes-base.chatTrigger",
      "typeVersion": 1,
      "position": [100, 300],
      "parameters": {
        "chatInputMode": "text"
      }
    },
    {
      "name": "Generate OTP",
      "type": "n8n-nodes-base.function",
      "typeVersion": 1,
      "position": [300, 300],
      "parameters": {
        "functionCode": "const otp = Math.floor(100000 + Math.random() * 900000).toString();\n// Store the OTP in the workflow data for later comparison\nitems[0].json.otp = otp;\n\n// Simulate sending the OTP to the user (in practice, you might call an SMS/email service or send via chat)\nconsole.log('Generated OTP:', otp);\n\nreturn items;"
      }
    },
    {
      "name": "Send OTP Response",
      "type": "n8n-nodes-base.set",
      "typeVersion": 1,
      "position": [500, 300],
      "parameters": {
        "values": {
          "string": [
            {
              "name": "message",
              "value": "An OTP has been sent to your registered contact. Please reply with the OTP to continue."
            }
          ]
        }
      }
    },
    {
      "name": "Receive OTP",
      "type": "n8n-nodes-base.webhook",
      "typeVersion": 1,
      "position": [700, 300],
      "parameters": {
        "path": "receive-otp",
        "method": "POST"
      }
    },
    {
      "name": "Validate OTP",
      "type": "n8n-nodes-base.function",
      "typeVersion": 1,
      "position": [900, 300],
      "parameters": {
        "functionCode": "const receivedOtp = items[0].json.otpInput; // assume the OTP the user provided is in this field\nconst generatedOtp = $json[\"otp\"];\n\nif (receivedOtp === generatedOtp) {\n  // For example, call an HTTP Request node or lookup CRM data here\n  items[0].json.validation = 'success';\n  // You might add or fetch account info and assign to items[0].json.account\n} else {\n  items[0].json.validation = 'failed';\n  items[0].json.message = 'Invalid OTP provided.';\n}\n\nreturn items;"
      }
    },
    {
      "name": "Fetch Account Data",
      "type": "n8n-nodes-base.httpRequest",
      "typeVersion": 1,
      "position": [1100, 300],
      "parameters": {
        "url": "https://your-crm.domain/api/account-info",
        "method": "GET",
        "queryParameters": [
          {
            "name": "userId",
            "value": "={{$json[\"userId\"]}}"
          }
        ]
      },
      "conditions": {
        "string": [
          {
            "value1": "={{$json[\"validation\"]}}",
            "value2": "success"
          }
        ]
      }
    },
    {
      "name": "Return Final Output",
      "type": "n8n-nodes-base.set",
      "typeVersion": 1,
      "position": [1300, 300],
      "parameters": {
        "values": {
          "json": [
            {
              "name": "accountInfo",
              "value": "={{ $json }}"
            }
          ]
        }
      }
    }
  ],
  "connections": {
    "Chat Trigger": {
      "main": [
        [
          {
            "node": "Generate OTP",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Generate OTP": {
      "main": [
        [
          {
            "node": "Send OTP Response",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Send OTP Response": {
      "main": [
        [
          {
            "node": "Receive OTP",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Receive OTP": {
      "main": [
        [
          {
            "node": "Validate OTP",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Validate OTP": {
      "main": [
        [
          {
            "node": "Fetch Account Data",
            "type": "main",
            "index": 0
          }
        ],
        [
          {
            "node": "Return Final Output",
            "type": "main",
            "index": 0
          }
        ]
      ]
    },
    "Fetch Account Data": {
      "main": [
        [
          {
            "node": "Return Final Output",
            "type": "main",
            "index": 0
          }
        ]
      ]
    }
  }
}

In this example, the last node (“Return Final Output”) would return a JSON object that could look similar to this when the OTP has been validated and account data has been fetched:

JSONCopied
{
  "accountInfo": {
    "accountId": "12345",
    "accountName": "John Doe",
    "status": "Verified"
  }
}

A couple of points to note:

• The OTP generation, distribution, and verification logic will likely need refinement for production—especially considering security and state management.
• You might need to persist the generated OTP in your database or a secure cache if the workflow runs asynchronously.
• The actual lookup in your CRM may require handling authentication (via credentials) and formatting the response appropriately.
• The above example is a starting point. Depending on your chat setup (for example, if you’re using an AI Agent node to process post-validation queries), you may need additional steps to route validated user sessions to the proper conversation thread.

Feel free to iterate on this example to suit your specific business logic and integration requirements. If you have a working draft and run into issues, I’d be happy to help troubleshoot or refine the workflow further.