ಏಜೆಂಟ್ ಹಂತಗಳು ಮತ್ತು ಹಸ್ತಾಂತರಗಳು

ಏಜೆಂಟ್ ಅನ್ನು ತನ್ನದೇ ಆದ ಸೂಚನೆಗಳು, ಪರಿಕರಗಳು ಮತ್ತು ಸಂಗ್ರಹಿಸಿದ ಮೌಲ್ಯಗಳಿರುವ ಹಂತಗಳಾಗಿ ವಿಭಜಿಸಿ, ಮತ್ತು ಕರೆಯ ಮಧ್ಯದಲ್ಲೇ ಏಜೆಂಟ್‌ಗಳ ನಡುವೆ ಕರೆಗಳನ್ನು ಹಸ್ತಾಂತರಿಸಿ.

ಒಂದೇ prompt ಮಾದರಿಗೆ ಸಂಪೂರ್ಣ ಕೆಲಸವನ್ನು ಒಂದೇ ಬಾರಿಗೆ ನೀಡುತ್ತದೆ. ಹಂತಗಳು ಅದಕ್ಕೆ ಕರೆಯ ಒಂದು ಹಂತವನ್ನು ಒಂದೇ ಬಾರಿಗೆ ನೀಡುತ್ತವೆ: ಪ್ರತಿ ಹಂತಕ್ಕೂ ತನ್ನದೇ ಸೂಚನೆಗಳು, ತನ್ನದೇ ಸಾಧನಗಳು, ಪದಕ್ಕೆ ಪದವಾಗಿ ಹೇಳಬೇಕಾದ ಐಚ್ಛಿಕ ಸಾಲು ಮತ್ತು ಮುಂದುವರಿಯುವ ಮೊದಲು ಸಂಗ್ರಹಿಸಬೇಕಾದ ಮೌಲ್ಯಗಳಿರುತ್ತವೆ. ಹಸ್ತಾಂತರಗಳು ನಿಮ್ಮ ಸಂಸ್ಥೆಯಲ್ಲಿರುವ ಮತ್ತೊಂದು ಏಜೆಂಟ್‌ಗೆ ಕರೆಯ ಮಧ್ಯದಲ್ಲೇ, ಟ್ರಾನ್ಸ್‌ಕ್ರಿಪ್ಟ್ ಹಾಗೆಯೇ ಉಳಿದಿರುವಾಗ, ಜವಾಬ್ದಾರಿ ವಹಿಸಿಕೊಳ್ಳಲು ಅವಕಾಶ ನೀಡುತ್ತವೆ, ಆದ್ದರಿಂದ ಕರೆಮಾಡುವವರು ತಮ್ಮ ಮಾತನ್ನು ಪುನರಾವರ್ತಿಸಬೇಕಾಗುವುದಿಲ್ಲ.

ಪ್ರತಿಯೊಂದು ಏಜೆಂಟ್ ಒಂದೇ prompt ಆಗಿ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ. ನೀವು ಹಂತಗಳು ಅಥವಾ ಹಸ್ತಾಂತರಗಳನ್ನು ಸೇರಿಸುವವರೆಗೆ ಅದರ ಬಗ್ಗೆ ಏನೂ ಬದಲಾಗುವುದಿಲ್ಲ.

ಹಂತಗಳೇ ಅಥವಾ ಒಂದೇ prompt?#

ಹಂತಗಳು ಸ್ಕ್ರಿಪ್ಟ್ ಮಾಡಿದ ಫೋನ್ ಟ್ರೀ ಅಲ್ಲ. ಒಂದು ಹಂತದ ಒಳಗೆ ಮಾದರಿಯು ಒಂದೇ prompt ಜೊತೆಗೆ ಮಾಡುವಂತೆಯೇ ಸಂಭಾಷಣೆಯನ್ನು ನಡೆಸುತ್ತದೆ. ಹಂತವು ಅದು ಯಾವುದರ ಮೇಲೆ ಕೆಲಸ ಮಾಡುತ್ತಿದೆ, ಯಾವ ಸಾಧನಗಳನ್ನು ಬಳಸಬಹುದು ಮತ್ತು ಹೊರಬರುವ ಮೊದಲು ಅದಕ್ಕೆ ಏನು ಬೇಕು ಎಂಬುದನ್ನು ನಿರ್ಧರಿಸುತ್ತದೆ.

ಹಂತಗಳನ್ನು ಹೊಂದಿರುವ ಏಜೆಂಟ್ ಅನ್ನು ಹೇಗೆ ನಿರ್ಮಿಸಲಾಗುತ್ತದೆ#

ಏಜೆಂಟ್ ಹಂತಗಳನ್ನು ಹೊಂದಿದ್ದಾಗ, ಅದರ prompt ಹಂಚಿಕೆಯ ಸೂಚನೆಗಳನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ: ಪ್ರತಿಯೊಂದು ಹಂತಕ್ಕೂ ಅನ್ವಯವಾಗುವ ವ್ಯಕ್ತಿತ್ವ ಮತ್ತು ನಿಯಮಗಳು. ಪ್ರತಿ ಹಂತವು ತನ್ನದೇ ಸೂಚನೆಗಳನ್ನು ಅದರ ಮೇಲೆ ಸೇರಿಸುತ್ತದೆ. ಪ್ರತಿ ಸರದಿಯಲ್ಲಿ ಮಾದರಿಯು ಹಂಚಿಕೆಯ ಸೂಚನೆಗಳು, ಪ್ರಸ್ತುತ ಹಂತದ ಹೆಸರು ಮತ್ತು ಸೂಚನೆಗಳು ಹಾಗೂ ಇದುವರೆಗೆ ಸಂಗ್ರಹಿಸಲಾದ ಮೌಲ್ಯಗಳನ್ನು ನೋಡುತ್ತದೆ.

ಬಿಲ್ಡರ್‌ನಲ್ಲಿ, ಏಜೆಂಟ್ ಅನ್ನು ಏಕ prompt ನಿಂದ ಹಂತಗಳು ಗೆ ಬದಲಾಯಿಸಿ. ನಿಮಗೆ ಪ್ರತಿ ಹಂತಕ್ಕೆ ಅದರ ಹೆಸರು, ಸೂಚನೆಗಳು, ಹೇಳುವ ಸಾಲು, ಸಾಧನಗಳು, ಸಂಗ್ರಹಿಸಿದ ಮೌಲ್ಯಗಳು ಮತ್ತು ಪರಿವರ್ತನೆಗಳನ್ನು ಹೊಂದಿರುವ ಕಾರ್ಡ್, ಹಸ್ತಾಂತರಗಳ ಆಯ್ಕೆಗಾರ ಮತ್ತು ಹಂತಗಳ ಓದಲು-ಮಾತ್ರದ ಫ್ಲೋ ಗ್ರಾಫ್ ದೊರೆಯುತ್ತದೆ. ಮತ್ತೆ ಒಂದೇ prompt ಗೆ ಬದಲಾಯಿಸಿದಾಗ, ಹಂಚಿಕೆಯ ಸೂಚನೆಗಳು ಮತ್ತು ಪ್ರತಿಯೊಂದು ಹಂತವನ್ನು ವಿಲೀನಗೊಳಿಸುವ ಸಮತಟ್ಟಾದ prompt ಅನ್ನು ನೀಡಲಾಗುತ್ತದೆ.

API ಮೂಲಕ, steps ಮತ್ತು handoffs ಗಳು ಏಜೆಂಟ್ ಮೇಲಿನ ಫೀಲ್ಡ್‌ಗಳಾಗಿವೆ. ಪ್ರತಿಯೊಂದು ಏಜೆಂಟ್ ಫೀಲ್ಡ್‌ನಂತೆ, PATCH ಅವುಗಳನ್ನು ಡ್ರಾಫ್ಟ್‌ನಲ್ಲಿ ಹಂತಗೊಳಿಸುತ್ತದೆ; POST /v1/agents/{agent_id}/deploy ಅವುಗಳನ್ನು ಲೈವ್ ಮಾಡುತ್ತದೆ. "steps": null ಕಳುಹಿಸುವುದರಿಂದ ಏಜೆಂಟ್ ಮತ್ತೆ ಒಂದೇ prompt ಗೆ ಬದಲಾಗುತ್ತದೆ. ಪರೀಕ್ಷಾ ಕರೆಗಳು ಮತ್ತು ಮಾತನಾಡಿ ಡ್ರಾಫ್ಟ್ ಅನ್ನು ನಡೆಸುತ್ತವೆ.

ಹಂತದ ಫೀಲ್ಡ್‌ಗಳು#

ಗ್ರಾಫ್ ಸ್ವತಃ {"start_step": "<step id>", "steps": [...]} ಆಗಿದೆ. ಕರೆ start_step ನಲ್ಲಿ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ.

ಪರಿವರ್ತನೆಗಳು#

ಪ್ರತಿ ಪರಿವರ್ತನೆಯು to, ಒಂದು ಹಂತದ ಐಡಿ, ಮತ್ತು ಈ ಕೆಳಗಿನವುಗಳಲ್ಲಿ ನಿಖರವಾಗಿ ಒಂದನ್ನು ಹೊಂದಿರುತ್ತದೆ:

• when: ಸರಳ ಭಾಷೆ, ಮತ್ತು ಮಾದರಿಯೇ ನಿರ್ಧರಿಸುತ್ತದೆ. ಏಜೆಂಟ್‌ಗೆ ಅಂತರ್ನಿರ್ಮಿತ go_to_step ಉಪಕರಣ ದೊರೆಯುತ್ತದೆ; ಇದು ಅದು ಹೋಗಬಹುದಾದ ಹಂತಗಳನ್ನು ಪಟ್ಟಿ ಮಾಡುತ್ತದೆ ಮತ್ತು ಪ್ರತಿ when ಅನ್ನು ಅದನ್ನು ಆಯ್ಕೆಮಾಡುವ ಕಾರಣವಾಗಿ ಹೊಂದಿರುತ್ತದೆ.
• condition: ಸಂಗ್ರಹಿಸಿದ ಮೌಲ್ಯಗಳ ಮೇಲಿನ ನಿಯಮ, ಮತ್ತು ಕೋಡ್ ನಿರ್ಧರಿಸುತ್ತದೆ. ಮಾದರಿಯು ಇದನ್ನು ಬಿಟ್ಟುಹೋಗಲು ಅಥವಾ ಮಾತನಾಡಿ ತಪ್ಪಿಸಿಕೊಳ್ಳಲು ಸಾಧ್ಯವಿಲ್ಲ.
• "always": true: ಪರಿಶೀಲನೆಯಿಲ್ಲದೆ ಮುಂದುವರಿಯಿರಿ. ಕೋಡ್ ಮೊದಲು ನಿರ್ಧರಿಸುತ್ತದೆ: ಒಂದು ಹಂತವನ್ನು ಪ್ರವೇಶಿಸಿದ ತಕ್ಷಣ, ಅಥವಾ ಅದರ ಅಗತ್ಯ ಮೌಲ್ಯಗಳನ್ನು ಸಂಗ್ರಹಿಸಿದ ಬಳಿಕ, ಮಾದರಿಯು when ಅನ್ನು ಆಯ್ಕೆಮಾಡುವ ಮೊದಲು ಹೊಂದಿಕೆಯಾಗುವ ಮೊದಲ condition ಅಥವಾ always ಪರಿವರ್ತನೆಯೇ ಅನ್ವಯವಾಗುತ್ತದೆ. ಆದ್ದರಿಂದ always ಅನ್ನು ಷರತ್ತುಗಳ ನಂತರ ಅವುಗಳ ಪರ್ಯಾಯವಾಗಿ ಇರಿಸಿ, ಅಥವಾ ಒಂದು ಹಂತವನ್ನು ನೇರವಾಗಿ ಮುಂದಿನದಕ್ಕೆ ಜೋಡಿಸಲು ಅದನ್ನು ಪ್ರತ್ಯೇಕವಾಗಿ ಇರಿಸಿ. always ಇರುವ ಹಂತವು when ಆಯ್ಕೆಗಾಗಿ ಎಂದಿಗೂ ಕಾಯುವುದಿಲ್ಲ.

ಒಂದು condition ಹೀಗಿರುತ್ತದೆ: {"value": <collected name or dotted path>, "op": <op>, "target": <literal>}:

eq, ne, in ಮತ್ತು not_in ಖಾಲಿ ಜಾಗಗಳನ್ನು ತೆಗೆದ ನಂತರ ಪಠ್ಯವನ್ನು ಅಕ್ಷರದ ದೊಡ್ಡ-ಸಣ್ಣ ವ್ಯತ್ಯಾಸವಿಲ್ಲದೆ ಹೋಲಿಸುತ್ತವೆ. ಸಂಖ್ಯೆಗಳು ಸಂಖ್ಯೆಗಳಾಗಿ ಮತ್ತು ದಿನಾಂಕಗಳನ್ನು YYYY-MM-DD ಸ್ಟ್ರಿಂಗ್‌ಗಳಾಗಿ ಹೋಲಿಸಲಾಗುತ್ತದೆ. ಎಂದಿಗೂ ಸಂಗ್ರಹಿಸದ ಮೌಲ್ಯವು missing ಹೊರತುಪಡಿಸಿ ಪ್ರತಿಯೊಂದು op ಅನ್ನು ತಪ್ಪು ಎಂದು ಮಾಡುತ್ತದೆ.

when ಮತ್ತು global_when ಅನ್ನು ಹೇಳಬೇಕಾದ ವಿಷಯವಾಗಿ ಅಲ್ಲದೆ, "ಕರೆಮಾಡುವವರು ಅಪಾಯಿಂಟ್‌ಮೆಂಟ್ ಕಾಯ್ದಿರಿಸಲು ಬಯಸುತ್ತಾರೆ" ಎಂಬಂತಹ ಷರತ್ತಾಗಿ ಬರೆಯಿರಿ. ಏಜೆಂಟ್ ಇವುಗಳನ್ನು ಆಂತರಿಕ ರೂಟಿಂಗ್ ಟಿಪ್ಪಣಿಗಳಾಗಿ ನೋಡುತ್ತದೆ ಮತ್ತು ಅವುಗಳನ್ನು ಎಂದಿಗೂ ಗಟ್ಟಿಯಾಗಿ ಓದಬಾರದು ಅಥವಾ ತಾನು ಹಂತಗಳನ್ನು ಬದಲಾಯಿಸುತ್ತಿದೆ ಎಂದು ಉಲ್ಲೇಖಿಸಬಾರದು ಎಂದು ಸೂಚಿಸಲಾಗುತ್ತದೆ.

ಮಾದರಿಯು go_to_step ಅನ್ನು ಕರೆಯುವಾಗ:

1. ಹಂತದಲ್ಲಿರುವ ಪ್ರತಿಯೊಂದು required ಮೌಲ್ಯವೂ ಇರಬೇಕು. ಒಂದು ಕಾಣೆಯಾಗಿದ್ದರೆ, ಮಾದರಿಗೆ ಯಾವುದು ಕಾಣೆಯಾಗಿದೆ ಎಂದು ತಿಳಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಅದು ಕರೆಮಾಡುವವರನ್ನು ಅದಕ್ಕಾಗಿ ಕೇಳುತ್ತದೆ.
2. ಮೌಲ್ಯಗಳನ್ನು ಸಂಗ್ರಹಿಸಲಾಗುತ್ತದೆ.
3. condition ಮತ್ತು always ಪರಿವರ್ತನೆಗಳನ್ನು ಕ್ರಮವಾಗಿ ಪರಿಶೀಲಿಸಲಾಗುತ್ತದೆ. ಮೊದಲ ಹೊಂದಾಣಿಕೆಯೇ ಅನ್ವಯವಾಗುತ್ತದೆ.
4. ಇಲ್ಲದಿದ್ದರೆ ಏಜೆಂಟ್ ಮಾದರಿಯು ಆಯ್ಕೆಮಾಡಿದ ಹಂತಕ್ಕೆ ಚಲಿಸುತ್ತದೆ.
5. ಯಾವುದೂ ಹೊಂದಿಕೆಯಾಗದಿದ್ದರೆ ಮತ್ತು ಮಾದರಿಯು ಯಾವುದೇ ಹಂತವನ್ನು ಹೆಸರಿಸದಿದ್ದರೆ, ಏಜೆಂಟ್ ಅಲ್ಲಿಯೇ ಉಳಿಯುತ್ತದೆ.

ಒಂದು ಜಾಗತಿಕ ಹಂತಕ್ಕೆ ಜಿಗಿಯುವುದು ಇದಕ್ಕೆ ಹೊರತಾಗಿದೆ: ಕರೆಮಾಡುವವರು ವಿಷಯವನ್ನು ಬದಲಾಯಿಸಿದ್ದಾರೆ, ಆದ್ದರಿಂದ ಪ್ರಸ್ತುತ ಹಂತದಲ್ಲಿ ಇನ್ನೂ ಅಗತ್ಯ ಮೌಲ್ಯಗಳು ಕಾಣೆಯಾಗಿದ್ದರೂ, ಮತ್ತು ಆ ಹಂತದ ಷರತ್ತುಗಳನ್ನು ಪರಿಶೀಲಿಸುವ ಮೊದಲು, ಅದು ಮುಂದುವರಿಯುತ್ತದೆ.

ಪ್ರತಿ ಬಾರಿ ಒಂದು ಹಂತವನ್ನು ಪ್ರವೇಶಿಸಿದಾಗಲೂ condition ಮತ್ತು always ಪರಿವರ್ತನೆಗಳನ್ನು ಪರಿಶೀಲಿಸಲಾಗುತ್ತದೆ; ಆದ್ದರಿಂದ ಕೋಡ್-ನಿರ್ಧರಿತ ಹಂತಗಳ ಸರಣಿಯು ಒಂದೇ ಬಾರಿಗೆ ಕಾರ್ಯಗತವಾಗುತ್ತದೆ. ಸರಣಿಯು ಈ ಸಂದರ್ಭಗಳಲ್ಲಿ ನಿಲ್ಲುತ್ತದೆ:

• ಈ ಕಾರ್ಯಾಚರಣೆಯಲ್ಲಿ ಈಗಾಗಲೇ ಭೇಟಿಯಾದ ಹಂತದಲ್ಲಿ;
• 8 ಜಿಗಿತಗಳ ನಂತರ;
• ಹಂತವು ಇನ್ನೂ ಸಂಗ್ರಹಿಸಬೇಕಾದ ಅಗತ್ಯ ಮೌಲ್ಯಗಳನ್ನು ಹೊಂದಿರುವಾಗ, ಆ ಹಂತದಲ್ಲಿ on_enter_tool ಇಲ್ಲದಿದ್ದರೆ (ಒಂದು ವೆಬ್‌ಹುಕ್ ಹಂತವು ಯಾವಾಗಲೂ ಅದರ ಫಲಿತಾಂಶದ ಆಧಾರದ ಮೇಲೆ ರೂಟ್ ಆಗುತ್ತದೆ).

ಸರಣಿ ನಿಲ್ಲುವ ಹಂತದ say ಸಾಲು ಮಾತ್ರ ಮಾತನಾಡಲಾಗುತ್ತದೆ.

ಯಾವುದೇ ಪರಿವರ್ತನೆಗಳಿಲ್ಲದ ಹಂತವು ಅಂತಿಮವಾಗಿದೆ. ಏಜೆಂಟ್ ಅಲ್ಲಿ ಪೂರ್ಣಗೊಳಿಸಿ, ತನ್ನ ಸಾಮಾನ್ಯ ಅಂತರ್ನಿರ್ಮಿತ ಕ್ರಿಯೆಗಳ ಮೂಲಕ ಕರೆಯನ್ನು ಕೊನೆಗೊಳಿಸುತ್ತದೆ ಅಥವಾ ವರ್ಗಾಯಿಸುತ್ತದೆ.

ಮೌಲ್ಯಗಳನ್ನು ಸಂಗ್ರಹಿಸುವುದು#

ಒಂದು ಹಂತಕ್ಕೆ ಬೇಕಾದವುಗಳನ್ನು collect ನಲ್ಲಿ ಪಟ್ಟಿ ಮಾಡಿ. ಮಾದರಿಯು go_to_step ಅನ್ನು ಕರೆಯುವಾಗ ಮೌಲ್ಯಗಳನ್ನು ರವಾನಿಸುತ್ತದೆ ಮತ್ತು ಅವು ಕರೆಯ ಉಳಿದ ಭಾಗಕ್ಕೆ ಲಭ್ಯವಾಗಿರುತ್ತವೆ.

ಸಂಗ್ರಹಿಸಿದ ಮೌಲ್ಯಗಳು ಕರೆಯ ವಿಷಯವಾಗಿವೆ. ಅವು ಲಿಪ್ಯಂತರದ ಪಕ್ಕದಲ್ಲಿ ಕರೆಯಲ್ಲಿ ಕಾಣಿಸುತ್ತವೆ ಮತ್ತು ಅದೇ ಉಳಿಸಿಕೊಳ್ಳುವಿಕೆ, ಅಳಿಸುವಿಕೆ ಮತ್ತು ಮರೆಮಾಚುವಿಕೆ ನಿಯಮಗಳನ್ನು ಅನುಸರಿಸುತ್ತವೆ. ಏಜೆಂಟ್‌ನ ಕರೆ ರೆಕಾರ್ಡಿಂಗ್ ಅನ್ನು ಆಫ್ ಮಾಡಿದಾಗ, ಸಂಗ್ರಹಿಸಿದ ಮೌಲ್ಯಗಳನ್ನು ಸಂಗ್ರಹಿಸಲಾಗುವುದಿಲ್ಲ ಅಥವಾ ವೆಬ್‌ಹುಕ್‌ಗಳಲ್ಲಿ ಕಳುಹಿಸಲಾಗುವುದಿಲ್ಲ; ಹಂತದ ಕಾಲರೇಖೆಯು ಮಾತ್ರ ಉಳಿಯುತ್ತದೆ. ನೋಡಿ ಕರೆಯಲ್ಲಿ ಇದನ್ನು ಎಲ್ಲಿ ನೋಡಬೇಕು.

ಹೇಳುವ ಸಾಲುಗಳು#

ಏಜೆಂಟ್ ಹಂತವನ್ನು ಪ್ರವೇಶಿಸಿದಾಗ say ಅನ್ನು ಬರೆದಿರುವಂತೆಯೇ ನಿಖರವಾಗಿ ಮಾತನಾಡಲಾಗುತ್ತದೆ. ನಂತರ ಆ ಸಾಲನ್ನು ಈಗಷ್ಟೇ ಹೇಳಲಾಗಿದೆ ಎಂದು ತಿಳಿದುಕೊಂಡು, ಮಾಡೆಲ್ ಅದೇ ಪ್ರತಿಕ್ರಿಯೆಯಲ್ಲೇ ಹೊಸ ಹಂತವನ್ನು ಮುಂದುವರಿಸುತ್ತದೆ, ಆದ್ದರಿಂದ ಅದನ್ನು ಪುನರಾವರ್ತಿಸುವುದಿಲ್ಲ. ಶುಭಾಶಯಗಳು, ಅಗತ್ಯ ಬಹಿರಂಗಪಡಿಕೆಗಳು ಮತ್ತು ನಿಗದಿತ ಪದಗಳಿಗಾಗಿ say ಬಳಸಿ, ಉಳಿದ ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ಮಾಡೆಲ್‌ಗೆ ಬಿಡಿ.

ಪ್ರಾರಂಭ ಹಂತದ say, ಯಾವುದೇ ಸಮ್ಮತಿ ಘೋಷಣೆಯ ನಂತರ, ಏಜೆಂಟ್ ಮೊದಲು ಮಾತನಾಡುವಾಗ ಅದರ ಆರಂಭಿಕ ಸಾಲಾಗಿರುತ್ತದೆ. ಕರೆ ಮಾಡುವವರು ಮೊದಲು ಮಾತನಾಡಿದಾಗ, ಅದು ವ್ಯಕ್ತಿಗೆ ನೀಡುವ ಏಜೆಂಟ್‌ನ ಮೊದಲ ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ತೆರೆಯುತ್ತದೆ; IVR ಅಥವಾ ಧ್ವನಿಮೇಲ್ ಶುಭಾಶಯಕ್ಕೆ ಎಂದಿಗೂ ಅಲ್ಲ.

ಕರೆ __previous__ ಅಥವಾ ಹಿಂದಿರುಗಿಸುವಿಕೆಯ ಮೂಲಕ ಹಂತಕ್ಕೆ ಮರಳಿದಾಗ, ಆ ಹಂತದ say ಅನ್ನು ಮತ್ತೆ ಮಾತನಾಡಲಾಗುವುದಿಲ್ಲ. ಅದು ಹೇಗೆ ಕೇಳಿಸಬೇಕು ಎಂಬಂತೆ ಬರೆಯಿರಿ: ಧ್ವನಿಯು ತಪ್ಪಾಗಿ ಓದಬಹುದಾದ ಯಾವುದನ್ನಾದರೂ ಅಕ್ಷರಶಃ ಬರೆಯಿರಿ. ಹೇಳುವ ಸಾಲುಗಳು {{var}} ಕರೆ ಚರಗಳನ್ನು ಬೆಂಬಲಿಸುತ್ತವೆ, ಆದರೆ ಸಂಗ್ರಹಿಸಿದ ಮೌಲ್ಯಗಳನ್ನು ಬೆಂಬಲಿಸುವುದಿಲ್ಲ.

Webhook ಹಂತಗಳು#

on_enter_tool ಅನ್ನು ಏಜೆಂಟ್‌ನ ಟೂಲ್‌ಗಳಲ್ಲಿ ಒಂದಕ್ಕೆ ಹೊಂದಿಸಿ; ಹಂತವನ್ನು ಪ್ರವೇಶಿಸಿದ ತಕ್ಷಣ ಮಾಡೆಲ್‌ಗಾಗಿ ಕಾಯದೆ ಅದು ಚಲಿಸುತ್ತದೆ. ಅದರ ಆರ್ಗ್ಯುಮೆಂಟ್‌ಗಳು ಟೂಲ್‌ನ ಪ್ಯಾರಾಮೀಟರ್ ಹೆಸರುಗಳಿಗೆ ಹೊಂದಿಕೆಯಾಗುವ ಹೆಸರುಗಳನ್ನು ಹೊಂದಿರುವ ಸಂಗ್ರಹಿಸಿದ ಮೌಲ್ಯಗಳಾಗಿರುತ್ತವೆ. ಫಲಿತಾಂಶವನ್ನು <tool>_result ಎಂಬ ಹೆಸರಿನ ಸಂಗ್ರಹಿಸಿದ ಮೌಲ್ಯವಾಗಿ, 4 KB ಗೆ ಮೊಟಕುಗೊಳಿಸಿ ಸಂಗ್ರಹಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಹಂತದ condition ಹಾಗೂ always ಪರಿವರ್ತನೆಗಳನ್ನು ತಕ್ಷಣವೇ ಪರಿಶೀಲಿಸಲಾಗುತ್ತದೆ, ಆದ್ದರಿಂದ ಹುಡುಕಾಟವು ತನ್ನದೇ ಫಲಿತಾಂಶದ ಆಧಾರದಲ್ಲಿ ಕರೆಯನ್ನು ಮಾರ್ಗನಿರ್ದೇಶಿಸಬಹುದು.

ಸಂಗ್ರಹಿಸಲಾದ ಮೌಲ್ಯವು ಎರಡು ಕ್ಷೇತ್ರಗಳನ್ನು ಹೊಂದಿದೆ:

lookup_account_result.response.<field> ಮೂಲಕ ಬಾಡಿ ಕ್ಷೇತ್ರದ ಆಧಾರದಲ್ಲಿ ಮತ್ತು lookup_account_result.status ಮೂಲಕ ಸ್ಥಿತಿ ಕೋಡ್‌ನ ಆಧಾರದಲ್ಲಿ ಮಾರ್ಗನಿರ್ದೇಶಿಸಿ.

ಹುಡುಕಾಟವು ಗರಿಷ್ಠ 8 ಸೆಕೆಂಡುಗಳವರೆಗೆ ಅಥವಾ ಟೂಲ್‌ನ ಸ್ವಂತ ಕಾಲಮಿತಿಯು ಕಡಿಮೆಯಿದ್ದರೆ ಅಷ್ಟು ಸಮಯದವರೆಗೆ ಚಲಿಸುತ್ತದೆ. 3 ಸೆಕೆಂಡುಗಳಿಗಿಂತ ಹೆಚ್ಚು ಸಮಯ ತೆಗೆದುಕೊಂಡರೆ, ಕರೆ ಮಾಡುವವರು ಮೌನದಲ್ಲಿ ಉಳಿಯದಂತೆ ಏಜೆಂಟ್ ಚಿಕ್ಕ ಸಾಲನ್ನು ಹೇಳುತ್ತದೆ. ನಿಮ್ಮ ಎಂಡ್‌ಪಾಯಿಂಟ್ 400 ಅಥವಾ ಅದಕ್ಕಿಂತ ಹೆಚ್ಚಿನ ಸ್ಥಿತಿಯನ್ನು ಹಿಂತಿರುಗಿಸಿದರೆ, ಅಥವಾ ಸಮಯಕ್ಕೆ ಉತ್ತರಿಸದಿದ್ದರೆ, ಏಜೆಂಟ್‌ಗೆ ಈಗ ಅದನ್ನು ಪರಿಶೀಲಿಸಲು ಸಾಧ್ಯವಾಗಲಿಲ್ಲ ಎಂದು ಕರೆ ಮಾಡುವವರಿಗೆ ತಿಳಿಸಿ, ತಾನು ಮಾಡಬಹುದಾದುದನ್ನು ಮುಂದುವರಿಸುತ್ತದೆ.

ಜಾಗತಿಕ ಹಂತಗಳು#

global_when ಹೊಂದಿರುವ ಹಂತವನ್ನು, ಆ ವಿವರಣೆ ಅನ್ವಯಿಸುವಾಗ, ಯಾವುದೇ ಹಂತದಿಂದ ತಲುಪಬಹುದು. when ನಂತೆಯೇ ಮಾಡೆಲ್ ನಿರ್ಧರಿಸುತ್ತದೆ. ಕರೆ ಮಾಡುವವರು ಯಾವುದೇ ಸಮಯದಲ್ಲಿ ಪ್ರಸ್ತಾಪಿಸಬಹುದಾದ ವಿಷಯಗಳಿಗಾಗಿ ಇದನ್ನು ಬಳಸಿ: ಬಿಲ್ಲಿಂಗ್ ಪ್ರಶ್ನೆಗಳು, ವ್ಯಕ್ತಿಯ ಸಹಾಯಕ್ಕಾಗಿ ವಿನಂತಿ, ದೂರು.

ಜಾಗತಿಕ ಹಂತದಲ್ಲಿ "to": "__previous__" ಹೊಂದಿರುವ ಪರಿವರ್ತನೆಯು ಕರೆಯನ್ನು ಅದಕ್ಕೂ ಮೊದಲು ಸಕ್ರಿಯವಾಗಿದ್ದ ಹಂತಕ್ಕೆ ಹಿಂತಿರುಗಿಸುತ್ತದೆ, ಆದ್ದರಿಂದ ಕರೆ ಮಾಡುವವರು ಬಿಟ್ಟ ಸ್ಥಳದಿಂದ ಮುಂದುವರಿಸಬಹುದು. ಹಂತವು ಪುನರಾರಂಭವಾಗುತ್ತದೆ: ಅದರ on_enter_tool ಮತ್ತೆ ಚಲಿಸುವುದಿಲ್ಲ, ಅದರ say ಪುನರಾವರ್ತನೆಯಾಗುವುದಿಲ್ಲ, ಮತ್ತು ಏಜೆಂಟ್ ಅದನ್ನು ಮತ್ತೆ ಆರಂಭಿಸದೆ ಮುಂದುವರಿಸುತ್ತದೆ.

ಹ್ಯಾಂಡ್ಆಫ್‌ಗಳು#

handoffs ನಿಮ್ಮ ಸಂಸ್ಥೆಯಲ್ಲಿರುವ, ಕರೆಯನ್ನು ವಹಿಸಿಕೊಳ್ಳಬಹುದಾದ ಇತರ ಏಜೆಂಟ್‌ಗಳನ್ನು ಪಟ್ಟಿ ಮಾಡುತ್ತದೆ:

[{"agent_id": 413, "when": "The caller asks about billing or a refund"}]

ಏಜೆಂಟ್‌ಗೆ ಆ ಏಜೆಂಟ್‌ಗಳು ಮತ್ತು ಕಾರಣಗಳೊಂದಿಗೆ ಅಂತರ್ನಿರ್ಮಿತ hand_off ಸಾಧನ ಸಿಗುತ್ತದೆ. ಪರಿವರ್ತನೆಗಳಂತೆಯೇ, ಪ್ರತಿ when ಆಂತರಿಕ ರೂಟಿಂಗ್ ಟಿಪ್ಪಣಿಯಾಗಿದ್ದು, ಅದನ್ನು ಎಂದಿಗೂ ಓದಿ ಹೇಳಲಾಗುವುದಿಲ್ಲ.

ಹ್ಯಾಂಡ್ಆಫ್ ಮಾಡುವಾಗ, ಏಜೆಂಟ್ ತನ್ನದೇ ಧ್ವನಿಯಲ್ಲಿ, ಕರೆಯುವವರು ಎಲ್ಲಿಗೆ ಹೋಗುತ್ತಿದ್ದಾರೆ ಎಂಬುದನ್ನು ತಿಳಿಸುವ ಒಂದು ಚಿಕ್ಕ ವಾಕ್ಯವನ್ನು ಹೇಳುತ್ತದೆ, ಉದಾಹರಣೆಗೆ "Sure, I'll send you over to our billing team". ನಂತರ ಗುರಿ ಏಜೆಂಟ್‌ನ prompt, ಹಂತಗಳು, ಸಾಧನಗಳು ಮತ್ತು ಧ್ವನಿ ವಹಿಸಿಕೊಳ್ಳುತ್ತವೆ ಹಾಗೂ ಅದೇ ಪ್ರತಿಲಿಪಿಯೊಂದಿಗೆ ಕರೆ ಮುಂದುವರಿಯುತ್ತದೆ. ಹೊಸ ಏಜೆಂಟ್ ಸಂಕ್ಷಿಪ್ತವಾಗಿ ತನ್ನನ್ನು ಪರಿಚಯಿಸಿಕೊಂಡು ಕರೆಯುವವರ ಕೊನೆಯ ವಿನಂತಿಗೆ ಉತ್ತರಿಸುತ್ತದೆ; ಅದು ವರ್ಗಾವಣೆಯನ್ನು ಘೋಷಿಸುವುದಿಲ್ಲ. ಆ ಕ್ಷಣದಿಂದ ಗುರಿಯ ಜ್ಞಾನ ಭಂಡಾರ ಲಭ್ಯವಾಗುತ್ತದೆ.

ಒಂದು ಕರೆ ಮೊದಲ ಬಾರಿಗೆ ಏಜೆಂಟ್‌ಗೆ ತಲುಪಿದಾಗ, ಅದು ಆ ಏಜೆಂಟ್‌ನ start_step ನಲ್ಲಿ ಆರಂಭವಾಗುತ್ತದೆ: ಹಂತದ on_enter_tool ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಮತ್ತು ಅದರ say ಅನ್ನು ಹೇಳಲಾಗುತ್ತದೆ. ಕರೆ ಈಗಾಗಲೇ ಭೇಟಿ ನೀಡಿದ ಏಜೆಂಟ್‌ಗೆ ಮರಳಿ ಹ್ಯಾಂಡ್ಆಫ್ ಆದಾಗ, ಆ ಏಜೆಂಟ್ on_enter_tool ಅನ್ನು ಚಲಾಯಿಸದೆ, ತನ್ನ say ಅನ್ನು ಪುನರಾವರ್ತಿಸದೆ ಅಥವಾ ಮತ್ತೆ ತನ್ನನ್ನು ಪರಿಚಯಿಸಿಕೊಳ್ಳದೆ, ಅದು ಇದ್ದ ಹಂತದಿಂದಲೇ ಮುಂದುವರಿಯುತ್ತದೆ. ಸಂಗ್ರಹಿಸಿದ ಮೌಲ್ಯಗಳನ್ನು ಕರೆಯಲ್ಲಿರುವ ಪ್ರತಿಯೊಂದು ಏಜೆಂಟ್ ಹಂಚಿಕೊಳ್ಳುತ್ತದೆ.

• ಗುರಿಯು ಅದೇ ಸಂಸ್ಥೆಯಲ್ಲಿರುವ ಏಜೆಂಟ್ ಆಗಿರಬೇಕು ಮತ್ತು ಏಜೆಂಟ್ ತನ್ನನ್ನೇ ಹ್ಯಾಂಡ್ಆಫ್ ಮಾಡಲಾಗುವುದಿಲ್ಲ.
• ಕರೆ-ಮಟ್ಟದ ಎಲ್ಲವೂ ಉತ್ತರಿಸಿದ ಏಜೆಂಟ್‌ನಲ್ಲೇ ಇರುತ್ತದೆ: ಉತ್ಪನ್ನ, ಭಾಷೆಗಳು, ಮೊದಲು ಯಾರು ಮಾತನಾಡುತ್ತಾರೆ, ಧ್ವನಿಮೇಲ್, ಸಮ್ಮತಿ ಘೋಷಣೆ ಮತ್ತು ಪ್ರತಿಯೊಂದು ಇತರ ಕರೆ ಸೆಟ್ಟಿಂಗ್.
• ಗುರಿಗಳು ಮುಂದೆಯೂ ಮತ್ತು ಹಿಂದಕ್ಕೂ ಹ್ಯಾಂಡ್ಆಫ್ ಮಾಡಬಹುದು. ಒಂದು ಕರೆ ಗರಿಷ್ಠ 8 ಏಜೆಂಟ್‌ಗಳನ್ನು ತಲುಪಬಹುದು.
• ಪರೀಕ್ಷಾ ಕರೆ ನೀವು ಪರೀಕ್ಷಿಸುವ ಏಜೆಂಟ್‌ನ ಕರಡನ್ನು ಚಲಾಯಿಸುತ್ತದೆ. ಅದು ಹ್ಯಾಂಡ್ಆಫ್ ಮಾಡುವ ಏಜೆಂಟ್‌ಗಳು ತಮ್ಮ ನಿಯೋಜಿತ ಆವೃತ್ತಿಗಳನ್ನು ಚಲಾಯಿಸುತ್ತವೆ.
• ಎರಡು ಏಜೆಂಟ್‌ಗಳು ಒಂದೇ ಹೆಸರಿನ ಆದರೆ ವಿಭಿನ್ನ ವ್ಯಾಖ್ಯಾನಗಳ ಸಾಧನವನ್ನು ಹೊಂದಿದ್ದರೆ, ಕರೆಗೆ ಒಂದನ್ನು ಮಾತ್ರ ಉಳಿಸಿಕೊಳ್ಳಲಾಗುತ್ತದೆ ಮತ್ತು ಉತ್ತರಿಸಿದ ಏಜೆಂಟ್‌ನದ್ದೇ ಯಾವಾಗಲೂ ಗೆಲ್ಲುತ್ತದೆ. ನೀವು ಉಳಿಸುವಾಗ ಬಿಲ್ಡರ್ ನಿಮಗೆ ಎಚ್ಚರಿಕೆ ನೀಡುತ್ತದೆ.
• ಏಜೆಂಟ್ ಹಂತಗಳಿಲ್ಲದೆ ಹ್ಯಾಂಡ್ಆಫ್‌ಗಳನ್ನು ಹೊಂದಿರಬಹುದು. ಅದರ ಸಂಪೂರ್ಣ prompt ಅನ್ನು ಇದ್ದಂತೆಯೇ ಬಳಸಲಾಗುತ್ತದೆ.

go_to_step ಮತ್ತು hand_off ಹಂತಗಳು ಅಥವಾ ಹ್ಯಾಂಡ್ಆಫ್‌ಗಳನ್ನು ಹೊಂದಿರುವ ಏಜೆಂಟ್‌ಗಳಲ್ಲಿ ಮೀಸಲಾಗಿವೆ, ಆದ್ದರಿಂದ ನಿಮ್ಮ ಸ್ವಂತ ಸಾಧನಗಳು ಆ ಹೆಸರುಗಳನ್ನು ಬಳಸಲಾಗುವುದಿಲ್ಲ.

ಕರೆಯಲ್ಲಿ ಇದನ್ನು ಎಲ್ಲಿ ನೋಡಬೇಕು#

ಕರೆಯನ್ನು ಕರೆ ಇತಿಹಾಸ ನಲ್ಲಿ ತೆರೆಯಿರಿ. ಪ್ರತಿಲಿಪಿಯ ಪಕ್ಕದಲ್ಲಿರುವ ಹಂತದ ಕಾಲರೇಖೆಯು ಕರೆ ಪ್ರವೇಶಿಸಿದ ಪ್ರತಿಯೊಂದು ಹಂತ ಮತ್ತು ಅದರ ಕಾರಣವನ್ನು ತೋರಿಸುತ್ತದೆ, ಹಾಗೂ ಸಂಗ್ರಹಿಸಿದ ಮೌಲ್ಯಗಳನ್ನು ಅದರೊಂದಿಗೆ ಪಟ್ಟಿ ಮಾಡಲಾಗುತ್ತದೆ.

ಕರೆ ಆಬ್ಜೆಕ್ಟ್ ಮತ್ತು ಕರೆ-ಪೂರ್ಣ ವೆಬ್‌ಹುಕ್ (telephony.complete / web.complete) ಒಂದೇ ಡೇಟಾವನ್ನು steps_trace ಮತ್ತು collected_values ರೂಪದಲ್ಲಿ ಹೊಂದಿರುತ್ತವೆ. ಹಂತಗಳಿಲ್ಲದ ಕರೆಗಳಲ್ಲಿ ಎರಡೂ ಇರುವುದಿಲ್ಲ.

"steps_trace": [
  {"t_ms": 0, "agent": "a412", "step": "greet", "via": "start"},
  {"t_ms": 51230, "agent": "a412", "step": "verify", "via": "model"},
  {"t_ms": 98410, "agent": "a412", "step": "minor", "via": "condition"}
],
"collected_values": {"full_name": "Dana Reyes", "dob": "2010-04-02", "age": 15}

agent ಎಂದರೆ ಏಜೆಂಟ್ ಐಡಿ ನಂತರದ a. via ಕರೆಯನ್ನು ಯಾವುದು ಮುಂದಕ್ಕೆ ಸರಿಸಿತು ಎಂಬುದನ್ನು ಹೇಳುತ್ತದೆ:

ಹಂತಗಳು ಎಲ್ಲಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ#

ಹಂತಗಳು Spark, Bolt ಮತ್ತು ಪ್ರತಿಯೊಂದು Storm ಉತ್ಪನ್ನದಲ್ಲಿ, ಒಳಬರುವ, ಹೊರಹೋಗುವ ಮತ್ತು ಕ್ಯಾಂಪೇನ್ ಕರೆಗಳಲ್ಲಿ, ಪರೀಕ್ಷಾ ಕರೆಗಳಲ್ಲಿ ಹಾಗೂ ವೆಬ್ ಮತ್ತು ವಿಜೆಟ್ ಕರೆಗಳಲ್ಲಿ ಸ್ಥಳೀಯವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ.

ಬೇರೆ ಎಲ್ಲೆಡೆ ಏಜೆಂಟ್ ಇನ್ನೂ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ, ಆದರೆ ರಚನೆಯಿಲ್ಲದೆ: ಹಂಚಿಕೊಂಡ ಸೂಚನೆಗಳು ಮತ್ತು ಪ್ರತಿಯೊಂದು ಹಂತವನ್ನು ಕ್ರಮವಾಗಿ ವಿಲೀನಗೊಳಿಸುವ ಸಮತಟ್ಟಾದ prompt ಅನ್ನು ಅದು ಚಲಾಯಿಸುತ್ತದೆ. ಇದು ಇವುಗಳನ್ನು ಒಳಗೊಂಡಿದೆ:

• ಪ್ರಾಯೋಗಿಕ Bolt ಉತ್ಪನ್ನಗಳು;
• ಉಳಿಸಿದ ಏಜೆಂಟ್‌ನ ಸೆಷನ್‌ಗಳನ್ನು ಒಳಗೊಂಡಂತೆ, Realtime ಸೆಷನ್‌ಗಳು;
• ಡೈನಾಮಿಕ್ ಕರೆ ಕಾನ್ಫಿಗ್ ವೆಬ್‌ಹುಕ್ ಹಿಂತಿರುಗಿಸುವ ಇನ್‌ಲೈನ್ ಕಾನ್ಫಿಗರೇಶನ್‌ಗಳು. agent_id ಹಿಂತಿರುಗಿಸುವ ವೆಬ್‌ಹುಕ್ ಆ ಏಜೆಂಟ್‌ನ ಹಂತಗಳನ್ನು ಬಳಸುತ್ತದೆ.

ಮಿತಿಗಳು#

ನಿಯಮವನ್ನು ಉಲ್ಲಂಘಿಸುವ ಉಳಿಸುವಿಕೆಯು ತಪ್ಪಾದ ಫೀಲ್ಡ್‌ನ ಪಥದೊಂದಿಗೆ 400 ಅನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ, ಉದಾಹರಣೆಗೆ steps.steps[2].transitions[0].to. tools ಮತ್ತು on_enter_tool ನಲ್ಲಿನ ಟೂಲ್ ಹೆಸರುಗಳು ಏಜೆಂಟ್‌ಗೆ ಲಗತ್ತಿಸಲಾದ ಟೂಲ್‌ಗಳಾಗಿರಬೇಕು.

ಪ್ರತಿ ಹಂತದ ಭಾಷೆಗಳು, ಮಾಡೆಲ್ ಅನ್ನು ಬಿಟ್ಟುಹೋಗುವ ಸ್ಕ್ರಿಪ್ಟೆಡ್ ಹಂತಗಳು ಮತ್ತು say ಸಾಲುಗಳೊಳಗಿನ ಸಂಗ್ರಹಿಸಿದ ಮೌಲ್ಯಗಳಿಗೆ ಬೆಂಬಲವಿಲ್ಲ.

ಆಮದು ಮಾಡಿದ ಏಜೆಂಟ್‌ಗಳು#

Retell, Bland, Vapi ಅಥವಾ ElevenLabs ನಿಂದ ಆಮದು ಮಾಡುವುದು ಬಹು-prompt ಏಜೆಂಟ್‌ಗಳು, ಫ್ಲೋಗಳು, ಪಾಥ್‌ವೇಗಳು ಮತ್ತು ವರ್ಕ್‌ಫ್ಲೋಗಳನ್ನು ಹಂತಗಳಾಗಿ, ಹಾಗೂ ಸ್ಕ್ವಾಡ್‌ಗಳು ಮತ್ತು ಏಜೆಂಟ್ ವರ್ಗಾವಣೆಗಳನ್ನು ಆಮದು ಮಾಡಿದ ಏಜೆಂಟ್‌ಗಳ ನಡುವಿನ ಹ್ಯಾಂಡ್ಆಫ್‌ಗಳಾಗಿ ತರುತ್ತದೆ. ನೀವು ಆಮದು ಮಾಡುವ ಮೊದಲು ವಿಮರ್ಶೆ ಪುಟವು ಎರಡನ್ನೂ ತೋರಿಸುತ್ತದೆ.

ಉದಾಹರಣೆ: ದಂತ ಚಿಕಿತ್ಸಾ ನೋಂದಣಿ#

ಕ್ರಮವಾಗಿ ಮೂರು ಹಂತಗಳು: ಸ್ವಾಗತಿಸಿ, ರೋಗಿಯ ವಿವರಗಳನ್ನು ಸಂಗ್ರಹಿಸಿ, ಬುಕಿಂಗ್ ಮಾಡಿ.

{
  "prompt": "You are Ava, the front desk assistant at Acme Dental. Be warm and brief. Ask one question at a time.",
  "steps": {
    "start_step": "greet",
    "steps": [
      {
        "id": "greet",
        "name": "Greeting",
        "instructions": "Greet the caller and ask how you can help.",
        "say": "Thanks for calling Acme Dental, this is Ava. How can I help you today?",
        "tools": null,
        "collect": [],
        "transitions": [
          {"to": "details", "when": "The caller wants to book an appointment"}
        ]
      },
      {
        "id": "details",
        "name": "Patient details",
        "instructions": "Ask for the caller's full name, date of birth and the reason for the visit. Read the date of birth back and ask the caller to confirm it.",
        "tools": null,
        "collect": [
          {"name": "full_name", "type": "string", "description": "Caller's full name", "required": true},
          {"name": "dob", "type": "date", "description": "Date of birth", "required": true},
          {"name": "reason", "type": "string", "description": "Reason for the visit", "required": true},
          {"name": "new_patient", "type": "boolean", "description": "First visit to the practice", "required": false}
        ],
        "transitions": [
          {"to": "book", "when": "The caller has confirmed their details"}
        ]
      },
      {
        "id": "book",
        "name": "Book",
        "instructions": "Offer the two earliest open slots from book_slot and book the one the caller picks. Confirm the date and time, then say goodbye and end the call.",
        "tools": ["book_slot"],
        "collect": [],
        "transitions": []
      }
    ]
  }
}

ಇದನ್ನು PATCH /v1/agents/{agent_id} ಮೂಲಕ ಹಂತಗೊಳಿಸಿ, ಮಾತನಾಡಿ ಮೂಲಕ ಪ್ರಯತ್ನಿಸಿ, ನಂತರ ನಿಯೋಜಿಸಿ. ಹೆಸರು, ಜನ್ಮದಿನಾಂಕ ಮತ್ತು ಕಾರಣವನ್ನು ಸಂಗ್ರಹಿಸುವವರೆಗೆ details ಹಂತವು ಬುಕಿಂಗ್‌ಗೆ ಹ್ಯಾಂಡ್ಆಫ್ ಮಾಡಲು ಸಾಧ್ಯವಿಲ್ಲ; new_patient ಐಚ್ಛಿಕವಾಗಿದೆ.

ಉದಾಹರಣೆ: ವಯಸ್ಸು-ನಿಯಂತ್ರಿತ ಶಾಖೆ#

ಮಾಡೆಲ್ ಯಾರೊಂದಿಗಾದರೂ ಮಾತನಾಡಬಹುದು, ಆದರೆ ಯಾರ ಬುಕಿಂಗ್ ಆಗಬೇಕು ಎಂಬುದನ್ನು ಕೋಡ್ ನಿರ್ಧರಿಸುತ್ತದೆ. ವಯಸ್ಸನ್ನು ಸಂಗ್ರಹಿಸಿ, ನಂತರ ಮಾಡೆಲ್‌ನ ಸ್ವಂತ ಆಯ್ಕೆಯನ್ನು ಪರಿಗಣಿಸುವ ಮೊದಲು ಅದರ ಆಧಾರದ ಮೇಲೆ ಮಾರ್ಗನಿರ್ದೇಶಿಸಿ.

{
  "id": "verify",
  "name": "Verify age",
  "instructions": "Ask for the caller's age.",
  "tools": null,
  "collect": [
    {"name": "age", "type": "number", "description": "Caller's age in years", "required": true}
  ],
  "transitions": [
    {"to": "guardian", "condition": {"value": "age", "op": "lt", "target": 18}},
    {"to": "book", "when": "The caller has given their age"}
  ]
}

ಹದಿನೈದು ಎಂದು ಹೇಳುವ ಕರೆಗಾರರು, ಮಾಡೆಲ್ ಏನು ನಿರ್ಧರಿಸಿದರೂ, guardian ಗೆ ಹೋಗುತ್ತಾರೆ. ಉಳಿದವರೆಲ್ಲರೂ book ಗೆ ಹೋಗುತ್ತಾರೆ. ಗ್ರಾಫ್‌ನಲ್ಲಿ ಎರಡೂ ಬೇರೆಡೆ ಸಾಮಾನ್ಯ ಹಂತಗಳಾಗಿವೆ.

ಉದಾಹರಣೆ: ಖಾತೆ ಹುಡುಕಾಟ ವೆಬ್‌ಹುಕ್ ಹಂತ#

ಕರೆ ಮಾಡಿದವರು ಖಾತೆ ಸಂಖ್ಯೆಯನ್ನು ನೀಡುತ್ತಾರೆ, ಮುಂದಿನ ಹಂತವನ್ನು ಪ್ರವೇಶಿಸಿದಾಗ ಹುಡುಕಾಟವು ನಡೆಯುತ್ತದೆ, ಮತ್ತು ಅದರ ಫಲಿತಾಂಶವು ಮಾರ್ಗವನ್ನು ಆಯ್ಕೆ ಮಾಡುತ್ತದೆ. ಸಂಕ್ಷಿಪ್ತತೆಗಾಗಿ not_found, collections ಮತ್ತು support ಹಂತಗಳನ್ನು ಬಿಟ್ಟುಬಿಡಲಾಗಿದೆ.

[
  {
    "id": "identify",
    "name": "Identify",
    "instructions": "Ask for the caller's account number and read it back digit by digit.",
    "tools": null,
    "collect": [
      {"name": "account_number", "type": "string", "description": "Account number", "required": true}
    ],
    "transitions": [
      {"to": "lookup", "when": "The caller has confirmed their account number"}
    ]
  },
  {
    "id": "lookup",
    "name": "Look up account",
    "instructions": "Tell the caller what you found on their account and ask how you can help.",
    "tools": ["lookup_account"],
    "collect": [],
    "on_enter_tool": "lookup_account",
    "transitions": [
      {"to": "not_found", "condition": {"value": "lookup_account_result.response.found", "op": "eq", "target": false}},
      {"to": "collections", "condition": {"value": "lookup_account_result.response.account_status", "op": "in", "target": ["past_due", "suspended"]}},
      {"to": "support", "when": "The caller needs help with an active account"}
    ]
  }
]

lookup_account ತನ್ನ ಪ್ಯಾರಾಮೀಟರ್‌ಗೆ ಅದೇ ಹೆಸರು ಇರುವುದರಿಂದ account_number ಅನ್ನು ಸ್ವೀಕರಿಸುತ್ತದೆ. ಪ್ರತಿಕ್ರಿಯೆ ಬಾಡಿಯಲ್ಲಿ "found": false ಇದ್ದರೆ, ಕರೆ not_found ಗೆ ಹೋಗುತ್ತದೆ. ಅದರ account_status past_due ಅಥವಾ suspended ಆಗಿದ್ದರೆ, ಅದು collections ಗೆ ಹೋಗುತ್ತದೆ. ಸಕ್ರಿಯ ಖಾತೆಯು lookup ನಲ್ಲಿಯೇ ಉಳಿಯುತ್ತದೆ, ಅಲ್ಲಿ ಮಾದರಿಯು ಸಹಾಯ ಮಾಡಿ support ಗೆ ಮುಂದುವರಿಯುತ್ತದೆ. ವಿಫಲ ಹುಡುಕಾಟವನ್ನು ಅದರದೇ ಹಂತಕ್ಕೆ ಕಳುಹಿಸಲು, ಮೊದಲು ಸ್ಥಿತಿಯ ಮೇಲೆ ಷರತ್ತುಗಳನ್ನು ಸೇರಿಸಿ: ದೋಷ ಪ್ರತಿಕ್ರಿಯೆಯು ತನ್ನ ಸ್ಥಿತಿ ಕೋಡ್ ಅನ್ನು ಸಂಗ್ರಹಿಸುತ್ತದೆ, ಆದ್ದರಿಂದ {"value": "lookup_account_result.status", "op": "gte", "target": 400} ಅದನ್ನು ಹಿಡಿಯುತ್ತದೆ, ಮತ್ತು ಕಾಲಾವಧಿ ಮೀರುವುದು ಅಥವಾ ಉತ್ತರ ಇಲ್ಲದಿರುವುದು "error" ಅನ್ನು ಸಂಗ್ರಹಿಸುತ್ತದೆ, ಆದ್ದರಿಂದ {"value": "lookup_account_result.status", "op": "eq", "target": "error"} ಅದನ್ನು ಹಿಡಿಯುತ್ತದೆ.

ಉದಾಹರಣೆ: ಸ್ವಾಗತ ಡೆಸ್ಕ್‌ನಿಂದ ಬಿಲ್ಲಿಂಗ್‌ಗೆ#

ಎರಡು ಏಜೆಂಟ್‌ಗಳು. ಸ್ವಾಗತ ಡೆಸ್ಕ್ (ಏಜೆಂಟ್ 412) ಪ್ರತಿ ಕರೆಗೆ ಉತ್ತರಿಸುತ್ತದೆ ಮತ್ತು ಬಿಲ್ಲಿಂಗ್ ಪ್ರಶ್ನೆಗಳನ್ನು ತನ್ನದೇ prompt, ಪರಿಕರಗಳು ಮತ್ತು ಧ್ವನಿಯನ್ನು ಹೊಂದಿರುವ ಬಿಲ್ಲಿಂಗ್ ಏಜೆಂಟ್‌ಗೆ (ಏಜೆಂಟ್ 413) ಹಸ್ತಾಂತರಿಸುತ್ತದೆ.

ಸ್ವಾಗತ ಡೆಸ್ಕ್‌ನಲ್ಲಿ:

{
  "handoffs": [
    {"agent_id": 413, "when": "The caller asks about a bill, a payment or a refund"}
  ]
}

ಬಿಲ್ಲಿಂಗ್ ಏಜೆಂಟ್‌ನಲ್ಲಿ, ಇದರಿಂದ ಅದು ಕರೆಯನ್ನು ಮತ್ತೆ ಹಸ್ತಾಂತರಿಸಬಹುದು:

{
  "handoffs": [
    {"agent_id": 412, "when": "The billing question is resolved and the caller needs something else"}
  ]
}

ಸ್ವಾಗತ ಡೆಸ್ಕ್ "Let me get you to our billing team" ಎಂಬಂತಹ ಚಿಕ್ಕ ವಾಕ್ಯವನ್ನು ಹೇಳುತ್ತದೆ, ಮತ್ತು ಬಿಲ್ಲಿಂಗ್ ಏಜೆಂಟ್ ತನ್ನನ್ನು ಪರಿಚಯಿಸಿಕೊಂಡು ಸ್ವಾಗತ ಡೆಸ್ಕ್ ನಿಲ್ಲಿಸಿದ ಸ್ಥಳದಿಂದ ಸಂಭಾಷಣೆಯನ್ನು ಮುಂದುವರಿಸುತ್ತದೆ. ಬಿಲ್ಲಿಂಗ್ ಮತ್ತೆ ಹಸ್ತಾಂತರಿಸಿದಾಗ, ಸ್ವಾಗತ ಡೆಸ್ಕ್ ಕರೆ ಮಾಡಿದವರಿಗೆ ಪುನಃ ವಂದಿಸದೆ, ತಾನು ಇದ್ದ ಸ್ಥಳದಿಂದ ಮುಂದುವರಿಯುತ್ತದೆ. ಕರೆಯ ಉತ್ಪನ್ನ, ಭಾಷೆಗಳು, ಸಮ್ಮತಿ ಪ್ರಕಟಣೆ ಮತ್ತು ಇತರ ಕರೆ ಸೆಟ್ಟಿಂಗ್‌ಗಳು ಸ್ವಾಗತ ಡೆಸ್ಕ್‌ನಲ್ಲಿಯೇ ಉಳಿಯುತ್ತವೆ, ಏಕೆಂದರೆ ಅದೇ ಉತ್ತರಿಸಿತು.

ಬಿಲ್ಲಿಂಗ್‌ಗೆ ತನ್ನದೇ ಸೂಚನೆಗಳು ಮಾತ್ರ ಬೇಕಾಗಿದ್ದು ತನ್ನದೇ ಏಜೆಂಟ್ ಅಗತ್ಯವಿಲ್ಲದಿದ್ದರೆ, ಬದಲಿಗೆ ಸ್ವಾಗತ ಡೆಸ್ಕ್‌ನಲ್ಲಿ ಜಾಗತಿಕ ಹಂತವನ್ನು ಬಳಸಿ. ಪ್ರಶ್ನೆಗೆ ಉತ್ತರಿಸಿದಾಗ, ಕರೆ ಮಾಡಿದವರು ಇದ್ದ ಯಾವುದೇ ಹಂತಕ್ಕೆ ಕರೆ ಮರಳುತ್ತದೆ:

{
  "id": "billing",
  "name": "Billing questions",
  "instructions": "Answer questions about bills and payments. Offer to send a payment link by email.",
  "tools": null,
  "collect": [],
  "transitions": [
    {"to": "__previous__", "when": "The billing question is answered"}
  ],
  "global_when": "The caller asks about a bill or payment at any point"
}

ಮುಂದಿನ ಹಂತಗಳು#