ਏਜੰਟ ਦੇ ਕਦਮ ਅਤੇ ਹੈਂਡਆਫ਼

ਏਜੰਟ ਨੂੰ ਆਪਣੀਆਂ ਹਦਾਇਤਾਂ, ਟੂਲਾਂ ਅਤੇ ਇਕੱਠੀਆਂ ਕੀਤੀਆਂ ਵੈਲਿਊਜ਼ ਵਾਲੇ ਕਦਮਾਂ ਵਿੱਚ ਵੰਡੋ ਅਤੇ ਕਾਲ ਦੌਰਾਨ ਏਜੰਟਾਂ ਵਿਚਕਾਰ ਕਾਲਾਂ ਹੈਂਡਆਫ਼ ਕਰੋ।

ਇੱਕੋ prompt ਮਾਡਲ ਨੂੰ ਪੂਰਾ ਕੰਮ ਇੱਕੋ ਵਾਰ ਦਿੰਦਾ ਹੈ। ਸਟੈਪਾਂ ਇਸਨੂੰ ਕਾਲ ਦਾ ਇੱਕ ਪੜਾਅ ਇੱਕ ਸਮੇਂ ਵਿੱਚ ਦਿੰਦੀਆਂ ਹਨ: ਹਰ ਸਟੈਪ ਦੀਆਂ ਆਪਣੀਆਂ ਹਦਾਇਤਾਂ, ਆਪਣੇ ਟੂਲ, ਸ਼ਬਦ-ਬ-ਸ਼ਬਦ ਬੋਲੀ ਜਾਣ ਵਾਲੀ ਇੱਕ ਵਿਕਲਪਿਕ ਲਾਈਨ, ਅਤੇ ਅੱਗੇ ਵਧਣ ਤੋਂ ਪਹਿਲਾਂ ਇਕੱਠੇ ਕਰਨ ਲਈ ਮੁੱਲ ਹੁੰਦੇ ਹਨ। ਹੈਂਡਆਫ਼ ਤੁਹਾਡੀ ਸੰਸਥਾ ਦੇ ਕਿਸੇ ਹੋਰ ਏਜੰਟ ਨੂੰ ਕਾਲ ਦੇ ਵਿਚਕਾਰ ਕੰਮ ਸੰਭਾਲਣ ਦਿੰਦੇ ਹਨ, ਟ੍ਰਾਂਸਕ੍ਰਿਪਟ ਬਰਕਰਾਰ ਰਹਿੰਦੀ ਹੈ, ਇਸ ਲਈ ਕਾਲਰ ਨੂੰ ਕਦੇ ਵੀ ਆਪਣੀ ਗੱਲ ਦੁਹਰਾਉਣੀ ਨਹੀਂ ਪੈਂਦੀ।

ਹਰ ਏਜੰਟ ਇੱਕੋ prompt ਵਜੋਂ ਸ਼ੁਰੂ ਹੁੰਦਾ ਹੈ। ਜਦੋਂ ਤੱਕ ਤੁਸੀਂ ਸਟੈਪਾਂ ਜਾਂ ਹੈਂਡਆਫ਼ ਨਹੀਂ ਜੋੜਦੇ, ਇਸ ਵਿੱਚ ਕੁਝ ਨਹੀਂ ਬਦਲਦਾ।

ਸਟੈਪਾਂ ਜਾਂ ਇੱਕੋ prompt?#

ਸਟੈਪਾਂ ਸਕ੍ਰਿਪਟ ਕੀਤੀ ਹੋਈ ਫ਼ੋਨ ਟ੍ਰੀ ਨਹੀਂ ਹਨ। ਇੱਕ ਸਟੈਪ ਦੇ ਅੰਦਰ ਮਾਡਲ ਗੱਲਬਾਤ ਉਸੇ ਤਰ੍ਹਾਂ ਚਲਾਉਂਦਾ ਹੈ ਜਿਵੇਂ ਇੱਕੋ prompt ਨਾਲ ਚਲਾਉਂਦਾ ਹੈ। ਸਟੈਪ ਇਹ ਤੈਅ ਕਰਦਾ ਹੈ ਕਿ ਉਹ ਕਿਸ ਉੱਤੇ ਕੰਮ ਕਰ ਰਿਹਾ ਹੈ, ਕਿਹੜੇ ਟੂਲ ਵਰਤ ਸਕਦਾ ਹੈ ਅਤੇ ਬਾਹਰ ਜਾਣ ਤੋਂ ਪਹਿਲਾਂ ਉਸਨੂੰ ਕੀ ਚਾਹੀਦਾ ਹੈ।

ਸਟੈਪਾਂ ਵਾਲਾ ਏਜੰਟ ਕਿਵੇਂ ਬਣਦਾ ਹੈ#

ਜਦੋਂ ਕਿਸੇ ਏਜੰਟ ਵਿੱਚ ਸਟੈਪਾਂ ਹੁੰਦੀਆਂ ਹਨ, ਤਾਂ ਉਸਦਾ prompt ਸਾਂਝੀਆਂ ਹਦਾਇਤਾਂ ਰੱਖਦਾ ਹੈ: ਉਹ persona ਅਤੇ ਨਿਯਮ ਜੋ ਹਰ ਸਟੈਪ ਵਿੱਚ ਲਾਗੂ ਹੁੰਦੇ ਹਨ। ਹਰ ਸਟੈਪ ਇਸ ਦੇ ਉੱਪਰ ਆਪਣੀਆਂ ਹਦਾਇਤਾਂ ਜੋੜਦਾ ਹੈ। ਹਰ ਵਾਰੀ ਮਾਡਲ ਸਾਂਝੀਆਂ ਹਦਾਇਤਾਂ, ਮੌਜੂਦਾ ਸਟੈਪ ਦਾ ਨਾਮ ਅਤੇ ਹਦਾਇਤਾਂ, ਅਤੇ ਹੁਣ ਤੱਕ ਇਕੱਠੇ ਕੀਤੇ ਮੁੱਲ ਵੇਖਦਾ ਹੈ।

ਬਿਲਡਰ ਵਿੱਚ, ਏਜੰਟ ਨੂੰ ਇੱਕੋ prompt ਤੋਂ ਸਟੈਪਾਂ 'ਤੇ ਬਦਲੋ। ਤੁਹਾਨੂੰ ਹਰ ਸਟੈਪ ਲਈ ਉਸਦੇ ਨਾਮ, ਹਦਾਇਤਾਂ, say ਲਾਈਨ, ਟੂਲਾਂ, ਇਕੱਠੇ ਕੀਤੇ ਮੁੱਲਾਂ ਅਤੇ ਟ੍ਰਾਂਜ਼ਿਸ਼ਨਾਂ ਵਾਲਾ ਕਾਰਡ, ਇੱਕ ਹੈਂਡਆਫ਼ ਪਿਕਰ, ਅਤੇ ਸਟੈਪਾਂ ਦਾ ਸਿਰਫ਼-ਪੜ੍ਹਨ-ਲਈ ਫ਼ਲੋ ਗ੍ਰਾਫ਼ ਮਿਲਦਾ ਹੈ। ਇੱਕੋ prompt 'ਤੇ ਵਾਪਸ ਬਦਲਣ ਨਾਲ ਇੱਕ ਸਮਤਲ ਕੀਤਾ prompt ਮਿਲਦਾ ਹੈ ਜੋ ਸਾਂਝੀਆਂ ਹਦਾਇਤਾਂ ਅਤੇ ਹਰ ਸਟੈਪ ਨੂੰ ਮਿਲਾ ਦਿੰਦਾ ਹੈ।

API ਰਾਹੀਂ, steps ਅਤੇ handoffs ਏਜੰਟ ਦੇ ਫ਼ੀਲਡ ਹਨ। ਹਰ ਏਜੰਟ ਫ਼ੀਲਡ ਵਾਂਗ, ਇੱਕ PATCH ਇਹਨਾਂ ਨੂੰ ਡਰਾਫ਼ਟ ਵਿੱਚ ਸਟੇਜ ਕਰਦਾ ਹੈ; POST /v1/agents/{agent_id}/deploy ਇਹਨਾਂ ਨੂੰ ਲਾਈਵ ਕਰਦਾ ਹੈ। "steps": null ਭੇਜਣ ਨਾਲ ਏਜੰਟ ਵਾਪਸ ਇੱਕੋ prompt 'ਤੇ ਆ ਜਾਂਦਾ ਹੈ। ਟੈਸਟ ਕਾਲਾਂ ਅਤੇ ਗੱਲਬਾਤ ਡਰਾਫ਼ਟ ਚਲਾਉਂਦੇ ਹਨ।

ਸਟੈਪ ਫ਼ੀਲਡ#

ਗ੍ਰਾਫ਼ ਆਪਣੇ ਆਪ ਵਿੱਚ {"start_step": "<step id>", "steps": [...]} ਹੈ। ਕਾਲ start_step ਵਿੱਚ ਸ਼ੁਰੂ ਹੁੰਦੀ ਹੈ।

ਟ੍ਰਾਂਜ਼ਿਸ਼ਨ#

ਹਰ ਟ੍ਰਾਂਜ਼ਿਸ਼ਨ ਵਿੱਚ to, ਇੱਕ ਸਟੈਪ id, ਅਤੇ ਹੇਠਾਂ ਦਿੱਤਿਆਂ ਵਿੱਚੋਂ ਬਿਲਕੁਲ ਇੱਕ ਹੁੰਦਾ ਹੈ:

• when: ਸਾਦੀ ਭਾਸ਼ਾ, ਅਤੇ ਮਾਡਲ ਫ਼ੈਸਲਾ ਕਰਦਾ ਹੈ। ਏਜੰਟ ਨੂੰ ਇੱਕ ਬਿਲਟ-ਇਨ go_to_step ਟੂਲ ਮਿਲਦਾ ਹੈ ਜੋ ਉਹਨਾਂ ਸਟੈਪਾਂ ਦੀ ਸੂਚੀ ਦਿੰਦਾ ਹੈ ਜਿਨ੍ਹਾਂ 'ਤੇ ਇਹ ਜਾ ਸਕਦਾ ਹੈ, ਅਤੇ ਹਰ when ਉਸਨੂੰ ਚੁਣਨ ਦਾ ਕਾਰਨ ਹੁੰਦਾ ਹੈ।
• condition: ਇਕੱਠੇ ਕੀਤੇ ਮੁੱਲਾਂ ਲਈ ਇੱਕ ਨਿਯਮ, ਅਤੇ ਕੋਡ ਫ਼ੈਸਲਾ ਕਰਦਾ ਹੈ। ਮਾਡਲ ਇਸਨੂੰ ਛੱਡ ਨਹੀਂ ਸਕਦਾ ਜਾਂ ਗੱਲਾਂ ਨਾਲ ਇਸ ਤੋਂ ਬਚ ਨਹੀਂ ਸਕਦਾ।
• "always": true: ਬਿਨਾਂ ਜਾਂਚ ਦੇ ਅੱਗੇ ਵਧੋ। ਕੋਡ ਪਹਿਲਾਂ ਫ਼ੈਸਲਾ ਕਰਦਾ ਹੈ: ਜਿਵੇਂ ਹੀ ਕਿਸੇ ਸਟੈਪ ਵਿੱਚ ਦਾਖਲ ਹੁੰਦੇ ਹੋ, ਜਾਂ ਇਸਦੇ ਲੋੜੀਂਦੇ ਮੁੱਲ ਇਕੱਠੇ ਹੋ ਜਾਂਦੇ ਹਨ, ਪਹਿਲਾ ਮਿਲਦਾ condition ਜਾਂ always ਟ੍ਰਾਂਜ਼ਿਸ਼ਨ ਲਾਗੂ ਹੁੰਦਾ ਹੈ, ਇਸ ਤੋਂ ਪਹਿਲਾਂ ਕਿ ਮਾਡਲ ਕੋਈ when ਚੁਣ ਸਕੇ। ਇਸ ਲਈ 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 ਅੰਦਰੂਨੀ ਰੂਟਿੰਗ ਨੋਟ ਹੁੰਦਾ ਹੈ ਅਤੇ ਕਦੇ ਵੀ ਬੋਲ ਕੇ ਨਹੀਂ ਸੁਣਾਇਆ ਜਾਂਦਾ।

ਹੈਂਡਆਫ਼ ਕਰਨ ਵੇਲੇ, ਏਜੰਟ ਕਾਲਰ ਨੂੰ ਉਹ ਕਿੱਥੇ ਜਾ ਰਹੇ ਹਨ ਦੱਸਣ ਲਈ ਆਪਣੀ ਆਵਾਜ਼ ਵਿੱਚ ਇੱਕ ਛੋਟੀ ਲਾਈਨ ਕਹਿੰਦਾ ਹੈ, ਜਿਵੇਂ ਕਿ "ਜ਼ਰੂਰ, ਮੈਂ ਤੁਹਾਨੂੰ ਸਾਡੀ ਬਿਲਿੰਗ ਟੀਮ ਕੋਲ ਭੇਜ ਦਿੰਦਾ ਹਾਂ"। ਫਿਰ ਟਾਰਗੇਟ ਏਜੰਟ ਦਾ 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, ਏਜੰਟ id ਤੋਂ ਪਹਿਲਾਂ ਲੱਗਿਆ 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"}
  ]
}

ਫਰੰਟ ਡੈੱਸਕ ਇੱਕ ਛੋਟੀ ਲਾਈਨ ਕਹਿੰਦਾ ਹੈ, ਜਿਵੇਂ ਕਿ "ਮੈਂ ਤੁਹਾਨੂੰ ਸਾਡੀ ਬਿਲਿੰਗ ਟੀਮ ਨਾਲ ਜੋੜ ਦਿੰਦਾ ਹਾਂ", ਅਤੇ ਬਿਲਿੰਗ ਏਜੰਟ ਆਪਣਾ ਪਰਿਚਯ ਦਿੰਦਾ ਹੈ ਤੇ ਗੱਲਬਾਤ ਨੂੰ ਉੱਥੋਂ ਅੱਗੇ ਵਧਾਉਂਦਾ ਹੈ ਜਿੱਥੇ ਫਰੰਟ ਡੈੱਸਕ ਨੇ ਛੱਡਿਆ ਸੀ। ਜਦੋਂ ਬਿਲਿੰਗ ਵਾਪਸ ਭੇਜਦਾ ਹੈ, ਫਰੰਟ ਡੈੱਸਕ ਉੱਥੋਂ ਮੁੜ ਸ਼ੁਰੂ ਕਰਦਾ ਹੈ ਜਿੱਥੇ ਉਹ ਸੀ, ਕਾਲਰ ਨੂੰ ਦੁਬਾਰਾ ਨਮਸਕਾਰ ਕੀਤੇ ਬਿਨਾਂ। ਕਾਲ ਦਾ ਪ੍ਰੋਡਕਟ, ਭਾਸ਼ਾਵਾਂ, ਸਹਿਮਤੀ ਘੋਸ਼ਣਾ ਅਤੇ ਹੋਰ ਕਾਲ ਸੈਟਿੰਗਾਂ ਫਰੰਟ ਡੈੱਸਕ ਕੋਲ ਹੀ ਰਹਿੰਦੀਆਂ ਹਨ, ਕਿਉਂਕਿ ਉਸਨੇ ਜਵਾਬ ਦਿੱਤਾ ਸੀ।

ਜੇ ਬਿਲਿੰਗ ਨੂੰ ਸਿਰਫ਼ ਆਪਣੀਆਂ ਹਦਾਇਤਾਂ ਦੀ ਲੋੜ ਹੈ ਅਤੇ ਆਪਣੇ ਏਜੰਟ ਦੀ ਨਹੀਂ, ਤਾਂ ਇਸਦੀ ਬਜਾਏ ਫਰੰਟ ਡੈੱਸਕ 'ਤੇ ਇੱਕ ਗਲੋਬਲ ਸਟੈਪ ਵਰਤੋ। ਜਦੋਂ ਸਵਾਲ ਦਾ ਜਵਾਬ ਮਿਲ ਜਾਂਦਾ ਹੈ, ਕਾਲ ਉਸ ਸਟੈਪ 'ਤੇ ਵਾਪਸ ਜਾਂਦੀ ਹੈ ਜਿਸ ਵਿੱਚ ਕਾਲਰ ਸੀ:

{
  "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"
}

ਅਗਲੇ ਕਦਮ#