ChatGPT Apps SDK ਨਾਲ ਲਾਂਚ ਕਰਦਿਆਂ ਸਾਨੂੰ ਕੀ ਸਿੱਖਣ ਨੂੰ ਮਿਲਿਆ

• ਜੇਕਰ ਤੁਹਾਨੂੰ ChatGPT ਵਿੱਚ ਛੇਤੀ ਕੋਈ ਵਰਕਫਲੋ ਚਾਹੀਦਾ ਹੈ ਜਾਂ ਕਸਟਮ ਏਜੰਟ ਸਟੈਕ ਵਿੱਚ ਨਿਵੇਸ਼ ਤੋਂ ਪਹਿਲਾਂ ਉੱਥੇ ਆਪਣੇ ਟੂਲ ਅਜ਼ਮਾਉਣੇ ਹਨ, ਤਾਂ Apps SDK ਇੱਕ ਵਿਹਾਰਕ ਵਿਕਲਪ ਹੈ। ਜੇਕਰ ਤੁਹਾਨੂੰ ਏਜੰਟ ਦੇ ਵਿਹਾਰ ਦੇ ਹਰ ਪੜਾਅ ਉੱਤੇ ਪੂਰਾ ਅਧਿਕਾਰ ਚਾਹੀਦਾ ਹੈ, ਤਾਂ ਆਮ ਤੌਰ ਉੱਤੇ ਇਹ ਢੁਕਵਾਂ ਨਹੀਂ ਹੈ।

• ਜਦੋਂ ChatGPT ਮੁੱਖ ਮੰਚ ਹੋਵੇ ਅਤੇ ਤੁਸੀਂ ਪੂਰਾ ਚੈਟ ਉਤਪਾਦ ਬਣਾਏ ਬਿਨਾਂ ਟੂਲਾਂ ਨਾਲ ਥੋੜ੍ਹਾ ਜਿਹਾ UI ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ Apps SDK ਚੁਣੋ। ਜਦੋਂ ਤੁਹਾਨੂੰ ਪ੍ਰਵਾਹ, ਮੈਮੋਰੀ, ਪ੍ਰੌਂਪਟਾਂ ਅਤੇ ਲਿਖਣ ਦੀਆਂ ਕਾਰਵਾਈਆਂ ਉੱਤੇ ਸਖ਼ਤ ਨਿਯੰਤਰਨ ਚਾਹੀਦਾ ਹੋਵੇ, ਤਾਂ ਆਪਣਾ ਏਜੰਟ ਸਟੈਕ ਚੁਣੋ।

• Apps SDK ਉਹਨਾਂ ਉਤਪਾਦਾਂ ਲਈ ਢੁਕਵਾਂ ਹੈ ਜੋ ਚੈਟ ਨੂੰ UI ਦੇ ਕੁਝ ਛੋਟੇ ਪੜਾਵਾਂ ਨਾਲ ਜੋੜਦੇ ਹਨ। ਤੁਸੀਂ ਜਲਦੀ ਜਾਰੀ ਕਰਦੇ ਹੋ, ਪਰ ਕੁਝ ਨਿਯੰਤਰਨ ਛੱਡਦੇ ਹੋ।

• ਸਾਡੇ ਲਈ ਸਪਸ਼ਟ ਟੂਲ, ਵਿਜੈੱਟ ਦਾ ਸਪਸ਼ਟ ਵਿਹਾਰ ਅਤੇ ਅਗਲੇ ਸਪਸ਼ਟ ਪੜਾਅ ਕਾਰਗਰ ਰਹੇ। ਅਸੀਂ ਪ੍ਰਵਾਹ ਤੈਅ ਕਰਨ ਲਈ ਇਹਨਾਂ ਉੱਤੇ ਨਿਰਭਰ ਕੀਤਾ, LLM ਉੱਤੇ ਨਹੀਂ। ਮਾਡਲ ਉਦੋਂ ਸਭ ਤੋਂ ਉਪਯੋਗੀ ਸੀ ਜਦੋਂ ਉਸਨੇ ਸਿਸਟਮ ਵੱਲੋਂ ਪਹਿਲਾਂ ਹੀ ਚੁਣੇ ਨਤੀਜਿਆਂ ਦੀ ਵਿਆਖਿਆ ਕੀਤੀ।

• ਹੇਠਾਂ: ਕਿਵੇਂ ਚੁਣਨਾ ਹੈ, ਫਿਰ ਕੀ ਕੰਮ ਕੀਤਾ ਅਤੇ ਕੀ ਨਹੀਂ ਕੀਤਾ।

ਜ਼ਿਆਦਾਤਰ ਟੀਮਾਂ ਅਜੇ ਵੀ AI ਦੇ ਅਜ਼ਮਾਇਸ਼ੀ ਪ੍ਰੋਜੈਕਟ ਚਲਾਉਂਦੀਆਂ ਹਨ ਜਾਂ ਘੱਟ ਜੋਖਮ ਅਤੇ ਲਾਭ ਵਾਲੇ ਸਹਾਇਕ ਕੰਮਾਂ ਲਈ AI ਵਰਤਦੀਆਂ ਹਨ। ਬਹੁਤ ਘੱਟ ਟੀਮਾਂ ਅਜਿਹਾ ਕਾਰੋਬਾਰ ਲਈ ਅਹਿਮ ਉਤਪਾਦ ਜਾਰੀ ਕਰਦੀਆਂ ਹਨ ਜਿਸਨੂੰ ਵਰਤੋਂਕਾਰ ਹਰ ਹਫ਼ਤੇ ਵਰਤਦੇ ਹਨ। ਜੇਕਰ ਤੁਹਾਡਾ ਟੀਚਾ ਪੂਰਾ ਸਹਾਇਕ ਆਪ ਬਣਾਉਣ ਦੀ ਥਾਂ ChatGPT ਦੇ ਅੰਦਰ ਪਹੁੰਚਣਾ ਹੈ, ਤਾਂ ChatGPT Apps SDK ਇਸ ਘਾਟ ਨੂੰ ਪੂਰਾ ਕਰਨ ਦਾ ਇੱਕ ਤਰੀਕਾ ਹੈ।

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

ਇਹਨਾਂ ਲੋੜਾਂ ਲਈ Apps SDK ਢੁਕਵਾਂ ਸੀ, ਕਿਉਂਕਿ ਗਾਹਕ ਨੂੰ ਇਹ ਚਾਹੀਦਾ ਸੀ:

• ਬਣਾਉਣ ਅਤੇ ਹੋਸਟ ਕਰਨ ਲਈ ਵੱਖਰਾ ਚੈਟ ਉਤਪਾਦ ਨਹੀਂ—ਉਹ ChatGPT ਦੇ ਅੰਦਰ ਪਹੁੰਚ ਚਾਹੁੰਦੇ ਸਨ, ਕੋਈ ਹੋਰ ਇਕੱਲਾ ਸਹਾਇਕ ਢਾਂਚਾ ਨਹੀਂ।

• ਚੈਟ ਨਾਲ ਛੋਟਾ, ਟਾਸਕ-ਵਿਸ਼ੇਸ਼ UI—ਵਰਕਫਲੋ ਅੰਦਰ ਦੂਜਾ ਪੂਰਾ ਉਤਪਾਦ ਨਹੀਂ, ਸਗੋਂ ਵਿਜੈੱਟ ਦੇ ਕੁਝ ਕੇਂਦਰਿਤ ਪੜਾਅ।

• MCP ਟੂਲਾਂ ਰਾਹੀਂ ਉਪਲਬਧ ਬੈਕਐਂਡ ਵਿਹਾਰ—ਸ਼ੁਰੂ ਤੋਂ ਅੰਤ ਤੱਕ ਆਪਣਾ ਕਸਟਮ ਏਜੰਟ ਰਨਟਾਈਮ ਨਹੀਂ, ਸਗੋਂ ਮਿਆਰੀ ਟੂਲ ਕਾਲਿੰਗ।

• ChatGPT ਅੰਦਰ ਖੋਜ—ਵਰਤੋਂਕਾਰਾਂ ਨੂੰ ਵਰਕਫਲੋ ਉੱਥੇ ਮਿਲੇ ਜਿੱਥੇ ਉਹ ਪਹਿਲਾਂ ਹੀ ਕੰਮ ਕਰਦੇ ਹਨ।

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

Apps SDK ਐਪ ਤਿੰਨ ਚੀਜ਼ਾਂ ਨੂੰ ਆਪਸ ਵਿੱਚ ਜੋੜਦੀ ਹੈ:

1. ChatGPT ਦਾ ਏਜੰਟ ਰਨਟਾਈਮ

2. ਤੁਹਾਡੇ MCP ਟੂਲ

3. ਤੁਹਾਡਾ ਵਿਜੈੱਟ UI

ਅਮਲ ਵਿੱਚ ਪ੍ਰਵਾਹ:

1. ਵਰਤੋਂਕਾਰ ChatGPT ਨੂੰ ਕੁਝ ਕਰਨ ਲਈ ਕਹਿੰਦਾ ਹੈ।

2. ChatGPT ਤੁਹਾਡੇ MCP ਟੂਲਾਂ ਵਿੱਚੋਂ ਕਿਸੇ ਇੱਕ ਨੂੰ ਕਾਲ ਕਰ ਸਕਦਾ ਹੈ।

3. ਤੁਹਾਡਾ ਸਰਵਰ ਇੱਕ ਸਟ੍ਰੱਕਚਰ ਕੀਤਾ ਟੂਲ ਨਤੀਜਾ ਵਾਪਸ ਕਰਦਾ ਹੈ।

4. ChatGPT ਉਸ ਨਤੀਜੇ ਨੂੰ ਪੜ੍ਹ ਕੇ ਅਗਲਾ ਪੜਾਅ ਤੈਅ ਕਰਦਾ ਹੈ: ਹੋਰ ਟੂਲ ਕਾਲਾਂ, ਵਰਤੋਂਕਾਰ ਨੂੰ ਜਵਾਬ ਜਾਂ ਦੋਵੇਂ। ਜੇਕਰ ਤੁਸੀਂ ਉਸ ਟੂਲ ਨਾਲ ਵਿਜੈੱਟ ਜੋੜਿਆ ਹੈ, ਤਾਂ ਉਹ ਇਸ ਵਾਰ ਵਿੱਚ ਦਿਖ ਸਕਦਾ ਹੈ।

5. ਵਰਤੋਂਕਾਰ ਚੈਟ ਜਾਂ ਵਿਜੈੱਟ ਵਿੱਚ ਅੱਗੇ ਵਧਦਾ ਹੈ (ਅਗਲਾ ਸੁਨੇਹਾ, ਕੋਈ ਚੋਣ ਜਾਂ ਵਿਜੈੱਟ ਵੱਲੋਂ ਸ਼ੁਰੂ ਕੀਤੀ ਟੂਲ ਕਾਲ)। ਇਸ ਨਾਲ ਥ੍ਰੈੱਡ ਅੱਪਡੇਟ ਹੁੰਦਾ ਹੈ। ChatGPT ਇੱਕ ਹੋਰ ਵਾਰੀ ਚਲਦਾ ਹੈ ਅਤੇ ਕੰਮ ਪੂਰਾ ਹੋਣ ਤੱਕ ਪੜਾਅ 2–4 ਦੁਹਰਾਏ ਜਾਂਦੇ ਹਨ।

ਚੈਟ, ਬੈਕਐਂਡ ਕਾਰਵਾਈਆਂ ਅਤੇ UI ਦੇ ਛੋਟੇ ਪੜਾਵਾਂ ਦਾ ਇਹ ਮੇਲ ਹੀ ਮੁੱਖ ਗੱਲ ਹੈ। ਇਸਦਾ ਇਹ ਵੀ ਅਰਥ ਹੈ ਕਿ ਚੈਟ, ਟੂਲਾਂ ਅਤੇ UI ਵਿਚਕਾਰਲੇ ਹਵਾਲੇ ਸਭ ਤੋਂ ਨਾਜ਼ੁਕ ਹਿੱਸੇ ਹਨ।

ਤੁਹਾਨੂੰ ਚੈਟ UI, ਟੂਲ ਵਾਇਰਿੰਗ, ਪ੍ਰਮਾਣੀਕਰਨ ਸ਼ੈਲੀਆਂ ਜਾਂ ਵਿਜੈੱਟ ਖੋਲ ਸ਼ੁਰੂ ਤੋਂ ਨਹੀਂ ਬਣਾਉਣੇ ਪੈਂਦੇ। ਕਈ ਉਤਪਾਦਾਂ ਲਈ ਇਸ ਨਾਲ ਬਣਾਉਣ ਦਾ ਕਾਫ਼ੀ ਸਮਾਂ ਬਚਦਾ ਹੈ, ਜਿਸ ਨਾਲ ਤੁਸੀਂ ਖੇਤਰ-ਵਿਸ਼ੇਸ਼ ਤਰਕ ਅਤੇ ਸੁਰੱਖਿਆ ਨਿਯੰਤਰਨਾਂ ਉੱਤੇ ਧਿਆਨ ਦੇ ਸਕਦੇ ਹੋ।

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

Apps SDK ਤੁਹਾਡੇ ਸਾਧਾਰਨ ਫਰੰਟਐਂਡ ਤੋਂ ਵੱਖਰੀ ਕਿਸਮ ਦਾ ਉਤਪਾਦ ਦਿੰਦਾ ਹੈ, ਪਰ ਇਹ ਜਾਣਨਾ ਜ਼ਰੂਰੀ ਹੈ ਕਿ ਇਹ ਕਿਹੜੇ ਹਾਲਾਤਾਂ ਲਈ ਸਭ ਤੋਂ ਢੁਕਵਾਂ ਹੈ।

Apps SDK ਉਦੋਂ ਵਰਤੋ ਜਦੋਂ ਤੁਸੀਂ ਚਾਹੁੰਦੇ ਹੋ

• ChatGPT ਵਰਕਫਲੋ ਛੇਤੀ ਜਾਰੀ ਕਰਨਾ।

• ChatGPT ਨੂੰ ਗੱਲਬਾਤ ਦੀ ਮੇਜ਼ਬਾਨੀ ਕਰਨ ਦਿਓ।

• ਸੁਭਾਵਿਕ ਭਾਸ਼ਾ ਨੂੰ UI ਦੇ ਕੁਝ ਕੇਂਦ੍ਰਿਤ ਪੜਾਵਾਂ ਨਾਲ ਜੋੜੋ।

• ਤੁਹਾਡਾ ਆਪਣਾ ਚੈਟ ਇੰਟਰਫੇਸ, ਏਜੰਟ ਕੰਟੇਨਰ ਅਤੇ ਖੋਜ ਪ੍ਰਣਾਲੀ ਬਣਾਉਣ ਤੋਂ ਬਚੋ।

ਇਹ ਆਖ਼ਰੀ ਨੁਕਤਾ ਉਦੋਂ ਅਹਿਮ ਹੈ ਜਦੋਂ ਤੁਹਾਡੇ ਵਰਤੋਂਕਾਰ ਪਹਿਲਾਂ ਹੀ ChatGPT ਵਿੱਚ ਕੰਮ ਕਰਦੇ ਹਨ।

ਤੁਹਾਡਾ ਆਪਣਾ ਏਜੰਟ ਉਦੋਂ ਬਣਾਓ ਜਦੋਂ ਤੁਹਾਨੂੰ ਚਾਹੀਦਾ ਹੋਵੇ

• ਪੜਾਅ-ਦਰ-ਪੜਾਅ ਤੈਅ ਪ੍ਰਵਾਹ, ਜਿਸਨੂੰ ਤੁਸੀਂ ਕੋਡ ਰਾਹੀਂ ਲਾਗੂ ਕਰ ਸਕੋ।

• ਕਸਟਮ UI ਅਤੇ ਪੁਸ਼ਟੀਕਰਨ ਦਾ ਅਜਿਹਾ ਰਸਤਾ ਜਿਸ ਉੱਤੇ ਸ਼ੁਰੂ ਤੋਂ ਅੰਤ ਤੱਕ ਤੁਹਾਡਾ ਅਧਿਕਾਰ ਹੋਵੇ।

• ਤੁਹਾਡਾ ਆਪਣਾ ਮੈਮੋਰੀ ਅਤੇ ਸਥਿਤੀ ਮਾਡਲ।

• ਅਜਿਹਾ ਵਿਹਾਰ ਜੋ ਹਰ ਵਾਰ ਅਨੁਮਾਨਯੋਗ ਹੋਣਾ ਲਾਜ਼ਮੀ ਹੈ।

• ਏਜੰਟ ਲਈ ਟ੍ਰੇਸ, ਲੌਗ ਅਤੇ ਮੈਟ੍ਰਿਕਸ।

ਜੇਕਰ ਯੋਜਨਾਕਾਰ, ਸਿਸਟਮ ਪ੍ਰੌਂਪਟ ਅਤੇ ਪੂਰਾ ਵਰਕਫਲੋ ਹੀ ਤੁਹਾਡਾ ਉਤਪਾਦ ਹਨ, ਤਾਂ ਆਮ ਤੌਰ ਉੱਤੇ ਕਸਟਮ ਸਟੈਕ ਬਿਹਤਰ ਹੈ।

ਸਾਡੇ ਪ੍ਰੋਜੈਕਟ ਵਿੱਚ ਵਾਰ-ਵਾਰ ਉੱਭਰਦਾ ਸ਼ਬਦ ਸੀ ਨਿਯੰਤਰਨ: ਇੱਕ ਪਾਸੇ ਤੇਜ਼ੀ ਅਤੇ ਜਾਣਿਆ-ਪਛਾਣਿਆ ਹੋਸਟ, ਦੂਜੇ ਪਾਸੇ ਰਨਟਾਈਮ ਉੱਤੇ ਅਧੂਰਾ ਅਧਿਕਾਰ। ਪੂਰੇ ਸਟੈਕ ਉੱਤੇ ਅਧਿਕਾਰ ਦੀ ਥਾਂ ChatGPT ਵਿੱਚ ਵਰਤੋਂਕਾਰਾਂ ਤੱਕ ਪਹੁੰਚ ਨੂੰ ਤਰਜੀਹ ਦਿੰਦਿਆਂ ਗਾਹਕ ਨੇ ਇਹ ਸਮਝੌਤਾ ਮੰਨਿਆ ਸੀ।

ਸਾਧਾਰਨ ਪ੍ਰਕਿਰਿਆ ਸੁਣਨ ਵਿੱਚ ਸੌਖੀ ਲੱਗਦੀ ਹੈ: ਵਰਤੋਂਕਾਰ ਪੁੱਛਦਾ ਹੈ, ਟੂਲ ਚਲਦਾ ਹੈ, ਡਾਟਾ ਵਾਪਸ ਆਉਂਦਾ ਹੈ ਅਤੇ ਲੋੜ ਪੈਣ 'ਤੇ ਵਿਜੈੱਟ ਦਿਖਾਈ ਦਿੰਦਾ ਹੈ।

ਅਮਲ ਵਿੱਚ, ਸਭ ਤੋਂ ਵੱਡਾ ਸਿਰਦਰਦ ਹੈਂਡਔਫ਼ ਸੀ। ਵਿਜੈੱਟ ਸਜਾਵਟ ਨਹੀਂ ਹੈ। ਸਕ੍ਰੀਨ ਉੱਤੇ ਆਉਣ ਮਗਰੋਂ ਇਹ ਬਦਲ ਦਿੰਦਾ ਹੈ ਕਿ ਮਾਡਲ ਕੀ ਵੇਖਦਾ ਅਤੇ ਅੱਗੇ ਕੀ ਕਰਦਾ ਹੈ। ਵਿਜੈੱਟ ਕਾਰਵਾਈਆਂ ਨੂੰ ਖੁੱਲ੍ਹੀ ਚੈਟ ਨਹੀਂ, ਸਗੋਂ ਨਾਮ ਵਾਲੀਆਂ ਘਟਨਾਵਾਂ ਸਮਝੋ।

ਪ੍ਰੋਜੈਕਟ ਦਾ ਸਟੈਕ ਸਿੱਧਾ-ਸਾਦਾ ਸੀ: FastMCP, Pydantic, React, TypeScript। ਇਹਨਾਂ ਨੂੰ ਜੋੜਨਾ ਸੌਖਾ ਸੀ। ਅਸਲ ਕੰਮ ਮਾਡਲ, ਟੂਲਾਂ ਅਤੇ UI ਵਿਚਕਾਰ ਇਸ ਗੱਲ ਉੱਤੇ ਸਹਿਮਤੀ ਬਣਾਉਣਾ ਸੀ ਕਿ ਅੱਗੇ ਕੀ ਹੋਵੇਗਾ।

ਹਰੇਕ ਹੈਂਡਔਫ਼ ਸਪਸ਼ਟ ਬਣਾਓ

ਅਸੀਂ ਟੂਲ ਨਤੀਜਿਆਂ ਨੂੰ ਬੈਕਐਂਡ ਦੇ ਕੱਚੇ ਪੇਲੋਡ ਸਮਝਣਾ ਛੱਡ ਦਿੱਤਾ। ਹਰ ਵਾਪਸੀ ਇੱਕ ਹੈਂਡਔਫ਼ ਬਣ ਗਈ।

ਇੱਕ ਮਜ਼ਬੂਤ ਟੂਲ ਨਤੀਜਾ:

• ਵਿਜੈੱਟ ਨੂੰ ਦਿਖਾਉਣ ਲਈ ਲੋੜੀਂਦੀ ਜਾਣਕਾਰੀ ਦਿੰਦਾ ਹੈ।

• ChatGPT ਨੂੰ ਜਵਾਬ ਦਾ ਆਧਾਰ ਬਣਾਉਣ ਲਈ ਸਟ੍ਰੱਕਚਰ ਕੀਤਾ ਤੱਥ ਦਿੰਦਾ ਹੈ।

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

ਵਿਜੈੱਟ ਕਾਰਵਾਈਆਂ ਨੂੰ ਥ੍ਰੈੱਡ ਵਿੱਚ ਅਸਪਸ਼ਟ ਲਿਖਤ ਵਾਪਸ ਨਹੀਂ ਭੇਜਣੀ ਚਾਹੀਦੀ। ਉਹਨਾਂ ਨੂੰ ਦੱਸਣਾ ਚਾਹੀਦਾ ਹੈ ਕਿ ਵਰਤੋਂਕਾਰ ਨੇ ਕੀ ਕੀਤਾ ਅਤੇ ਅੱਗੇ ਕੀ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ।

ਹੈਂਡਔਫ਼ ਸਪਸ਼ਟ ਹੋਣ ਮਗਰੋਂ ਭਰੋਸੇਯੋਗਤਾ ਵਧ ਗਈ।

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

ਹੇਠਾਂ ਸਾਡੇ ਵੱਲੋਂ ਵਰਤਿਆ ਇੱਕ ਛੋਟਾ Pydantic ਢਾਂਚਾ ਹੈ। ਆਊਟਪੁੱਟ ਖੇਤਰ ਵਿੱਚ ਵਿਜੈੱਟ ਦਿਖਾਉਣ ਲਈ ਲੋੜੀਂਦਾ ਸਟ੍ਰੱਕਚਰ ਕੀਤਾ ਡਾਟਾ ਅਤੇ ਉਹ ਤੱਥ ਹੁੰਦੇ ਹਨ ਜੋ ChatGPT ਨੂੰ ਸੈਸ਼ਨ ਵਿੱਚ ਵਰਤਣੇ ਚਾਹੀਦੇ ਹਨ। agent_directions ਫੀਲਡ ਵਿੱਚ ਇੱਕ ਛੋਟੀ ਲਾਈਨ ਹੁੰਦੀ ਹੈ ਜੋ ਦੱਸਦੀ ਹੈ ਕਿ ਸਹਾਇਕ ਨੂੰ ਅੱਗੇ ਕੀ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ। ਕਾਰਨ ਚੋਣਵਾਂ ਹੈ।

1from typing import Generic, TypeVar2
3from pydantic import BaseModel4
5T = TypeVar("T")6
7class AgentDirections(BaseModel):8 assistant_instruction: str9 reason: str | None = None10
11class ToolResults(BaseModel, Generic[T]):12 agent_directions: AgentDirections13 output: T

ਵਿਜੈੱਟ ਛੋਟੇ ਰੱਖੋ

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

ਵਿਜੈੱਟ ਸੁਨੇਹਿਆਂ ਵਿੱਚ ਤੀਜਾ ਪੁਰਖ

ਅਸੀਂ ਵਿਜੈੱਟ ਦੇ ਅਗਲੇ ਸੁਨੇਹੇ ਵਰਤੋਂਕਾਰ ਦੀ ਚੈਟ ਵਾਂਗ ਲਿਖਣੇ ਛੱਡ ਦਿੱਤੇ, ਜਿਵੇਂ “ਮੈਂ ਚੁਣਿਆ…” ਜਾਂ “ਮੈਂ ਪੁਸ਼ਟੀ ਕੀਤੀ…”। ਅਸੀਂ ਉਨ੍ਹਾਂ ਨੂੰ ਵਰਤੋਂਕਾਰ ਦੀ ਕਾਰਵਾਈ ਬਾਰੇ ਛੋਟੀਆਂ ਰਿਪੋਰਟਾਂ ਵਜੋਂ ਲਿਖਿਆ, ਜਿਵੇਂ “ਵਰਤੋਂਕਾਰ ਨੇ ਚੁਣਿਆ…” ਜਾਂ “ਵਰਤੋਂਕਾਰ ਨੇ ਪੁਸ਼ਟੀ ਕੀਤੀ…”। ਅਸੀਂ ਇਹ ਤਰੀਕਾ ਇਸ ਲਈ ਅਜ਼ਮਾਇਆ ਕਿਉਂਕਿ ChatGPT ਵਿਜੈੱਟ ਸੁਨੇਹਿਆਂ ਨੂੰ ਵਰਤੋਂਕਾਰ ਸੁਨੇਹਿਆਂ ਦੀ ਥਾਂ ਟੂਲ ਸੁਨੇਹਿਆਂ ਵਜੋਂ ਜੋੜ ਰਿਹਾ ਸੀ।

ਅਗਲਾ ਪੜਾਅ ਸਪਸ਼ਟ ਹੋਣ ਉੱਤੇ ਸਿੱਧੀਆਂ ਕਾਰਵਾਈਆਂ

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

ਇਸ ਨਾਲ ਨਿਰਧਾਰਤ ਪ੍ਰਵਾਹ ਲਾਗੂ ਕਰਨ ਵਿੱਚ ਮਦਦ ਮਿਲੀ ਅਤੇ ਇੱਕ ਹੋਰ ਚੈਟ ਵਾਰੀ ਤੋਂ ਬਚਣ ਕਰਕੇ ਲੈਟੈਂਸੀ ਵੀ ਘਟੀ।

ਗਲਤੀ ਸੰਭਾਲਣਾ

ਟੂਲ ਕਾਲ ਅਸਫਲ ਹੋਣ ਉੱਤੇ ਅਸੀਂ ਟੂਲ ਤੋਂ ਢੁਕਵੇਂ MCP ਗਲਤੀ ਕੋਡ ਅਤੇ ਛੋਟੇ, ਸਾਦੇ ਸੁਨੇਹੇ ਵਾਪਸ ਕੀਤੇ। ਇਸ ਤਰ੍ਹਾਂ ਅਸਫਲ ਕਾਲਾਂ ਬਾਰੇ ChatGPT ਕੋਲ ਪੜ੍ਹਨ ਲਈ ਅਸਲ ਜਾਣਕਾਰੀ ਹੁੰਦੀ ਸੀ, ਤਾਂ ਜੋ ਉਹ ਵਰਤੋਂਕਾਰ ਨੂੰ ਸਮੱਸਿਆ ਸਮਝਾ ਸਕੇ, ਢੁਕਵਾਂ ਅਗਲਾ ਪੜਾਅ ਚੁਣ ਸਕੇ ਜਾਂ ਦੋਵੇਂ ਕਰ ਸਕੇ।

ਟੂਲ ਸੰਦਰਭ ਦਾ ਪ੍ਰਬੰਧਨ

ਅਸੀਂ ਸੈਸ਼ਨ ਦੀ ਸਥਿਤੀ ਆਪਣੇ ਸਰਵਰ ਉੱਤੇ ਰੱਖੀ। ChatGPT ਟੂਲ ਕਾਲਾਂ ਨਾਲ ਸੈਸ਼ਨ-ਸੀਮਤ ਸੰਦਰਭ ਭੇਜਦਾ ਹੈ। FastMCP ਵਿੱਚ ਅਸੀਂ ਹਰ ਟੂਲ ਨੂੰ Context ਪੈਰਾਮੀਟਰ ਦਿੱਤਾ, ਤਾਂ ਜੋ ਹੈਂਡਲਰ ਉਸ ਸਥਿਤੀ ਨੂੰ ਪੜ੍ਹ ਅਤੇ ਅੱਪਡੇਟ ਕਰ ਸਕੇ।

• ਸਥਿਰ IDs ਅਤੇ ਪਹਿਲੇ ਨਤੀਜੇ ਸੈਸ਼ਨ ਵਿੱਚ ਰਹਿੰਦੇ ਸਨ, ਇਸ ਲਈ ChatGPT ਨੂੰ ਹਰ ਕਾਲ ਉੱਤੇ ਉਨ੍ਹਾਂ ਨੂੰ ਟੂਲ ਆਰਗੂਮੈਂਟਾਂ ਵਜੋਂ ਮੁੜ ਭੇਜਣ ਲਈ ਨਹੀਂ ਕਿਹਾ ਜਾਂਦਾ ਸੀ।

• ਜਦੋਂ ਟੂਲ-ਕਾਲ ਲੂਪ ਸਾਹਮਣੇ ਆਉਂਦੇ ਸਨ, ਤਾਂ ਅਸੀਂ ਡੁਪਲੀਕੇਟ ਕਾਲਾਂ ਨੂੰ ਪਛਾਣ ਕੇ ਟੂਲ ਨਤੀਜੇ ਰਾਹੀਂ ਸਪਸ਼ਟ ਗਲਤੀ ਵਾਪਸ ਕਰ ਸਕਦੇ ਸੀ।

• ਜਾਂਚ ਅਤੇ ਸਹਾਇਤਾ ਲਈ ਸੈਸ਼ਨ ਲੌਗ ਸਾਡੇ ਕੋਲ ਰਹਿੰਦੇ ਸਨ।

ਸ਼ੁਰੂ ਵਿੱਚ ਅਸੀਂ ਵਿਜੈੱਟ ਦਿਖਾਇਆ, ਮੰਨ ਲਿਆ ਕਿ ਮਾਡਲ “ਸਮਝ ਗਿਆ” ਹੈ ਅਤੇ ਸਹੀ ਅਗਲੀ ਟੂਲ ਕਾਲ ਦੀ ਉਡੀਕ ਕੀਤੀ। ਕਈ ਵਾਰ ਅਜਿਹਾ ਹੋਇਆ। ਅਕਸਰ ਅਜਿਹਾ ਨਹੀਂ ਹੋਇਆ।

ਸਪਸ਼ਟ ਹੈਂਡਔਫ਼ ਤੋਂ ਬਿਨਾਂ, ChatGPT ਕਾਰਵਾਈ ਦੀ ਥਾਂ ਸਾਰ ਦੇ ਸਕਦਾ ਸੀ, ਵਰਤੋਂਕਾਰ ਨੂੰ ਚੋਣ ਦੁਹਰਾਉਣ ਲਈ ਕਹਿ ਸਕਦਾ ਸੀ ਜਾਂ ਰੁਕਣ ਦੀ ਥਾਂ ਯੋਜਨਾ ਬਣਾਉਂਦਾ ਰਹਿ ਸਕਦਾ ਸੀ।

ਹੱਲ ਇਹ ਸੀ ਕਿ ਮਾਡਲ ਦੇ ਸਮਝਣ ਦੀ ਉਮੀਦ ਰੱਖਣ ਦੀ ਥਾਂ ਸਟਰੱਕਚਰਡ ਆਉਟਪੁੱਟਸ ਅਤੇ ਵਿਜੈੱਟ ਪੇਲੋਡਾਂ ਵਿੱਚ ਅਗਲਾ ਪੜਾਅ ਸਾਫ਼ ਲਿਖਿਆ ਜਾਵੇ।

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

Apps SDK ਦੇ ਦਸਤਾਵੇਜ਼ ਉਨ੍ਹਾਂ ਟੂਲਾਂ ਦਾ ਵਰਣਨ ਕਰਦੇ ਹਨ ਜਿਨ੍ਹਾਂ ਨੂੰ ਏਜੰਟ ਦੀ ਟੂਲ ਸੂਚੀ ਤੋਂ ਬਾਹਰ ਰੱਖਿਆ ਜਾ ਸਕਦਾ ਹੈ, ਤਾਂ ਜੋ ਉਹ ਉਨ੍ਹਾਂ ਨੂੰ ਨਾ ਚੁਣੇ ਪਰ ਵਿਜੈੱਟ ਫਿਰ ਵੀ ਉਨ੍ਹਾਂ ਨੂੰ ਕਾਲ ਕਰ ਸਕੇ। ਜਦੋਂ ਅਸੀਂ ਦਿੱਖਣਯੋਗਤਾ ਨੂੰ ਕੇਵਲ ਐਪ ਵਿੱਚ ਕੀਤਾ, ਤਾਂ ਉਹ ਟੂਲ ਸਿਰਫ਼ ਏਜੰਟ ਲਈ ਹੀ ਨਹੀਂ, ਵਿਜੈੱਟ ਲਈ ਵੀ ਅਣ-ਉਪਲਬਧ ਹੋ ਗਏ। ਸਾਨੂੰ ਕਦੇ ਅਜਿਹੀ ਸੰਰਚਨਾ ਨਹੀਂ ਮਿਲੀ ਜਿਸ ਵਿੱਚ ਏਜੰਟ ਟੂਲ ਨਾ ਵੇਖ ਸਕੇ ਪਰ ਵਿਜੈੱਟ ਵੇਖ ਸਕੇ।

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

ਜੇਕਰ ਤੁਹਾਡਾ ਟੀਚਾ ਘੱਟ ਕਸਟਮ ਪਲੇਟਫਾਰਮ ਕੰਮ ਨਾਲ ChatGPT ਵਿੱਚ ਵਰਕਫਲੋ ਬਣਾਉਣਾ ਹੈ, ਤਾਂ Apps SDK ਉੱਥੇ ਪਹੁੰਚਣ ਦਾ ਵਿਹਾਰਕ ਤਰੀਕਾ ਹੈ। ਤੇਜ਼ੀ ਅਤੇ ਵਰਤੋਂਕਾਰਾਂ ਤੱਕ ਉੱਥੇ ਪਹੁੰਚਣ ਲਈ ਜਿੱਥੇ ਉਹ ਪਹਿਲਾਂ ਹੀ ਕੰਮ ਕਰਦੇ ਹਨ, ਤੁਸੀਂ ਕੁਝ ਨਿਯੰਤਰਨ ਛੱਡਦੇ ਹੋ।

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

ਆਪਣਾ ਚੈਟ, ਪ੍ਰਮਾਣੀਕਰਨ ਅਤੇ ਏਜੰਟ ਪਲੰਬਿੰਗ ਬਣਾਉਣ ਤੋਂ ਪਹਿਲਾਂ ਤੁਸੀਂ Apps SDK ਰਾਹੀਂ ਆਪਣਾ MCP ਸਰਵਰ ChatGPT ਅੰਦਰ ਚਲਾ ਸਕਦੇ ਹੋ, ਫਿਰ ਉਤਪਾਦ ਦੀ ਲੋੜ ਮੁਤਾਬਕ ਆਪਣੇ ਸਟੈਕ ਉੱਤੇ ਜਾ ਸਕਦੇ ਹੋ।

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