ਅੱਜਕੱਲ੍ਹ ਹਰ AI ਗੱਲਬਾਤ ਵਿੱਚ ਏਜੰਟ (Agents) ਦਾ ਦਬਦਬਾ ਹੈ। ਡੈਮੋਜ਼ (Demos) ਉਨ੍ਹਾਂ ਨੂੰ ਅਜਿਹੇ ਖੁਦਮੁਖਤਿਆਰ ਡਿਜੀਟਲ ਸਹਾਇਕਾਂ ਵਜੋਂ ਦਿਖਾਉਂਦੇ ਹਨ ਜੋ ਮਨੁੱਖੀ ਮਦਦ ਤੋਂ ਬਿਨਾਂ ਸੋਚਦੇ ਹਨ, ਰਣਨੀਤੀ ਬਣਾਉਂਦੇ ਹਨ ਅਤੇ ਸਮੱਸਿਆਵਾਂ ਨੂੰ ਹੱਲ ਕਰਦੇ ਹਨ। ਪਰ ਜੇਕਰ ਤੁਸੀਂ ਇਸ ਇੰਟਰਫੇਸ ਦੇ ਅੰਦਰ ਦੇਖੋਗੇ, ਤਾਂ ਤੁਹਾਨੂੰ ਕੁਝ ਬਹੁਤ ਹੀ ਸਰਲ ਮਿਲੇਗਾ। ਇੱਕ ਏਜੰਟ ਸਿਰਫ਼ ਇੱਕ ਲੂਪ (loop) ਦੇ ਅੰਦਰ ਚੱਲ ਰਿਹਾ ਇੱਕ ਲੈਂਗੂਏਜ ਮਾਡਲ ਹੈ। ਇਹ ਇੱਕ ਡਿਜ਼ਾਈਨ ਪੈਟਰਨ ਹੈ, ਕੋਈ ਚੇਤਨਾ ਨਹੀਂ। ਇਸ ਅੰਤਰ ਨੂੰ ਸਮਝਣਾ ਮਹੱਤਵਪੂਰਨ ਹੈ ਕਿਉਂਕਿ ਇਹ ਇਸ ਗੱਲ ਨੂੰ ਬਦਲ ਦਿੰਦਾ ਹੈ ਕਿ ਤੁਸੀਂ ਇਹਨਾਂ ਪ੍ਰਣਾਲੀਆਂ ਨੂੰ ਕਿਵੇਂ ਬਣਾਉਂਦੇ, ਡੀਬੱਗ (debug) ਕਰਦੇ ਅਤੇ ਉਹਨਾਂ 'ਤੇ ਭਰੋਸਾ ਕਰਦੇ ਹੋ।
ਇੱਕ ਏਜੰਟ ਅਸਲ ਵਿੱਚ ਕੀ ਹੁੰਦਾ ਹੈ
ਇੱਕ ਸਟੈਂਡਰਡ ਚੈਟਬੋਟ ਇੱਕ ਸਿੰਗਲ-ਸ਼ੌਟ ਫੰਕਸ਼ਨ ਹੈ। ਤੁਸੀਂ ਇੱਕ ਪ੍ਰੋਂਪਟ (prompt) ਟਾਈਪ ਕਰਦੇ ਹੋ। ਮਾਡਲ ਅਗਲੇ ਟੋਕਨਾਂ ਦੀ ਭਵਿੱਖਬਾਣੀ ਕਰਦਾ ਹੈ ਅਤੇ ਟੈਕਸਟ ਦਾ ਇੱਕ ਬਲਾਕ ਵਾਪਸ ਕਰਦਾ ਹੈ। ਫਿਰ ਇਹ ਰੁਕ ਜਾਂਦਾ ਹੈ। ਇਹ ਇਹ ਨਹੀਂ ਚੈੱਕ ਕਰਦਾ ਕਿ ਕੀ ਉਸਦਾ ਜਵਾਬ ਸਹੀ ਸੀ। ਇਹ ਇਹ ਵੀ ਨਹੀਂ ਜਾਂਚ ਕਰਦਾ ਕਿ ਕੀ ਕੋਈ ਵੈੱਬ ਲਿੰਕ ਕੰਮ ਕਰ ਰਿਹਾ ਹੈ ਜਾਂ ਕੀ ਕੋਈ ਗਣਨਾ ਸਹੀ ਹੈ। ਇਹ ਇੱਕ ਵਾਰ ਵਿੱਚ ਹੀ ਤੁਹਾਨੂੰ ਆਪਣਾ ਸਭ ਤੋਂ ਵਧੀਆ ਅੰਦਾਜ਼ਾ ਦਿੰਦਾ ਹੈ ਅਤੇ ਚੁੱਪ ਹੋ ਜਾਂਦਾ ਹੈ।
ਇੱਕ ਏਜੰਟ ਉਸ ਸਿੰਗਲ ਸ਼ੌਟ ਨੂੰ ਇੱਕ ਦੁਹਰਾਉਣ ਵਾਲੇ ਚੱਕਰ ਵਿੱਚ ਬਦਲ ਦਿੰਦਾ ਹੈ। ਮਾਡਲ ਅਜੇ ਵੀ ਟੈਕਸਟ ਤਿਆਰ ਕਰਦਾ ਹੈ, ਪਰ ਹੁਣ ਇਹ ਇੱਕ ਨਿਯੰਤਰਿਤ ਲੂਪ ਦੇ ਅੰਦਰ ਕੰਮ ਕਰਦਾ ਹੈ ਜਿੱਥੇ ਇਹ ਬਾਹਰੀ ਦੁਨੀਆ ਨੂੰ ਪ੍ਰਭਾਵਿਤ ਕਰ ਸਕਦਾ ਹੈ ਅਤੇ ਜੋ ਕੁਝ ਹੁੰਦਾ ਹੈ ਉਸ 'ਤੇ ਪ੍ਰਤੀਕਿਰਿਆ ਕਰ ਸਕਦਾ ਹੈ।
ਇਹ ਚੱਕਰ ਇਸ ਤਰ੍ਹਾਂ ਦਿਖਾਈ ਦਿੰਦਾ ਹੈ:
- ਟੀਚੇ ਦਾ ਮੁਲਾਂਕਣ ਕਰੋ ਅਤੇ ਕੀ ਕਰਨਾ ਹੈ ਇਸ ਬਾਰੇ ਸੋਚੋ।
- ਇੱਕ ਕਾਰਵਾਈ ਕਰੋ, ਆਮ ਤੌਰ 'ਤੇ ਕਿਸੇ ਟੂਲ ਜਾਂ API ਨੂੰ ਕਾਲ ਕਰਕੇ।
- ਉਸ ਕਾਰਵਾਈ ਦੇ ਨਤੀਜੇ ਨੂੰ ਦੇਖੋ।
- ਉਸ ਨਵੀਂ ਜਾਣਕਾਰੀ ਦੇ ਅਧਾਰ 'ਤੇ ਦੁਬਾਰਾ ਸੋਚੋ।
ਇਹ ਚੱਕਰ ਉਦੋਂ ਤੱਕ ਦੁਹਰਾਇਆ ਜਾਂਦਾ ਹੈ ਜਦੋਂ ਤੱਕ ਕੰਮ ਖਤਮ ਨਹੀਂ ਹੋ ਜਾਂਦਾ ਜਾਂ ਪ੍ਰਣਾਲੀ ਸੁਰੱਖਿਆ ਸੀਮਾ (safety limit) ਤੱਕ ਨਹੀਂ ਪਹੁੰਚ ਜਾਂਦੀ। ਇਹੀ ਸਾਰਾ ਭੇਦ ਹੈ। ਕੋਈ ਲੁਕਿਆ ਹੋਇਆ ਰੀਜ਼ਨਿੰਗ ਇੰਜਣ ਨਹੀਂ ਹੈ। ਜਾਦੂ ਅਸਲ ਟੂਲਜ਼ ਤੋਂ ਅਸਲ ਡੇਟਾ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਮਾਡਲ ਨੂੰ ਆਪਣੇ ਰਸਤੇ ਨੂੰ ਸੁਧਾਰਨ ਦਾ ਮੌਕਾ ਦੇਣ ਵਿੱਚੋਂ ਆਉਂਦਾ ਹੈ।
ReAct: Thought-Action-Observation ਚੱਕਰ
ਇਸ ਲੂਪ ਨੂੰ ਲਾਗੂ ਕਰਨ ਦਾ ਸਭ ਤੋਂ ਆਮ ਤਰੀਕਾ ReAct ਪੈਟਰਨ ਹੈ, ਜਿਸਦਾ ਮਤਲਬ ਹੈ Reason ਪਲੱਸ Act। ਲੂਪ ਦੇ ਹਰ ਚੱਕਰ ਵਿੱਚ, ਮਾਡਲ ਤਿੰਨ ਵੱਖ-ਵੱਖ ਪੜਾਵਾਂ ਵਿੱਚੋਂ ਲੰਘਦਾ ਹੈ।
ਪਹਿਲਾਂ, ਮਾਡਲ ਇੱਕ Thought ਪੈਦਾ ਕਰਦਾ ਹੈ। ਇਹ ਮੌਜੂਦਾ ਸਥਿਤੀ 'ਤੇ ਵਿਚਾਰ ਕਰਦਾ ਹੈ, ਆਪਣੇ ਆਪ ਨੂੰ ਅਸਲ ਟੀਚੇ ਦੀ ਯਾਦ ਦਿਵਾਉਂਦਾ ਹੈ ਅਤੇ ਫੈਸਲਾ ਕਰਦਾ ਹੈ ਕਿ ਉਸਨੂੰ ਅੱਗੇ ਕੀ ਜਾਣਨ ਦੀ ਲੋੜ ਹੈ। ਦੂਜਾ, ਇਹ ਇੱਕ Action ਚੁਣਦਾ ਹੈ। ਇਹ ਇੱਕ ਵੈੱਬ ਸਰਚ, ਡੇਟਾਬੇਸ ਕੁਏਰੀ (query), ਕੈਲਕੁਲੇਟਰ ਕਾਲ, ਜਾਂ ਫਾਈਲ ਪੜ੍ਹਨ ਦੀ ਬੇਨਤੀ ਹੋ ਸਕਦੀ ਹੈ। ਤੀਜਾ, ਇਸਨੂੰ ਇੱਕ Observation ਪ੍ਰਾਪਤ ਹੁੰਦਾ ਹੈ। ਪ੍ਰਣਾਲੀ ਮਾਡਲ ਤੋਂ ਬਾਹਰ ਕਾਰਵਾਈ ਨੂੰ ਚਲਾਉਂਦੀ ਹੈ ਅਤੇ ਕੱਚੇ ਨਤੀਜੇ ਨੂੰ ਗੱਲਬਾਤ ਦੇ ਇਤਿਹਾਸ ਵਿੱਚ ਵਾਪਸ ਭੇਜ ਦਿੰਦੀ ਹੈ। ਮਾਡਲ ਫਿਰ ਉਸ ਤਾਜ਼ਾ ਨਿਰੀਖਣ (observation) ਨੂੰ ਆਪਣੀ ਨਵੀਂ ਹਕੀਕਤ ਵਜੋਂ ਵਰਤਦੇ ਹੋਏ ਅਗਲਾ ਲੂਪ ਸ਼ੁਰੂ ਕਰਦਾ ਹੈ।
ਇੱਕ ਸਧਾਰਨ ਉਦਾਹਰਣ ਲਓ। ਮੰਨ ਲਓ ਤੁਸੀਂ ਇੱਕ ਏਜੰਟ ਨੂੰ ਪੁੱਛਦੇ ਹੋ ਕਿ ਕੀ ਕੱਲ੍ਹ ਆਸਟਿਨ (Austin) ਵਿੱਚ ਮੀਂਹ ਪਵੇਗਾ। ਮਾਡਲ ਸੋਚ ਸਕਦਾ ਹੈ, "ਮੈਨੂੰ ਆਸਟਿਨ ਲਈ ਮੌਸਮ ਦੀ ਭਵਿੱਖਬਾਣੀ ਦੀ ਲੋੜ ਹੈ।" ਇਸਦੀ ਕਾਰਵਾਈ ਸ਼ਹਿਰ ਦੇ ਨਾਮ ਨਾਲ ਮੌਸਮ API ਨੂੰ ਕਾਲ ਕਰਨਾ ਹੈ। ਨਿਰੀਖਣ (observation) ਕੱਚੇ JSON ਵਜੋਂ ਵਾਪਸ ਆਉਂਦਾ ਹੈ: ਤਾਪਮਾਨ ਦੀ ਰੀਡਿੰਗ ਅਤੇ ਵਰਖਾ ਦੀ ਸੰਭਾਵਨਾ। ਮਾਡਲ ਫਿਰ ਦੁਬਾਰਾ ਸੋਚਦਾ ਹੈ, "ਭਵਿੱਖਬਾਣੀ ਸੱਤਰ ਪ੍ਰਤੀਸ਼ਤ ਮੀਂਹ ਦੀ ਸੰਭਾਵਨਾ ਦਿਖਾਉਂਦੀ ਹੈ," ਅਤੇ ਇਸਦੀ ਅੰਤਿਮ ਕਾਰਵਾਈ ਉਸਨੂੰ ਤੁਹਾਡੇ ਲਈ ਸਧਾਰਨ ਅੰਗਰੇਜ਼ੀ ਜਵਾਬ ਵਿੱਚ ਬਦਲਣਾ ਹੈ।
ਇਹ ਢਾਂਚਾ ਮਹੱਤਵਪੂਰਨ ਹੈ ਕਿਉਂਕਿ ਇਹ ਮਾਡਲ ਨੂੰ ਅਸਲੀਅਤ ਨਾਲ ਜੋੜਦਾ ਹੈ। ਜੇਕਰ ਮਾਡਲ ਨੂੰ ਅੱਗੇ ਵਧਣ ਤੋਂ ਪਹਿਲਾਂ ਸਰਚ ਕਰਨੀ ਪਵੇਗੀ ਅਤੇ ਨਤੀਜਿਆਂ ਨੂੰ ਪੜ੍ਹਨਾ ਪਵੇਗਾ, ਤਾਂ ਇਹ ਸਿਰਫ਼ ਤੱਥਾਂ ਦੀ ਕਲਪਨਾ ਨਹੀਂ ਕਰ ਸਕਦਾ। ਨਿਰੀਖਣ (observation) ਅਗਲੀ ਸੋਚ 'ਤੇ ਇੱਕ ਸਖ਼ਤ ਪਾਬੰਦੀ ਵਜੋਂ ਕੰਮ ਕਰਦਾ ਹੈ। ਲੂਪ ਕਲਪਨਾ ਨੂੰ ਬਹੁਤ ਮੁਸ਼ਕਲ ਬਣਾ ਦਿੰਦਾ ਹੈ ਕਿਉਂਕਿ ਮਾਡਲ ਨੂੰ ਬੋਲਣ ਤੋਂ ਪਹਿਲਾਂ ਦੇਖਣਾ ਪੈਂਦਾ ਹੈ।
ਇੱਕ ਭਰੋਸੇਯੋਗ ਲੂਪ ਬਣਾਉਣ ਲਈ ਤੁਹਾਨੂੰ ਕੀ ਚਾਹੀਦਾ ਹੈ
ਪ੍ਰੋਡਕਸ਼ਨ (production) ਵਿੱਚ ਇਸ ਪੈਟਰਨ ਨੂੰ ਚਲਾਉਣ ਲਈ ਸਿਰਫ਼ ਇੱਕ ਚਲਾਕ ਪ੍ਰੋਂਪਟ ਤੋਂ ਵੱਧ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। ਤੁਹਾਨੂੰ ਤਿੰਨ ਵਿਵਹਾਰਕ ਗਾਰਡਰੇਲਜ਼ (guardrails) ਦੀ ਲੋੜ ਹੈ।
ਸਟੈਪ ਬਜਟ ਸੈੱਟ ਕਰੋ। ਹਮੇਸ਼ਾ ਲੂਪ ਇਟਰੇਸ਼ਨਾਂ ਦੀ ਵੱਧ ਤੋਂ ਵੱਧ ਗਿਣਤੀ ਨਿਰਧਾਰਤ ਕਰੋ। ਬਿਨਾਂ ਕਿਸੇ ਸੀਮਾ ਦੇ, ਇੱਕ ਏਜੰਟ ਆਪਣੀ ਹੀ ਪੂਛ ਦਾ ਪਿੱਛਾ ਕਰ ਸਕਦਾ ਹੈ—ਖੋਜ ਕਰਨਾ, ਨਿਰੀਖਣ ਕਰਨਾ, ਸੋਚਣਾ, ਦੁਬਾਰਾ ਖੋਜ ਕਰਨਾ—ਜਦੋਂ ਤੱਕ ਇਹ ਤੁਹਾਡੇ API ਬਜਟ ਨੂੰ ਖਤਮ ਨਹੀਂ ਕਰ ਦਿੰਦਾ। ਇੱਕ ਸਟੈਪ ਸੀਮਾ ਸਮਾਪਤੀ ਨੂੰ ਲਾਜ਼ਮੀ ਬਣਾਉਂਦੀ ਹੈ। ਤੁਸੀਂ ਇਹ ਫੈਸਲਾ ਕਰ ਸਕਦੇ ਹੋ ਕਿ ਸੀਮਾ ਪੂਰੀ ਹੋਣ ਤੋਂ ਬਾਅਦ ਅਧੂਰਾ ਨਤੀਜਾ ਵਾਪਸ ਕਰਨਾ ਹੈ, ਕਿਸੇ ਮਨੁੱਖ ਕੋਲ ਭੇਜਣਾ ਹੈ, ਜਾਂ ਸਿਰਫ਼ ਅਸਫਲ ਹੋਣਾ ਹੈ।
ਕੋਡ ਐਗਜ਼ੀਕਿਊਸ਼ਨ (execution) ਨੂੰ ਖੁਦ ਸੰਭਾਲੋ। ਲੈਂਗੂਏਜ ਮਾਡਲ ਟੂਲ ਨਹੀਂ ਚਲਾਉਂਦਾ। ਇਹ ਸਿਰਫ਼ ਕਾਰਵਾਈਆਂ ਦਾ ਸੁਝਾਅ ਦਿੰਦਾ ਹੈ, ਆਮ ਤੌਰ 'ਤੇ ਸਟ੍ਰਕਚਰਡ ਟੈਕਸਟ ਜਾਂ JSON ਆਉਟਪੁੱਟ ਕਰਕੇ ਜੋ ਇੱਕ ਟੂਲ ਦਾ ਨਾਮ ਲੈਂਦਾ ਹੈ ਅਤੇ ਪੈਰਾਮੀਟਰ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ। ਤੁਹਾਡੇ ਕੋਡ ਨੂੰ