ai-agents-for-beginners

(ਇਸ ਪਾਠ ਦੀ ਵੀਡੀਓ ਦੇਖਣ ਲਈ ਉੱਪਰ ਦਿੱਤੀ ਤਸਵੀਰ ‘ਤੇ ਕਲਿੱਕ ਕਰੋ)

ਏਆਈ ਏਜੰਟਾਂ ਵਿੱਚ ਮੈਟਾਕੌਗਨੀਸ਼ਨ

ਪਰਿਚਯ

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

ਸਿੱਖਣ ਦੇ ਲਕੜੇ

ਇਸ ਪਾਠ ਨੂੰ ਪੂਰਾ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਤੁਸੀਂ ਸਮਰੱਥ ਹੋਵੋਗੇ:

ਏਜੰਟ 정의 ਵਿੱਚ ਧਾਰਣਾ ਲੂਪਾਂ ਦੇ ਪ੍ਰਭਾਵ ਨੂੰ ਸਮਝਣਾ।
ਆਪਣਾ-ਆਪ ਸੁਧਾਰ ਕਰਨ ਵਾਲੇ ਏਜੰਟ ਦੀ ਮਦਦ ਲਈ ਯੋਜਨਾ ਅਤੇ ਮੁਲਾਂਕਣ ਤਕਨੀਕਾਂ ਦਾ ਉਪਯੋਗ ਕਰਨਾ।
ਆਪਣੇ ਖ਼ੁਦ ਦੇ ਏਜੰਟ ਬਣਾਉਣਾ ਜੋ ਕੰਮ ਪੂਰੇ ਕਰਨ ਲਈ ਕੋਡ ਨੂੰ ਚਲਾਉਣ ਵਿੱਚ ਸਮਰੱਥ ਹੋਣ।

ਮੈਟਾਕੌਗਨੀਸ਼ਨ ਦਾ ਪਰਿਚਯ

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

ਏਜੰਟਿਕ ਏਆਈ ਪ੍ਰਣਾਲੀਆਂ ਦੇ ਸੰਦਰਭ ਵਿੱਚ, ਮੈਟਾਕੌਗਨੀਸ਼ਨ ਕਈ ਚੁਣੌਤੀਆਂ ਨੂੰ ਸੰਬੋਧਨ ਕਰਨ ਵਿੱਚ ਮਦਦਗਾਰ ਹੋ ਸਕਦੀ ਹੈ, ਜਿਵੇਂ ਕਿ:

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

ਮੈਟਾਕੌਗਨੀਸ਼ਨ ਕੀ ਹੈ?

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

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

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

ਏਆਈ ਏਜੰਟਾਂ ਵਿੱਚ ਮੈਟਾਕੌਗਨੀਸ਼ਨ ਦੀ ਮਹੱਤਤਾ

ਮੈਟਾਕੌਗਨੀਸ਼ਨ ਏਆਈ ਏਜੰਟ ਡਿਜ਼ਾਈਨ ਵਿੱਚ ਕਈ ਕਾਰਨਾਂ ਕਰਕੇ ਇੱਕ ਅਹਿਮ ਭੂਮਿਕਾ ਨਿਭਾਉਂਦਾ ਹੈ:

ਮੈਟਾਕੌਗਨੀਸ਼ਨ ਦੀ ਮਹੱਤਤਾ

ਸੁਆਰਥੀ ਚਿੰਤਨ: ਏਜੰਟ ਆਪਣੇ ਪ੍ਰਦਰਸ਼ਨ ਦਾ ਮੁਲਾਂਕਣ ਕਰ ਸਕਦੇ ਹਨ ਅਤੇ ਸੁਧਾਰ ਲਈ ਖੇਤਰਾਂ ਦੀ ਪਛਾਣ ਕਰ ਸਕਦੇ ਹਨ।
ਢਾਲਣ ਯੋਗਤਾ: ਏਜੰਟ ਪਿਛਲੇ ਅਨੁਭਵਾਂ ਅਤੇ ਬਦਲਦੀਆਂ ਹਾਲਤਾਂ ਦੇ ਅਧਾਰ ‘ਤੇ ਆਪਣੀਆਂ ਰਣਨੀਤੀਆਂ ਨੂੰ ਬਦਲ ਸਕਦੇ ਹਨ।
ਗਲਤੀ ਸਧਾਰਨ: ਏਜੰਟ स्वतੰਤਰ ਤੌਰ ‘ਤੇ ਗਲਤੀਆਂ ਦੀ ਪਛਾਣ ਅਤੇ ਸੁਧਾਰ ਕਰ ਸਕਦੇ ਹਨ, ਜਿਸ ਨਾਲ ਨਤੀਜੇ ਬੇਹਤਰ ਹੋਂਦੇ ਹਨ।
ਸਰੋਤਾਂ ਦਾ ਪ੍ਰਬੰਧਨ: ਏਜੰਟ ਆਪਣੇ ਕਾਰਜਾਂ ਦੀ ਯੋਜਨਾ ਅਤੇ ਮੁਲਾਂਕਣ ਕਰਕੇ ਸਮਾਂ ਅਤੇ ਕਮਪਿਊਟੇਸ਼ਨਲ ਪਾਵਰ ਵਰਗੇ ਸਰੋਤਾਂ ਦੀ ਪ੍ਰਯੋਗਸ਼ੀਲਤਾ ਬਿਹਤਰ ਬਣਾਉਂਦੇ ਹਨ।

ਇੱਕ ਏਆਈ ਏਜੰਟ ਦੇ ਘਟਕ

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

ਪਰਸੋਨਾ: ਏਜੰਟ ਦੀ ਵਿਅਕਤੀਗਤ ਛਵੀਂ ਅਤੇ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ, ਜੋ ਯੂਜ਼ਰਾਂ ਨਾਲ ਸੰਪਰਕ ਕਰਨ ਦੇ ਢੰਗ ਦੀ ਪਰਿਭਾਸ਼ਾ ਕਰਦੀਆਂ ਹਨ।
ਟੂਲਜ਼: ਸਮਰੱਥਾਵਾਂ ਅਤੇ ਕਾਰਜੇ ਜੋ ਏਜੰਟ ਕਰ ਸਕਦਾ ਹੈ।
ਹੁਨਰ: ਗਿਆਨ ਅਤੇ ਮਾਹਿਰਤਾ ਜੋ ਏਜੰਟ ਕੋਲ ਹੈ।

ਇਹ ਘਟਕ ਇੱਕ “ਮਾਹਰਤਾ ਇਕਾਈ” ਦਾ ਸਿਰਜਣਾ ਕਰਦੇ ਹਨ ਜੋ ਖਾਸ ਕੰਮ ਕਰ ਸਕਦੀ ਹੈ।

ਉਦਾਹਰਣ: ਇੱਕ ਯਾਤਰਾ ਏਜੰਟ ਦੀ ਸੋਚੋ, ਜੋ ਨਾ ਸਿਰਫ ਤੁਹਾਡੀ ਛੁੱਟੀਆਂ ਦੀ ਯੋਜਨਾ ਬਣਾਉਂਦਾ ਹੈ ਪਰ ਅਸਲੀ ਸਮੇਂ ਦੇ ਡਾਟੇ ਅਤੇ ਪਿਛਲੇ ਗਾਹਕਾਂ ਦੇ ਯਾਤਰਾ ਅਨੁਭਵਾਂ ਦੇ ਆਧਾਰ ‘ਤੇ ਆਪਣਾ ਰਸਤਾ ਢਾਲਦਾ ਵੀ ਹੈ।

ਉਦਾਹਰਣ: ਯਾਤਰਾ ਏਜੰਟ ਸਰਵਿਸ ਵਿੱਚ ਮੈਟਾਕੌਗਨੀਸ਼ਨ

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

ਮੌਜੂਦਾ ਕੰਮ

ਮੌਜੂਦਾ ਕੰਮ ਇਕ ਯੂਜ਼ਰ ਦੀ ਪੈਰਿਸ ਯਾਤਰਾ ਯੋਜਨਾ ਬਣਾਉਣ ਵਿੱਚ ਮਦਦ ਕਰਨਾ ਹੈ।

ਕੰਮ ਪੂਰਾ ਕਰਨ ਲਈ ਕਦਮ

ਯੂਜ਼ਰ ਦੀਆਂ ਪਸੰਦਾਂ ਇਕੱਠੀਆਂ ਕਰੋ: ਯੂਜ਼ਰ ਤੋਂ ਉਸ ਦੀ ਯਾਤਰਾ ਦੀਆਂ ਤਾਰੀਖਾਂ, ਬਜਟ, ਰੁਚੀਆਂ (ਜਿਵੇਂ, ਮਿਊਜ਼ੀਅਮ, ਵਿਅੰਜਨ, ਖਰੀਦਦਾਰੀ) ਅਤੇ ਕੋਈ ਖਾਸ ਲੋੜਾਂ ਬਾਰੇ ਪੁੱਛੋ।
ਜਾਣਕਾਰੀ ਇਕੱਠੀ ਕਰੋ: ਫਲਾਈਟ ਵਿਕਲਪਾਂ, ਰਹਿਣ ਸਥਾਨਾਂ, ਆਕਰਸ਼ਣਾਂ ਅਤੇ ਰੈਸਟੋਰੈਂਟਾਂ ਦੀ ਖੋਜ ਕਰੋ ਜੋ ਯੂਜ਼ਰ ਦੀਆਂ ਪਸੰਦਾਂ ਨਾਲ ਮੇਲ ਖਾਂਦੇ ਹਨ।
ਸਿਫਾਰਸ਼ਾਂ ਤਿਆਰ ਕਰੋ: ਇਕ ਵਿਅਕਤੀਗਤ ਦਿਣਚਰਿਆ ਦਿਓ ਜਿਸ ਵਿੱਚ ਫਲਾਈਟ ਵੇਰਵੇ, ਹੋਟਲ ਬੁਕਿੰਗਜ਼ ਅਤੇ ਸੁਝਾਏ ਗਏ ਸਰਗਰਮੀਆਂ ਸ਼ਾਮਿਲ ਹੋਣ।
ਫੀਡਬੈਕ ਦੇ ਅਧਾਰ ‘ਤੇ ਢਾਲੋ: ਯੂਜ਼ਰ ਤੋਂ ਸਿਫਾਰਸ਼ਾਂ ‘ਤੇ ਫੀਡਬੈਕ ਲਵੋ ਅਤੇ ਜ਼ਰੂਰੀ ਬਦਲਾਅ ਕਰੋ।

ਲੋੜੀਂਦੇ ਸਰੋਤ

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

ਅਨੁਭਵ ਅਤੇ ਸੁਆਰਥੀ ਚਿੰਤਨ

ਟ੍ਰੈਵਲ ਏਜੰਟ ਮੈਟਾਕੌਗਨੀਸ਼ਨ ਨੂੰ ਆਪਣੇ ਪ੍ਰਦਰਸ਼ਨ ਦਾ ਮੂਲਾਂਕਣ ਕਰਨ ਅਤੇ ਪਿਛਲੇ ਅਨੁਭਵਾਂ ਤੋਂ ਸਿੱਖਣ ਲਈ ਉਪਯੋਗ ਕਰਦਾ ਹੈ। ਉਦਾਹਰਨ ਵਜੋਂ:

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

ਅਮਲੀ ਵਿਕਾਸਕਾਰ ਉਦਾਹਰਣ

ਇਹ ਰਹਿ ਗਿਆ ਇੱਕ ਸਰਲ ਉਦਾਹਰਣ ਕਿ ਮੈਟਾਕੌਗਨੀਸ਼ਨ ਸ਼ਾਮਿਲ ਕਰਨ ‘ਤੇ ਟ੍ਰੈਵਲ ਏਜੰਟ ਦਾ ਕੋਡ ਕਿਵੇਂ ਦਿਖ ਸਕਦਾ ਹੈ:

class Travel_Agent:
    def __init__(self):
        self.user_preferences = {}
        self.experience_data = []

    def gather_preferences(self, preferences):
        self.user_preferences = preferences

    def retrieve_information(self):
        # ਪਸੰਦਾਂ ਅਨੁਸਾਰ ਉਡਾਣਾਂ, ਹੋਟਲਾਂ ਅਤੇ ਆਕਰਸ਼ਣਾਂ ਦੀ ਖੋਜ ਕਰੋ
        flights = search_flights(self.user_preferences)
        hotels = search_hotels(self.user_preferences)
        attractions = search_attractions(self.user_preferences)
        return flights, hotels, attractions

    def generate_recommendations(self):
        flights, hotels, attractions = self.retrieve_information()
        itinerary = create_itinerary(flights, hotels, attractions)
        return itinerary

    def adjust_based_on_feedback(self, feedback):
        self.experience_data.append(feedback)
        # ਫੀਡਬੈਕ ਦਾ ਵਿਸ਼ਲੇਸ਼ਣ ਕਰੋ ਅਤੇ ਭਵਿੱਖ ਦੀਆਂ ਸਿਫਾਰਸ਼ਾਂ ਨੂੰ ਸਮਝੋ
        self.user_preferences = adjust_preferences(self.user_preferences, feedback)

# ਉਦਾਹਰਨ ਵਜੋਂ ਵਰਤੋਂ
travel_agent = Travel_Agent()
preferences = {
    "destination": "Paris",
    "dates": "2025-04-01 to 2025-04-10",
    "budget": "moderate",
    "interests": ["museums", "cuisine"]
}
travel_agent.gather_preferences(preferences)
itinerary = travel_agent.generate_recommendations()
print("Suggested Itinerary:", itinerary)
feedback = {"liked": ["Louvre Museum"], "disliked": ["Eiffel Tower (too crowded)"]}
travel_agent.adjust_based_on_feedback(feedback)

ਮੈਟਾਕੌਗਨੀਸ਼ਨ ਕਿਉਂ ਮਹੱਤਵਪੂਰਨ ਹੈ

ਸਵੈ-ਪ੍ਰਤੀਬਿੰਬ: ਏਜੰਟ ਆਪਣੇ ਪ੍ਰਦਰਸ਼ਨ ਦਾ ਵਿਸ਼ਲੇਸ਼ਣ ਕਰ ਸਕਦੇ ਹਨ ਅਤੇ ਸੁਧਾਰ ਲਈ ਖੇਤਰਾਂ ਦੀ ਪਛਾਣ ਕਰ ਸਕਦੇ ਹਨ।
ਢਾਲਣਯੋਗਤਾ: ਫੀਡਬੈਕ ਅਤੇ ਬਦਲਦੀਆਂ ਸਥਿਤੀਆਂ ਦੇ ਮੁਤਾਬਕ ਰਣਨੀਤੀਆਂ ਨੂੰ ਬਦਲ ਸਕਦੇ ਹਨ।
ਗਲਤੀ ਸਧਾਰਨ: ਸਵੈ-ਸੰਚਾਲਿਤ ਤੌਰ ਤੇ ਗਲਤੀਆਂ ਦਾ ਪਤਾ ਲਗਾ ਕੇ ਉਨ੍ਹਾਂ ਨੂੰ ਸਧਾਰ ਸਕਦੇ ਹਨ।
ਸਰੋਤ ਪ੍ਰਬੰਧਨ: ਸਮੇਂ ਅਤੇ ਕਮਪਿਊਟਿੰਗ ਤਾਕਤ ਵਰਗੇ ਸਰੋਤਾਂ ਦੀ ਵੱਧ ਤੋਂ ਵੱਧ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹਨ।

ਮੈਟਾਕੌਗਨੀਸ਼ਨ ਸ਼ਾਮਿਲ ਕਰਕੇ, ਟ੍ਰੈਵਲ ਏਜੰਟ ਹੋਰ ਵਿਆਪਕ ਅਤੇ ਸਹੀ ਯਾਤਰਾ ਸਿਫਾਰਸ਼ਾਂ ਦੇ ਸਕਦਾ ਹੈ, ਜੋ ਕੁੱਲ ਮਿਲਾ ਕੇ ਯੂਜ਼ਰ ਅਨੁਭਵ ਨੂੰ ਸੁਧਾਰਦਾ ਹੈ।

2. ਏਜੰਟਾਂ ਵਿੱਚ ਯੋਜਨਾ ਬਣਾਉਣਾ

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

ਯੋਜਨਾ ਬਣਾਉਣ ਦੇ ਤੱਤ

ਮੌਜੂਦਾ ਕੰਮ: ਕੰਮ ਨੂੰ ਸਾਫ-ਸੁਥਰਾ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ।
ਕੰਮ ਸਪੁਰਦ ਕਰਨ ਲਈ ਕਦਮ: ਕੰਮ ਨੂੰ ਮੁਹੰਦੇ ਸੰਭਾਲ ਯੋਗ ਕਦਮਾਂ ਵਿੱਚ ਵੰਡੋ।
ਲੋੜੀਂਦੇ ਸਰੋਤ: ਜ਼ਰੂਰੀ ਸਰੋਤਾਂ ਦੀ ਪਛਾਣ ਕਰੋ।
ਅਨੁਭਵ: ਯੋਜਨਾ ਬਣਾਉਣ ਲਈ ਪਿਛਲੇ ਅਨੁਭਵਾਂ ਤੋਂ ਲਾਭ ਲਵੋ।

ਉਦਾਹਰਣ: ਇੱਥੇ ਉਹ ਕਦਮ ਹਨ ਜੋ ਟ੍ਰੈਵਲ ਏਜੰਟ ਇੱਕ ਯੂਜ਼ਰ ਦੀ ਯਾਤਰਾ ਨੂੰ ਪ੍ਰਭਾਵਸ਼ੀਲ ਤਰੀਕੇ ਨਾਲ ਯੋਜਨਾ ਬਣਾਉਣ ਲਈ ਲੈਣਾ ਚਾਹੀਦਾ ਹੈ:

ਟ੍ਰੈਵਲ ਏਜੰਟ ਲਈ ਕਦਮ

ਯੂਜ਼ਰ ਦੀਆਂ ਪਸੰਦਾਂ ਇਕੱਠੀਆਂ ਕਰੋ
- ਯੂਜ਼ਰ ਤੋਂ ਉਸ ਦੀ ਯਾਤਰਾ ਦੀਆਂ ਤਾਰੀਆਂ, ਬਜਟ, ਰੁਚੀਆਂ ਅਤੇ ਖਾਸ ਮੰਗਾਂ ਬਾਰੇ ਪੁੱਛੋ।
- ਉਦਾਹਰਣ: “ਤੁਸੀਂ ਕਦੋਂ ਯਾਤਰਾ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ?” “ਤੁਹਾਡਾ ਬਜਟ ਰੇਂਜ ਕੀ ਹੈ?” “ਕੀ ਤੁਹਾਨੂੰ ਛੁੱਟੀਆਂ ਵਿੱਚ ਕਿਹੜੀਆਂ ਸਰਗਰਮੀਆਂ ਪਸੰਦ ਹਨ?”
ਜਾਣਕਾਰੀ ਇਕੱਠੀ ਕਰੋ
- ਯੂਜ਼ਰ ਦੀਆਂ ਪਸੰਦਾਂ ਦੇ ਅਧਾਰ ‘ਤੇ ਸਬੰਧਤ ਯਾਤਰਾ ਵਿਕਲਪਾਂ ਦੀ ਖੋਜ ਕਰੋ।
- ਫਲਾਈਟਾਂ: ਯੂਜ਼ਰ ਦੇ ਬਜਟ ਅਤੇ ਯਾਤਰਾ ਤਾਰੀਖਾਂ ਵਿੱਚ ਉਪਲਬਧ ਫਲਾਈਟਾਂ ਖੋਜੋ।
- ਰਹਿਣ ਸਥਾਨ: ਹੋਟਲ ਜਾਂ ਕਿਰਾਏ ਦੀਆਂ ਜਾਇਦਾਦਾਂ ਜੋ ਸਥਾਨ, ਕੀਮਤ ਅਤੇ ਸਹੂਲਤਾਂ ਵਿੱਚ ਯੂਜ਼ਰ ਦੀਆਂ ਪਸੰਦਾਂ ਨਾਲ ਮੈਚ ਕਰਦੀਆਂ ਹਨ।
- ਆਕਰਸ਼ਣ ਅਤੇ ਰੈਸਟੋਰੈਂਟਾਂ: ਲੋਕਪ੍ਰਿਯ ਆਕਰਸ਼ਣ, ਸਰਗਰਮੀਆਂ ਅਤੇ ਖਾਣ-ਪੀਣ ਵਿਕਲਪ ਜੋ ਯੂਜ਼ਰ ਦੀਆਂ ਰੁਚੀਆਂ ਨਾਲ ਮੇਲ ਖਾਂਦੇ ਹਨ।
ਸਿਫਾਰਸ਼ਾਂ ਤਿਆਰ ਕਰੋ
- ਇਕ ਵਿਅਕਤੀਗਤ ਦਿਣਚਰਿਆ ਬਣਾਓ ਜੋ ਇਕੱਠੀ ਕੀਤੀ ਜਾਣਕਾਰੀ ਪੇਸ਼ ਕਰਦਾ ਹੈ।
- ਫਲਾਈਟ ਵਿਕਲਪਾਂ, ਹੋਟਲ ਬੁਕਿੰਗਜ਼ ਅਤੇ ਸੁਝਾਏ ਗਏ ਸਰਗਰਮੀਆਂ ਵਰਗੀਆਂ ਜਾਣਕਾਰੀਆਂ ਪ੍ਰਦਾਨ ਕਰੋ, ਯਕੀਨੀ ਬਣਾਉਂਦੇ ਹੋਏ ਕਿ ਸਿਫਾਰਸ਼ਾਂ ਯੂਜ਼ਰ ਦੀਆਂ ਪਸੰਦਾਂ ਨਾਲ ਮੇਲ ਖਾਂਦੀਆਂ ਹਨ।
ਯੂਜ਼ਰ ਨੂੰ ਦਿਣਚਰਿਆ ਪੇਸ਼ ਕਰੋ
- ਯੂਜ਼ਰ ਨੂੰ ਯੋਜਿਤ ਦਿਣਚਰਿਆ ਸਾਂਝਾ ਕਰੋ ਤांकि ਉਹ ਦੇਖ ਸਕੇ।
- ਉਦਾਹਰਣ: “ਇੱਥੇ ਤੁਹਾਡੇ ਪੈਰਿਸ ਯਾਤਰਾ ਲਈ ਸੁਝਾਈ ਗਈ ਦਿਣਚਰਿਆ ਹੈ। ਇਸ ਵਿੱਚ ਫਲਾਈਟ ਵੇਰਵੇ, ਹੋਟਲ ਬੁਕਿੰਗਜ਼ ਅਤੇ ਸੁਝਾਏ ਗਏ ਸਰਗਰਮੀਆਂ ਅਤੇ ਰੈਸਟੋਰੈਂਟਾਂ ਦੀ ਸੂਚੀ ਸ਼ਾਮਿਲ ਹੈ। ਮੇਰੀ ਜਾਣਕਾਰੀ ਦਿਓ!”
ਫੀਡਬੈਕ ਇਕੱਠਾ ਕਰੋ
- ਯੂਜ਼ਰ ਤੋਂ ਪ੍ਰਸਤਾਵਿਤ ਦਿਣਚਰਿਆ ‘ਤੇ ਫੀਡਬੈਕ ਲਵੋ।
- ਉਦਾਹਰਣ: “ਤੁਹਾਨੂੰ ਫਲਾਈਟ ਵਿਕਲਪ پسند ਆਏ?” “ਕੀ ਹੋਟਲ ਤੁਹਾਡੇ ਲਾਇਕ ਹੈ?” “ਕੀ ਤੁਸੀਂ ਕੋਈ ਸਰਗਰਮੀ ਸ਼ਾਮਿਲ ਜਾਂ ਹਟਾਉਣਾ ਚਾਹੁੰਦੇ ਹੋ?”
ਫੀਡਬੈਕ ਦੇ ਅਧਾਰ ‘ਤੇ ਢਾਲੋ
- ਯੂਜ਼ਰ ਦੇ ਫੀਡਬੈਕ ਦੇ ਅਨੁਸਾਰ ਦਿਣਚਰਿਆ ਨੂੰ ਬਦਲੋ।
- ਫਲਾਈਟ, ਰਹਿਣ ਸਥਾਨ ਅਤੇ ਸਰਗਰਮੀ ਦੀਆਂ ਸਿਫਾਰਸ਼ਾਂ ਨੂੰ ਯੂਜ਼ਰ ਦੀਆਂ ਪਸੰਦਾਂ ਦੇ ਅਨੁਕੂਲ ਬਦਲਾਓ।
ਆਖਰੀ ਪੁਸ਼ਟੀ
- ਅੰਤਿਮ ਪੁਸ਼ਟੀ ਲਈ ਨਵੀਨਤਮ ਦਿਣਚਰਿਆ ਯੂਜ਼ਰ ਨੂੰ ਪੇਸ਼ ਕਰੋ।
- ਉਦਾਹਰਣ: “ਮੈਂ ਤੁਹਾਡੇ ਫੀਡਬੈਕ ਦੇ ਬਾਅਦ ਸੋਧਾਂ ਕੀਤੀਆਂ ਹਨ। ਇਹ ਨਵੀਨਤਮ ਦਿਣਚਰਿਆ ਹੈ। ਕੀ ਸਭ ਕੁਝ ਤੁਹਾਡੇ ਲਈ ਠੀਕ ਹੈ?”
ਬੁਕਿੰਗ ਅਤੇ ਪੁਸ਼ਟੀਕਰਨ
- ਜਦੋਂ ਯੂਜ਼ਰ ਦਿਣਚਰਿਆ ਨੂੰ ਮਨਜ਼ੂਰ ਕਰ ਲੈਂਦਾ ਹੈ, ਫਲਾਈਟਾਂ, ਰਹਿਣ ਸਥਾਨ ਅਤੇ ਪਹਿਲਾਂ ਤੋਂ ਯੋਜਨਾ ਬਣਾਈਆਂ ਸਰਗਰਮੀਆਂ ਦੀ ਬੁਕਿੰਗ ਕਰੋ।
- ਪੁਸ਼ਟੀਕਰਨ ਵੇਰਵੇ ਯੂਜ਼ਰ ਨੂੰ ਭੇਜੋ।
ਚਲਦੇ ਨਾਲ ਸਮਰਥਨ ਦਿਓ
- ਯਾਤਰਾ ਦੇ ਦੌਰਾਨ ਕਿਸੇ ਵੀ ਬਦਲਾਅ ਜਾਂ ਵਾਧੂ ਬੇਨਤੀਆਂ ਲਈ ਯੂਜ਼ਰ ਦੀ ਮਦਦ ਲਈ ਉਪਲਬਧ ਰਹੋ।
- ਉਦਾਹਰਣ: “ਜੇਕਰ ਤੁਹਾਨੂੰ ਯਾਤਰਾ ਦੌਰਾਨ ਹੋਰ ਮਦਦ ਦੀ ਲੋੜ ਹੋਵੇ, ਤਾਂ ਮੈਨੂੰ ਕਿਸੇ ਵੀ ਸਮੇਂ ਸੱਦਾ ਦੇ ਸਕਦੇ ਹੋ!”

ਉਦਾਹਰਣ ਇੰਟਰੈਕਸ਼ਨ

class Travel_Agent:
    def __init__(self):
        self.user_preferences = {}
        self.experience_data = []

    def gather_preferences(self, preferences):
        self.user_preferences = preferences

    def retrieve_information(self):
        flights = search_flights(self.user_preferences)
        hotels = search_hotels(self.user_preferences)
        attractions = search_attractions(self.user_preferences)
        return flights, hotels, attractions

    def generate_recommendations(self):
        flights, hotels, attractions = self.retrieve_information()
        itinerary = create_itinerary(flights, hotels, attractions)
        return itinerary

    def adjust_based_on_feedback(self, feedback):
        self.experience_data.append(feedback)
        self.user_preferences = adjust_preferences(self.user_preferences, feedback)

# ਬੂਇੰਗ ਬੇਨਤੀ ਦੇ ਅੰਦਰ ਉਦਾਹਰਨ ਵਰਤੋਂ
travel_agent = Travel_Agent()
preferences = {
    "destination": "Paris",
    "dates": "2025-04-01 to 2025-04-10",
    "budget": "moderate",
    "interests": ["museums", "cuisine"]
}
travel_agent.gather_preferences(preferences)
itinerary = travel_agent.generate_recommendations()
print("Suggested Itinerary:", itinerary)
feedback = {"liked": ["Louvre Museum"], "disliked": ["Eiffel Tower (too crowded)"]}
travel_agent.adjust_based_on_feedback(feedback)

3. ਸਹੀਕਰਣ ਰੈਗ ਸਿਸਟਮ

ਸਭ ਤੋਂ ਪਹਿਲਾਂ ਆਓ ਅਸੀਂ RAG ਟੂਲ ਅਤੇ ਪ੍ਰੀ-ਐমਪਟਿਵ ਕਾਂਟੈਕਸਟ ਲੋਡ ਵਿੱਚ ਫਰਕ ਸਮਝੀਏ।

RAG ਵਿਰੁੱਧ ਕਾਂਟੈਕਸਟ ਲੋਡਿੰਗ

ਰਿਟਰੀਵਲ-ਆਗਮੈਂਟਡ ਜੈਨਰੇਸ਼ਨ (RAG)

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

RAG ਸਿਸਟਮ ਵਿੱਚ, ਏਜੰਟ ਨੋਲਿਜ਼ ਬੇਸ ਤੋਂ ਲੋੜੀਂਦਾ ਜਾਣਕਾਰੀਆਂ ਲਿਆਉਂਦਾ ਹੈ ਅਤੇ ਉਨ੍ਹਾਂ ਦੀ ਵਰਤੋਂ ਹੋਂਦ ਬਹੁਤਰੇ ਸਬੰਧਤ ਕਾਰਵਾਈਆਂ ਜਾਂ ਜਵਾਬ ਜਨਰੇਟ ਕਰਨ ਲਈ ਕਰਦਾ ਹੈ।

ਸਹੀਕਰਣ RAG ਦ੍ਰਿਸ਼ਟੀਕੋਨ

ਸਹੀਕਰਣ RAG ਦ੍ਰਿਸ਼ਟੀਕੋਨ RAG ਤਕਨੀਕਾਂ ਦਾ ਉਪਯੋਗ ਕਰਕੇ ਏਆਈ ਏਜੰਟਾਂ ਦੀ ਗਲਤੀਆਂ ਨੂੰ ਠੀਕ ਕਰਨ ਅਤੇ ਸਹੀਅਤ ਵਿੱਚ ਸੁਧਾਰ ਕਰਨ ‘ਤੇ ਧਿਆਨ ਕੇਂਦਰਿਤ ਕਰਦਾ ਹੈ। ਇਸ ਵਿੱਚ ਸ਼ਾਮਿਲ ਹੈ:

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

ਉਦਾਹਰਣ: ਖੋਜ ਏਜੰਟ ਵਿੱਚ ਸਹੀਕਰਣ RAG

ਇੱਕ ਖੋਜ ਏਜੰਟ ਦੀ ਸੋਚੋ ਜੋ ਯੂਜ਼ਰ ਦੇ ਪ੍ਰਸ਼ਨਾਂ ਦੇ ਜਵਾਬ ਦੇਣ ਲਈ ਵੈੱਬ ਤੋਂ ਜਾਣਕਾਰੀ ਲਿਆਉਂਦਾ ਹੈ। ਸਹੀਕਰਣ RAG ਦ੍ਰਿਸ਼ਟੀਕੋਨ ਸ਼ਾਮਿਲ ਕਰ ਸਕਦਾ ਹੈ:

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

ਟ੍ਰੈਵਲ ਏਜੰਟ ਵਿੱਚ ਸਹੀਕਰਣ RAG

ਸਹੀਕਰਣ RAG (ਰਿਟਰੀਵਲ-ਆਗਮੈਂਟਡ ਜੈਨਰੇਸ਼ਨ) ਏਆਈ ਦੀ ਸਮਰੱਥਾ ਨੂੰ ਜਾਣਕਾਰੀ ਲਿਆਉਣ ਅਤੇ ਜਨਰੇਟ ਕਰਨ ਨਾਲ ਨਾਲ ਗਲਤੀਆਂ ਨੂੰ ਠੀਕ ਕਰਨ ਵਿੱਚ ਬਹਿਤਰੀ ਲਿਆਉਂਦਾ ਹੈ। ਆਓ ਵੇਖੀਏ ਕਿ ਟ੍ਰੈਵਲ ਏਜੰਟ ਸਹੀਕਰਣ RAG ਦ੍ਰਿਸ਼ਟੀਕੋਨ ਦਿਆਰ ਕਰਕੇ ਕਿਵੇਂ ਹੋਰ ਸਹੀ ਅਤੇ ਪ੍ਰਸੰਗਿਕ ਯਾਤਰਾ ਸਿਫਾਰਸ਼ਾਂ ਦੇ ਸਕਦਾ ਹੈ।

ਇਸ ਵਿੱਚ ਸ਼ਾਮਿਲ ਹੈ:

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

ਟ੍ਰੈਵਲ ਏਜੰਟ ਵਿੱਚ ਸਹੀਕਰਣ RAG ਲਾਗੂ ਕਰਨ ਲਈ ਕਦਮ

ਆਰੰਭਕ ਯੂਜ਼ਰ ਇੰਟਰਐਕਸ਼ਨ
- ਟ੍ਰੈਵਲ ਏਜੰਟ ਯੂਜ਼ਰ ਤੋਂ ਸ਼ੁਰੂਆਤੀ ਪਸੰਦਾਂ ਇਕੱਠੀਆਂ ਕਰਦਾ ਹੈ, ਜਿਵੇਂ ਕਿ ਗੰਤੀ, ਯਾਤਰਾ ਤਾਰਖ, ਬਜਟ ਅਤੇ ਰੁਚੀਆਂ।
- ਉਦਾਹਰਣ:
```
preferences = {
    "destination": "Paris",
    "dates": "2025-04-01 to 2025-04-10",
    "budget": "moderate",
    "interests": ["museums", "cuisine"]
}
```
ਜਾਣਕਾਰੀ ਦੀ ਪ੍ਰਾਪਤੀ
- ਯੂਜ਼ਰ ਦੀਆਂ ਪਸੰਦਾਂ ਦੇ ਅਧਾਰ ‘ਤੇ ਫਲਾਈਟਾਂ, ਰਹਿਣ ਸਥਾਨ, ਆਕਰਸ਼ਣ ਅਤੇ ਰੈਸਟੋਰੈਂਟ ਬਾਰੇ ਜਾਣਕਾਰੀ ਲਿਆਉਣਾ।
- ਉਦਾਹਰਣ:
```
flights = search_flights(preferences)
hotels = search_hotels(preferences)
attractions = search_attractions(preferences)
```
ਆਰੰਭਕ ਸਿਫਾਰਸ਼ਾਂ ਤਿਆਰ ਕਰਨਾ
- ਲਿਆਈ ਗਈ ਜਾਣਕਾਰੀ ਨਾਲ ਵਿਅਕਤੀਗਤ ਦਿਣਚਰਿਆ ਬਣਾਉਣਾ।
- ਉਦਾਹਰਣ:
```
itinerary = create_itinerary(flights, hotels, attractions)
print("Suggested Itinerary:", itinerary)
```
ਯੂਜ਼ਰ ਫੀਡਬੈਕ ਇਕੱਠਾ ਕਰਨਾ
- ਯੂਜ਼ਰ ਤੋਂ ਆਰੰਭਕ ਸਿਫਾਰਸ਼ਾਂ ‘ਤੇ ਫੀਡਬੈਕ ਲੈਣਾ।
- ਉਦਾਹਰਣ:
```
feedback = {
    "liked": ["Louvre Museum"],
    "disliked": ["Eiffel Tower (too crowded)"]
}
```
ਸਹੀਕਰਣ RAG ਪ੍ਰਕਿਰਿਆ
- ਪ੍ਰਾਪੰਟਿੰਗ ਤਕਨੀਕ: ਯੂਜ਼ਰ ਫੀਡਬੈਕ ਦੇ ਅਧਾਰ ‘ਤੇ ਨਵੇਂ ਖੋਜ ਪ੍ਰਸ਼ਨ ਤਿਆਰ ਕਰਨਾ।
  - ਉਦਾਹਰਣ:
    if "disliked" in feedback: preferences["avoid"] = feedback["disliked"]
- ਟੂਲ: ਨਵੇਂ ਖੋਜ ਨਤੀਜਿਆਂ ਨੂੰ ਰੈਂਕ ਅਤੇ ਫਿਲਟਰ ਕਰਨ ਲਈ ਐਲਗੋਰਿਥਮ ਦੀ ਵਰਤੋਂ, ਲੋਕਾਂ ਦੀ ਪ੍ਰਸੰਗਿਕਤਾ ‘ਤੇ ਧਿਆਨ ਦੇਣਾ।
  - ਉਦਾਹਰਣ:
    new_attractions = search_attractions(preferences) new_itinerary = create_itinerary(flights, hotels, new_attractions) print("Updated Itinerary:", new_itinerary)
- ਮੁਲਾਂਕਣ: ਯੂਜ਼ਰ ਫੀਡਬੈਕ ਦਾ ਵਿਸ਼ਲੇਸ਼ਣ ਕਰਕੇ ਸਿਫਾਰਸ਼ਾਂ ਦੀ ਪ੍ਰਸੰਗਿਕਤਾ ਅਤੇ ਸਹੀਅਤ ਦੀ ਲਗਾਤਾਰ ਪੜਤਾਲ ਅਤੇ ਜਰੂਰੀ ਸੋਧ ਕਰਨਾ।
  - ਉਦਾਹਰਣ:
    def adjust_preferences(preferences, feedback): if "liked" in feedback: preferences["favorites"] = feedback["liked"] if "disliked" in feedback: preferences["avoid"] = feedback["disliked"] return preferences preferences = adjust_preferences(preferences, feedback)

ਅਮਲੀ ਉਦਾਹਰਣ

ਇਹ ਰਹਾ ਟ੍ਰੈਵਲ ਏਜੰਟ ਵਿੱਚ ਸਹੀਕਰਣ RAG ਦ੍ਰਿਸ਼ਟੀਕੋਨ ਸ਼ਾਮਿਲ ਕਰਨ ਦੀ ਇੱਕ ਸਧਾਰਨ ਪਾਇਥਨ ਕੋਡ ਉਦਾਹਰਣ:

class Travel_Agent:
    def __init__(self):
        self.user_preferences = {}
        self.experience_data = []

    def gather_preferences(self, preferences):
        self.user_preferences = preferences

    def retrieve_information(self):
        flights = search_flights(self.user_preferences)
        hotels = search_hotels(self.user_preferences)
        attractions = search_attractions(self.user_preferences)
        return flights, hotels, attractions

    def generate_recommendations(self):
        flights, hotels, attractions = self.retrieve_information()
        itinerary = create_itinerary(flights, hotels, attractions)
        return itinerary

    def adjust_based_on_feedback(self, feedback):
        self.experience_data.append(feedback)
        self.user_preferences = adjust_preferences(self.user_preferences, feedback)
        new_itinerary = self.generate_recommendations()
        return new_itinerary

# ਉਦਾਹਰਨ ਵਰਤੋਂ
travel_agent = Travel_Agent()
preferences = {
    "destination": "Paris",
    "dates": "2025-04-01 to 2025-04-10",
    "budget": "moderate",
    "interests": ["museums", "cuisine"]
}
travel_agent.gather_preferences(preferences)
itinerary = travel_agent.generate_recommendations()
print("Suggested Itinerary:", itinerary)
feedback = {"liked": ["Louvre Museum"], "disliked": ["Eiffel Tower (too crowded)"]}
new_itinerary = travel_agent.adjust_based_on_feedback(feedback)
print("Updated Itinerary:", new_itinerary)

ਪ੍ਰੀ-ਐਮਪਟਿਵ ਕਾਂਟੈਕਸਟ ਲੋਡ

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

ਇੱਥੇ ਪਾਇਥਨ ਵਿੱਚ ਇੱਕ ਟ੍ਰੈਵਲ ਏਜੈਂਟ ਐਪਲੀਕੇਸ਼ਨ ਲਈ ਪ੍ਰੀ-ਇਮਪਟੀਵ ਸੰਦਰਭ ਲੋਡ ਕਿਵੇਂ ਦਿਖਾਈ ਦੇ ਸਕਦੀ ਹੈ, ਉਸਦਾ ਸਧਾਰਣ ਉਦਾਹਰਨ ਦਿੱਤਾ ਗਿਆ ਹੈ:

class TravelAgent:
    def __init__(self):
        # ਲੋਕਪ੍ਰਿਯ ਮੰਜਿਲਾਂ ਅਤੇ ਉਨ੍ਹਾਂ ਦੀ ਜਾਣਕਾਰੀ ਨੂੰ ਪਹਿਲਾਂ ਲੋਡ ਕਰੋ
        self.context = {
            "Paris": {"country": "France", "currency": "Euro", "language": "French", "attractions": ["Eiffel Tower", "Louvre Museum"]},
            "Tokyo": {"country": "Japan", "currency": "Yen", "language": "Japanese", "attractions": ["Tokyo Tower", "Shibuya Crossing"]},
            "New York": {"country": "USA", "currency": "Dollar", "language": "English", "attractions": ["Statue of Liberty", "Times Square"]},
            "Sydney": {"country": "Australia", "currency": "Dollar", "language": "English", "attractions": ["Sydney Opera House", "Bondi Beach"]}
        }

    def get_destination_info(self, destination):
        # ਪਹਿਲਾਂ ਲੋਡ ਕੀਤੇ ਸੰਦਰਭ ਤੋਂ ਮੰਜਿਲ ਦੀ ਜਾਣਕਾਰੀ ਲਵੋ
        info = self.context.get(destination)
        if info:
            return f"{destination}:\nCountry: {info['country']}\nCurrency: {info['currency']}\nLanguage: {info['language']}\nAttractions: {', '.join(info['attractions'])}"
        else:
            return f"Sorry, we don't have information on {destination}."

# ਉਦਾਹਰਨ ਵਜੋਂ ਵਰਤੋਂ
travel_agent = TravelAgent()
print(travel_agent.get_destination_info("Paris"))
print(travel_agent.get_destination_info("Tokyo"))

ਵਿਆਖਿਆ

ਆਰੰਭਿਕੀਕਰਨ (__init__ ਮੈਥਡ): TravelAgent ਕਲਾਸ ਇੱਕ ਡਿਕਸ਼ਨਰੀ ਨੂੰ ਪਹਿਲਾਂ ਹੀ ਲੋਡ ਕਰਦੀ ਹੈ ਜਿਸ ਵਿੱਚ ਲੋਕਪ੍ਰਿਯ ਮੰਜ਼ਿਲਾਂ ਬਾਰੇ ਜਾਣਕਾਰੀ ਹੁੰਦੀ ਹੈ ਜਿਵੇਂ ਕਿ ਪੈਰਿਸ, ਟੋਕੀਓ, ਨਿਊਯਾਰਕ, ਅਤੇ ਸਿਡਨੀ। ਇਸ ਡਿਕਸ਼ਨਰੀ ਵਿੱਚ ਹਰ ਮੰਜ਼ਿਲ ਲਈ ਦੇਸ਼, ਮੁਦਰਾ, ਭਾਸ਼ਾ, ਅਤੇ ਮੁੱਖ ਆਕਰਸ਼ਣ ਵਰਗੀ ਵਿਸਥਾਰਿਤ ਜਾਣਕਾਰੀ ਸ਼ਾਮਲ ਹੁੰਦੀ ਹੈ।
ਜਾਣਕਾਰੀ ਪ੍ਰਾਪਤ ਕਰਨਾ (get_destination_info ਮੈਥਡ): ਜਦੋਂ ਕੋਈ ਯੂਜ਼ਰ ਕਿਸੇ ਨਿਰਧਾਰਤ ਮੰਜ਼ਿਲ ਬਾਰੇ ਪੁੱਛਦਾ ਹੈ, get_destination_info ਮੈਥਡ ਪਹਿਲਾਂ ਹੀ ਲੋਡ ਕੀਤੀ ਗਈ ਸੰਦਰਭ ਡਿਕਸ਼ਨਰੀ ਵਿੱਚੋਂ ਸੰਬੰਧਿਤ ਜਾਣਕਾਰੀ ਲੈ ਆਉਂਦੀ ਹੈ।

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

ਲਕਸ਼ ਦੇ ਨਾਲ ਯੋਜ਼ਨਾ ਦੀ ਸ਼ੁਰੂਆਤ ਕਰਨਾ ਅਤੇ ਫਿਰ ਦੁਹਰਾਉਣਾ

ਲਕਸ਼ ਦੇ ਨਾਲ ਯੋਜ਼ਨਾ ਦੀ ਸ਼ੁਰੂਆਤ ਦਾ ਮਤਲਬ ਹੈ ਸਾਫ਼ ਉਦੇਸ਼ ਜਾਂ ਨਿਸ਼ਾਨਾ ਰੱਖ ਕੇ ਸ਼ੁਰੂ ਕਰਨਾ। ਇਹ ਲਕਸ਼ ਪਹਿਲਾਂ ਹੀ ਨਿਰਧਾਰਤ ਕਰਨ ਨਾਲ, ਮਾਡਲ ਇਸਨੂੰ ਸਾਰੇ ਦੁਹਰਾਉਣ ਦੇ ਇਰਾਦੇ ਵਿਚ ਪ੍ਰਧਾਨ ਸਿਧਾਂਤ ਵਜੋਂ ਵਰਤ ਸਕਦਾ ਹੈ। ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ ਹਰ ਇਕ ਦੁਹਰਾਉਣ ਵਿੱਚ ਚਾਹੀਦੀ ਨਤੀਜੇ ਦੀ ਹੋਰ ਨੇੜਤਾ ਆਉਂਦੀ ਹੈ, ਇਸ ਕਾਰਜ ਨੂੰ অধিক ਸੁਚੱਜਾ ਅਤੇ ਕੇਂਦਰਿਤ ਬਣਾਉਂਦਾ ਹੈ।

ਇੱਥੇ ਇੱਕ ਉਦਾਹਰਨ ਹੈ ਕਿ ਤੁਸੀਂ ਟ੍ਰੈਵਲ ਏਜੈਂਟ ਲਈ ਲਕਸ਼ ਦੇ ਨਾਲ ਯੋਜ਼ਨਾ ਨੂੰ ਕਿਵੇਂ ਸ਼ੁਰੂ ਕਰਦੇ ਹੋ ਅਤੇ ਫਿਰ ਦੁਹਰਾਉਂਦੇ ਹੋ, ਪਾਇਥਨ ਵਿੱਚ:

ਸਥਿਤੀ

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

ਕਦਮ

ਗਾਹਕ ਦੀਆਂ ਪਸੰਦਾਂ ਅਤੇ ਬਜਟ ਨੂੰ ਨਿਰਧਾਰਤ ਕਰੋ।
ਇਹਨਾਂ ਪਸੰਦਾਂ ਦੇ ਆਧਾਰ ‘ਤੇ ਸ਼ੁਰੂਆਤੀ ਯੋਜ਼ਨਾ ਸ਼ੁਰੂ ਕਰੋ।
ਯੋਜ਼ਨਾ ਨੂੰ ਸੁਧਾਰਨ ਲਈ ਦੁਹਰਾਓ, ਗਾਹਕ ਦੀ ਤੁਹਾਨੂੰਸ ਪ੍ਰਾਪਤੀ ਲਈ ਅਨੁਕੂਲ ਬਣਾਉ।

ਪਾਇਥਨ ਕੋਡ

class TravelAgent:
    def __init__(self, destinations):
        self.destinations = destinations

    def bootstrap_plan(self, preferences, budget):
        plan = []
        total_cost = 0

        for destination in self.destinations:
            if total_cost + destination['cost'] <= budget and self.match_preferences(destination, preferences):
                plan.append(destination)
                total_cost += destination['cost']

        return plan

    def match_preferences(self, destination, preferences):
        for key, value in preferences.items():
            if destination.get(key) != value:
                return False
        return True

    def iterate_plan(self, plan, preferences, budget):
        for i in range(len(plan)):
            for destination in self.destinations:
                if destination not in plan and self.match_preferences(destination, preferences) and self.calculate_cost(plan, destination) <= budget:
                    plan[i] = destination
                    break
        return plan

    def calculate_cost(self, plan, new_destination):
        return sum(destination['cost'] for destination in plan) + new_destination['cost']

# ਉਦਾਹਰਣ ਵਿਆਖਿਆ
destinations = [
    {"name": "Paris", "cost": 1000, "activity": "sightseeing"},
    {"name": "Tokyo", "cost": 1200, "activity": "shopping"},
    {"name": "New York", "cost": 900, "activity": "sightseeing"},
    {"name": "Sydney", "cost": 1100, "activity": "beach"},
]

preferences = {"activity": "sightseeing"}
budget = 2000

travel_agent = TravelAgent(destinations)
initial_plan = travel_agent.bootstrap_plan(preferences, budget)
print("Initial Plan:", initial_plan)

refined_plan = travel_agent.iterate_plan(initial_plan, preferences, budget)
print("Refined Plan:", refined_plan)

ਕੋਡ ਵਿਆਖਿਆ

ਆਰੰਭਿਕੀਕਰਨ (__init__ ਮੈਥਡ): TravelAgent ਕਲਾਸ ਨੂੰ ਸੰਭਵ ਮੰਜ਼ਿਲਾਂ ਦੀ ਸੂਚੀ ਨਾਲ ਆਰੰਭ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਜਿਹਨਾਂ ਦੇ ਨਾਮ, ਲਾਗਤ, ਅਤੇ ਗਤੀਵਿਧੀ ਪ੍ਰਕਾਰ ਵਰਗੇ ਲੱਛਣ ਹੁੰਦੇ ਹਨ।
ਯੋਜ਼ਨਾ ਦੀ ਸ਼ੁਰੂਆਤ (bootstrap_plan ਮੈਥਡ): ਇਹ ਮੈਥਡ ਗਾਹਕ ਦੀਆਂ ਪਸੰਦਾਂ ਅਤੇ ਬਜਟ ਉੱਤੇ ਅਧਾਰਿਤ ਸ਼ੁਰੂਆਤੀ ਯੋਜ਼ਨਾ ਬਣਾਉਂਦਾ ਹੈ। ਇਹ ਮੰਜ਼ਿਲਾਂ ਦੀ ਸੂਚੀ ਵਿੱਚੋਂ ਉਹਨਾਂ ਨੂੰ ਜੋੜਦਾ ਹੈ ਜੋ ਗਾਹਕ ਦੀ ਪਸੰਦ ਨਾਲ ਮਿਲਦੀਆਂ ਹਨ ਅਤੇ ਬਜਟ ਵਿੱਚ ਫਿਟ ਹੁੰਦੀਆਂ ਹਨ।
ਪਸੰਦਾਂ ਦਾ ਮਿਲਾਪ (match_preferences ਮੈਥਡ): ਇਹ ਮੈਥਡ ਜਾਂਚ ਕਰਦਾ ਹੈ ਕਿ ਕੀ ਕੋਈ ਮੰਜ਼ਿਲ ਗਾਹਕ ਦੀਆਂ ਪਸੰਦਾਂ ਨਾਲ ਮਿਲਦੀ ਹੈ।
ਯੋਜ਼ਨਾ ਨੂੰ ਦੁਹਰਾਉਣਾ (iterate_plan ਮੈਥਡ): ਇਹ ਮੈਥਡ ਸ਼ੁਰੂਆਤੀ ਯੋਜ਼ਨਾ ਨੂੰ ਸੁਧਾਰਦਾ ਹੈ ਜੋ ਹਰ ਮੰਜ਼ਿਲ ਨੂੰ ਵਧੀਆ ਮਿਲਾਪ ਵਾਲੀ ਮੰਜ਼ਿਲ ਦੇ ਨਾਲ ਬਦਲ ਕੇ, ਗਾਹਕ ਦੀਆਂ ਪਸੰਦਾਂ ਅਤੇ ਬਜਟ ਸੀਮਾਵਾਂ ਦਾ ਧਿਆਨ ਰੱਖ ਕੇ।
ਲਾਗਤ ਦੀ ਗਣਨਾ (calculate_cost ਮੈਥਡ): ਇਹ ਮੈਥਡ ਮੌਜੂਦਾ ਯੋਜ਼ਨਾ ਦੀ ਕੁੱਲ ਲਾਗਤ ਦੀ ਗਣਨਾ ਕਰਦਾ ਹੈ, ਜਿਸ ਵਿੱਚ ਕੋਈ ਸੰਭਾਵੀ ਨਵੀਂ ਮੰਜ਼ਿਲ ਵੀ ਸ਼ਾਮਲ ਹੈ।

ਉਦਾਹਰਨ ਵਰਤੋਂ

ਸ਼ੁਰੂਆਤੀ ਯੋਜ਼ਨਾ: ਟ੍ਰੈਵਲ ਏਜੈਂਟ ਗਾਹਕ ਦੀਆਂ ਸੈਰ-ਸਪਾਟੇ ਦੀਆਂ ਪਸੰਦਾਂ ਅਤੇ $2000 ਦੇ ਬਜਟ ਦੇ ਆਧਾਰ ‘ਤੇ ਇੱਕ ਸ਼ੁਰੂਆਤੀ ਯੋਜ਼ਨਾ ਬਣਾਉਂਦਾ ਹੈ।
ਸੋਧੀ ਗਈ ਯੋਜ਼ਨਾ: ਟ੍ਰੈਵਲ ਏਜੈਂਟ ਯੋਜ਼ਨਾ ਨੂੰ ਦੁਹਰਾਉਂਦਾ ਹੈ, ਗਾਹਕ ਦੀਆਂ ਪਸੰਦਾਂ ਅਤੇ ਬਜਟ ਲਈ ਇਸਨੂੰ ਸੰਪੂਰਨ ਕਰਦਾ ਹੈ।

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

ਰੀ-ਰੈਂਕਿੰਗ ਅਤੇ ਸਕੋਰਿੰਗ ਲਈ LLM ਦਾ ਲਾਭ ਉਠਾਉਣਾ

ਵੱਡੇ ਭਾਸ਼ਾਈ ਮਾਡਲ (LLMs) ਨੂੰ ਰੀ-ਰੈਂਕਿੰਗ ਅਤੇ ਸਕੋਰਿੰਗ ਲਈ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ, ਜਿੱਥੇ ਇਹ ਪ੍ਰਾਪਤ ਦਸਤਾਵੇਜ਼ਾਂ ਜਾਂ ਬਣਾਏ ਜਾਏ ਜਵਾਬਾਂ ਦੀ ਪ੍ਰਸੰਗਿਕਤਾ ਅਤੇ ਗੁਣਵੱਤਾ ਦੀ ਮੁਲਾਂਕਣ ਕਰਦਾ ਹੈ। ਇਹ ਇਸ ਤਰ੍ਹਾਂ ਕੰਮ ਕਰਦਾ ਹੈ:

ਪ੍ਰਾਪਤੀ: ਸ਼ੁਰੂਆਤੀ ਕਦਮ ਵਿੱਚ ਕੋਈ ਪੁੱਛਤਾਛ ਦੇ ਆਧਾਰ ਤੇ ਉਮੀਦਵਾਰ ਦਸਤਾਵੇਜ਼ ਜਾਂ ਜਵਾਬ ਪ੍ਰਾਪਤ ਕੀਤੇ ਜਾਂਦੇ ਹਨ।

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

ਸਕੋਰਿੰਗ: LLM ਹਰ ਉਮੀਦਵਾਰ ਨੂੰ ਸਕੋਰ ਸੌਂਪਦਾ ਹੈ, ਜੋ ਉਸਦੀ ਪ੍ਰਸੰਗਿਕਤਾ ਅਤੇ ਗੁਣਵੱਤਾ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ। ਇਹ ਸਹੀ ਜਵਾਬ ਜਾਂ ਦਸਤਾਵੇਜ਼ ਚੁਣਨ ਵਿੱਚ ਮਦਦ ਕਰਦਾ ਹੈ।

LLM ਨੂੰ ਰੀ-ਰੈਂਕਿੰਗ ਅਤੇ ਸਕੋਰਿੰਗ ਲਈ ਵਰਤ ਕੇ, ਸਿਸਟਮ ਹੋਰ ਸਹੀ ਅਤੇ ਸੰਦਰਭਿਕ ਜਾਣਕਾਰੀ ਪ੍ਰਦਾਨ ਕਰ ਸਕਦਾ ਹੈ, ਜੋ ਸਮੂਹਿਕ ਯੂਜ਼ਰ ਅਨੁਭਵ ਨੂੰ ਸੁਧਾਰਦਾ ਹੈ।

ਇੱਥੇ ਇੱਕ ਉਦਾਹਰਨ ਹੈ ਕਿ ਕਿਸ ਤਰ੍ਹਾਂ ਇੱਕ ਟ੍ਰੈਵਲ ਏਜੈਂਟ ਪਾਇਥਨ ਵਿੱਚ ਯੂਜ਼ਰ ਦੀਆਂ ਪਸੰਦਾਂ ਦੇ ਆਧਾਰ ਤੇ ਮੰਜ਼ਿਲਾਂ ਨੂੰ ਰੀ-ਰੈਂਕ ਅਤੇ ਸਕੋਰ ਕਰਨ ਲਈ ਵੱਡੇ ਭਾਸ਼ਾ ਮਾਡਲ (LLM) ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦਾ ਹੈ:

ਸਥਿਤੀ - ਪਸੰਦਾਂ ਅਧਾਰਿਤ ਯਾਤਰਾ

ਇੱਕ ਟ੍ਰੈਵਲ ਏਜੈਂਟ ਗਾਹਕ ਨੂੰ ਉਹ ਮੰਜ਼ਿਲਾਂ ਸੁਝਾਉਣਾ ਚਾਹੁੰਦਾ ਹੈ ਜੋ ਉਹਦੀ ਪਸੰਦਾਂ ਅਨੁਸਾਰ ਬਹੁਤ ਚੰਗੀਆਂ ਹਨ। LLM ਇਹ ਮੰਜ਼ਿਲਾਂ ਨੂੰ ਮੁੜ ਕ੍ਰਮ ਵਿੱਚ ਲਿਆਉਣ ਅਤੇ ਸਕੋਰ ਕਰਨ ਵਿੱਚ ਮਦਦ ਕਰੇਗਾ ਤਾਂ ਜੋ ਸਭ ਤੋਂ ਪ੍ਰਸੰਗਿਕ ਵਿਕਲਪ ਪੇਸ਼ ਕੀਤੇ ਜਾਣ।

ਕਦਮ:

ਯੂਜ਼ਰ ਦੀਆਂ ਪਸੰਦਾਂ ਇਕੱਠੀਆਂ ਕਰੋ।
ਸੰਭਵ ਟ੍ਰੈਵਲ ਮੰਜ਼ਿਲਾਂ ਦੀ ਸੂਚੀ ਪ੍ਰਾਪਤ ਕਰੋ।
ਯੂਜ਼ਰ ਦੀਆਂ ਪਸੰਦਾਂ ਦੇ ਆਧਾਰ ਤੇ LLM ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਮੰਜ਼ਿਲਾਂ ਨੂੰ ਰੀ-ਰੈਂਕ ਅਤੇ ਸਕੋਰ ਕਰੋ।

ਇੱਥੇ ਪਿਛਲੇ ਉਦਾਹਰਨ ਨੂੰ ਐਜ਼ੂਰ ਓਪਨਏਆਈ ਸਰਵਿਸ ਨਾਲ ਵਰਤਣ ਲਈ ਕਿਵੇਂ ਅੱਪਡੇਟ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ:

ਲੋੜੀਂਦੇ ਗੁਣ

ਤੁਹਾਡੇ ਕੋਲ ਐਜ਼ੂਰ ਸਬਸਕ੍ਰਿਪਸ਼ਨ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ।
ਇੱਕ ਐਜ਼ੂਰ ਓਪਨਏਆਈ ਰਿਸੋਰਸ ਬਣਾਓ ਅਤੇ ਆਪਣੀ API ਕੀ ਪ੍ਰਾਪਤ ਕਰੋ।

ਉਦਾਹਰਨ ਪਾਇਥਨ ਕੋਡ

import requests
import json

class TravelAgent:
    def __init__(self, destinations):
        self.destinations = destinations

    def get_recommendations(self, preferences, api_key, endpoint):
        # ਐਜ਼ਰ ਓਪਨਏਆਈ ਲਈ ਇੱਕ ਪ੍ਰਾਂਪਟ ਬਣਾਓ
        prompt = self.generate_prompt(preferences)
        
        # ਬੇਨਤੀ ਲਈ ਹੈਡਰ ਅਤੇ ਡੇਟਾ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ
        headers = {
            'Content-Type': 'application/json',
            'Authorization': f'Bearer {api_key}'
        }
        payload = {
            "prompt": prompt,
            "max_tokens": 150,
            "temperature": 0.7
        }
        
        # ਦੁਬਾਰਾ ਰੈਂਕਿੰਗ ਅਤੇ ਸਕੋਰ ਕੀਤੇ ਗਏ ਮੰਜ਼ਿਲਾਂ ਨੂੰ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਐਜ਼ਰ ਓਪਨਏਆਈ ਏਪੀਆਈ ਨੂੰ ਕਾਲ ਕਰੋ
        response = requests.post(endpoint, headers=headers, json=payload)
        response_data = response.json()
        
        # ਸਿਫਾਰਿਸ਼ਾਂ ਨੂੰ ਕੱਢੋ ਅਤੇ ਵਾਪਸ ਕਰੋ
        recommendations = response_data['choices'][0]['text'].strip().split('\n')
        return recommendations

    def generate_prompt(self, preferences):
        prompt = "Here are the travel destinations ranked and scored based on the following user preferences:\n"
        for key, value in preferences.items():
            prompt += f"{key}: {value}\n"
        prompt += "\nDestinations:\n"
        for destination in self.destinations:
            prompt += f"- {destination['name']}: {destination['description']}\n"
        return prompt

# ਉਦਾਹਰਣ ਵਰਤੋਂ
destinations = [
    {"name": "Paris", "description": "City of lights, known for its art, fashion, and culture."},
    {"name": "Tokyo", "description": "Vibrant city, famous for its modernity and traditional temples."},
    {"name": "New York", "description": "The city that never sleeps, with iconic landmarks and diverse culture."},
    {"name": "Sydney", "description": "Beautiful harbour city, known for its opera house and stunning beaches."},
]

preferences = {"activity": "sightseeing", "culture": "diverse"}
api_key = 'your_azure_openai_api_key'
endpoint = 'https://your-endpoint.com/openai/deployments/your-deployment-name/completions?api-version=2022-12-01'

travel_agent = TravelAgent(destinations)
recommendations = travel_agent.get_recommendations(preferences, api_key, endpoint)
print("Recommended Destinations:")
for rec in recommendations:
    print(rec)

ਕੋਡ ਵਿਆਖਿਆ - ਪਸੰਦ ਬੁੱਕਰ

ਆਰੰਭਿਕੀਕਰਨ: TravelAgent ਕਲਾਸ ਨੂੰ ਸੰਭਵ ਟ੍ਰੈਵਲ ਮੰਜ਼ਿਲਾਂ ਦੀ ਸੂਚੀ ਨਾਲ ਆਰੰਭ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਹਰ ਇਕ ਦੇ ਨਾਮ ਅਤੇ ਵਰਣਨ ਸਮੇਤ ਲੱਛਣ ਹਨ।
ਸਿਫਾਰਸ਼ਾਂ ਪ੍ਰਾਪਤ ਕਰਨਾ (get_recommendations ਮੈਥਡ): ਇਹ ਮੈਥਡ ਯੂਜ਼ਰ ਦੀਆਂ ਪਸੰਦਾਂ ਦੇ ਆਧਾਰ ‘ਤੇ ਐਜ਼ੂਰ ਓਪਨਏਆਈ ਸਰਵਿਸ ਲਈ ਪ੍ਰਾਂਪਟ ਬਣਾਉਂਦਾ ਹੈ ਅਤੇ ਐਜ਼ੂਰ ਓਪਨਏਆਈ API ਨੂੰ HTTP POST ਰਿਕਵੈਸਟ ਭੇਜਦਾ ਹੈ ਤਾਂ ਜੋ ਮੰਜ਼ਿਲਾਂ ਨੂੰ ਮੁੜ ਕ੍ਰਮ ਵਿੱਚ ਲਿਆਇਆ ਜਾਵੇ ਅਤੇ ਸਕੋਰ ਕੀਤਾ ਜਾਵੇ।
ਪ੍ਰਾਂਪਟ ਬਣਾਉਣਾ (generate_prompt ਮੈਥਡ): ਇਹ ਮੈਥਡ ਐਜ਼ੂਰ ਓਪਨਏਆਈ ਲਈ ਪ੍ਰਾਂਪਟ ਤਿਆਰ ਕਰਦਾ ਹੈ, ਜਿਸ ਵਿੱਚ ਯੂਜ਼ਰ ਦੀਆਂ ਪਸੰਦਾਂ ਅਤੇ ਮੰਜ਼ਿਲਾਂ ਦੀ ਸੂਚੀ ਹੁੰਦੀ ਹੈ। ਇਹ ਪ੍ਰਾਂਪਟ ਮਾਡਲ ਨੂੰ ਦਿਸ਼ਾ ਦਿੰਦਾ ਹੈ ਕਿ ਦਿੱਤੀ ਗਈ ਪਸੰਦਾਂ ਅਨੁਸਾਰ ਮੰਜ਼ਿਲਾਂ ਨੂੰ ਮੁੜ ਕ੍ਰਮ ਵਿੱਚ ਲਿਆਉਣ ਅਤੇ ਸਕੋਰ ਕਰਨ ਲਈ।
API ਕਾਲ: requests ਲਾਇਬ੍ਰੇਰੀ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਐਜ਼ੂਰ ਓਪਨਏਆਈ API ਐਂਡਪੋਇੰਟ ਨੂੰ HTTP POST ਰਿਕਵੈਸਟ ਭੇਜੀ ਜਾਂਦੀ ਹੈ। ਜਵਾਬ ਵਿੱਚ ਮੁੜ ਕ੍ਰਮਿਤ ਅਤੇ ਸਕੋਰ ਕੀਤੀਆਂ ਮੰਜ਼ਿਲਾਂ ਹੁੰਦੀਆਂ ਹਨ।
ਉਦਾਹਰਨ ਵਰਤੋਂ: ਟ੍ਰੈਵਲ ਏਜੈਂਟ ਯੂਜ਼ਰ ਦੀਆਂ ਪਸੰਦਾਂ (ਉਦਾਹਰਨ ਲਈ, ਸੈਰ ਕਰਨ ਅਤੇ ਵਿਭਿੰਨ ਸੰਸਕ੍ਰਿਤੀਆਂ ਵਿਚ ਰੁਚੀ) ਇਕੱਠੀਆਂ ਕਰਦਾ ਹੈ ਅਤੇ ਐਜ਼ੂਰ ਓਪਨਏਆਈ ਸਰਵਿਸ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਮੁੜ ਕ੍ਰਮਿਤ ਅਤੇ ਸਕੋਰ ਕੀਤੀਆਂ ਸਿਫਾਰਸ਼ਾਂ ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ।

ਧਿਆਨ ਰੱਖੋ ਕਿ your_azure_openai_api_key ਨੂੰ ਆਪਣੇ ਅਸਲੀ ਐਜ਼ੂਰ ਓਪਨਏਆਈ API ਕੀ ਨਾਲ ਅਤੇ https://your-endpoint.com/... ਨੂੰ ਆਪਣੇ ਐਜ਼ੂਰ ਓਪਨਏਆਈ ਡਿਪਲੌਇਮੈਂਟ ਦੇ ਅਸਲੀ ਐਂਡਪੋਇੰਟ URL ਨਾਲ ਬਦਲੋ।

LLM ਨੂੰ ਰੀ-ਰੈਂਕ ਅਤੇ ਸਕੋਰਿੰਗ ਲਈ ਵਰਤ ਕੇ, ਟ੍ਰੈਵਲ ਏਜੈਂਟ ਗਾਹਕਾਂ ਨੂੰ ਹੋਰ ਵਿਅਕਤੀਗਤ ਅਤੇ ਪ੍ਰਸੰਗਿਕ ਟ੍ਰੈਵਲ ਸਿਫਾਰਸ਼ਾਂ ਦੇ ਸਕਦਾ ਹੈ, ਜਿਸ ਨਾਲ ਉਹਨਾਂ ਦਾ ਸਮੁੱਚਾ ਅਨੁਭਵ ਸੁਧਰਦਾ ਹੈ।

RAG: ਪ੍ਰਾਂਪਟਿੰਗ ਤਕਨੀਕ ਬਨਾਮ ਟੂਲ

Retrieval-Augmented Generation (RAG) AI ਏਜੈਂਟਾਂ ਦੇ ਵਿਕਾਸ ਵਿੱਚ ਦੋਹਾਂ ਤਕਨੀਕ ਅਤੇ ਟੂਲ ਦੋਹਾਂ ਵਜੋਂ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ। ਦੋਹਾਂ ਵਿੱਚ ਅੰਤਰ ਨੂੰ ਸਮਝ ਕੇ ਤੁਸੀਂ RAG ਨੂੰ ਆਪਣੇ ਪ੍ਰੋਜੈਕਟਾਂ ਵਿੱਚ ਬਿਹਤਰ ਤਰੀਕੇ ਨਾਲ ਲਾਗੂ ਕਰ ਸਕਦੇ ਹੋ।

RAG ਇੱਕ ਪ੍ਰਾਂਪਟਿੰਗ ਤਕਨੀਕ ਵਜੋਂ

ਇਹ ਕੀ ਹੈ?

ਇੱਕ ਪ੍ਰਾਂਪਟਿੰਗ ਤਕਨੀਕ ਵਜੋਂ, RAG ਵਿਸ਼ੇਸ਼ ਪੁੱਛਤਾਛਾਂ ਜਾਂ ਪ੍ਰਾਂਪਟਾਂ ਬਣਾਉਂਦਾ ਹੈ ਜੋ ਵੱਡੇ ਕੋਰਪਸ ਜਾਂ ਡੇਟਾਬੇਸ ਤੋਂ ਸਬੰਧਤ ਜਾਣਕਾਰੀ ਲੱਭਣ ਲਈ ਮਦਦ ਕਰਦੇ ਹਨ। ਫਿਰ ਇਸ ਜਾਣਕਾਰੀ ਦਾ ਉਪਯੋਗ ਜਵਾਬ ਜਾਂ ਕਾਰਵਾਈ ਬਣਾਉਣ ਲਈ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।

ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ:

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

ਟ੍ਰੈਵਲ ਏਜੈਂਟ ਵਿੱਚ ਉਦਾਹਰਨ:

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

RAG ਇੱਕ ਟੂਲ ਵਜੋਂ

ਇਹ ਕੀ ਹੈ?

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

ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ:

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

ਟ੍ਰੈਵਲ ਏਜੈਂਟ ਵਿੱਚ ਉਦਾਹਰਨ:

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

ਤੁਲਨਾ

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

ਜੀਵੰਤ ਉਦਾਹਰਨ

ਪ੍ਰਾਂਪਟਿੰਗ ਤਕਨੀਕ ਉਦਾਹਰਨ:

def search_museums_in_paris():
    prompt = "Find top museums in Paris"
    search_results = search_web(prompt)
    return search_results

museums = search_museums_in_paris()
print("Top Museums in Paris:", museums)

ਟੂਲ ਉਦਾਹਰਨ:

class Travel_Agent:
    def __init__(self):
        self.rag_tool = RAGTool()

    def get_museums_in_paris(self):
        user_input = "I want to visit museums in Paris."
        response = self.rag_tool.retrieve_and_generate(user_input)
        return response

travel_agent = Travel_Agent()
museums = travel_agent.get_museums_in_paris()
print("Top Museums in Paris:", museums)

ਪ੍ਰਸੰਗਿਕਤਾ ਦਾ ਮੁਲਾਂਕਣ ਕਰਨਾ

ਪ੍ਰਸੰਗਿਕਤਾ ਦਾ ਮੁਲਾਂਕਣ AI ਏਜੈਂਟ ਦੀ ਕਾਰਗੁਜ਼ਾਰੀ ਦਾ ਇੱਕ ਅਹੰਕਾਰਪੂਰਨ ਪਹਲੂ ਹੈ। ਇਹ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ ਏਜੈਂਟ ਵੱਲੋਂ ਪ੍ਰਾਪਤ ਅਤੇ ਬਣਾਈ ਗਈ ਜਾਣਕਾਰੀ ਯੂਜ਼ਰ ਲਈ ਢੁਕਵਾਂ, ਸਹੀ, ਅਤੇ ਲਾਭਕਾਰੀ ਹੈ। ਆਓ ਵੇਖੀਏ ਕਿ ਕਿਵੇਂ ਪ੍ਰਸੰਗਿਕਤਾ ਦਾ ਮੁਲਾਂਕਣ ਕਰਨਾ ਹੈ, ਜੀਵੰਤ ਉਦਾਹਰਨਾਂ ਅਤੇ ਤਕਨੀਕਾਂ ਸਮੇਤ।

ਪ੍ਰਸੰਗਿਕਤਾ ਮੁਲਾਂਕਣ ਵਿੱਚ ਮੁੱਖ ਧਾਰਨਾਵਾਂ

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

ਪ੍ਰਸੰਗਿਕਤਾ ਮੁਲਾਂਕਣ ਲਈ ਪ੍ਰਯੋਗਿਕ ਤਕਨੀਕਾਂ

ਪ੍ਰਸੰਗਿਕਤਾ ਸਕੋਰਿੰਗ:
- ਹਰ ਪ੍ਰਾਪਤ ਵਿਸ਼ੇਸ਼ਤਾ ਨੂੰ ਇੱਕ ਪ੍ਰਸੰਗਿਕਤਾ ਸਕੋਰ ਦੇਣਾ, ਜੋ ਇਹ ਦਿਖਾਵੇ ਕਿ ਇਹ ਯੂਜ਼ਰ ਦੀ ਪੁੱਛਤਾਂ ਅਤੇ ਪਸੰਦਾਂ ਨਾਲ ਕਿੰਨੀ ਮਿਲਦੀ ਹੈ।
- ਉਦਾਹਰਨ:
```
def relevance_score(item, query):
    score = 0
    if item['category'] in query['interests']:
        score += 1
    if item['price'] <= query['budget']:
        score += 1
    if item['location'] == query['destination']:
        score += 1
    return score
```
ਫਿਲਟਰੇਸ਼ਨ ਅਤੇ ਰੈਂਕਿੰਗ:
- ਬੇਸਮਝ ਅਤੇ ਗੈਰ-ਮਿਲਦੀਆਂ ਆਈਟਮਾਂ ਨੂੰ ਹਟਾਉਣਾ ਅਤੇ ਬਾਕੀ ਨੂੰ ਉਹਨਾਂ ਦੇ ਪ੍ਰਸੰਗਿਕਤਾ ਸਕੋਰ ਅਨੁਸਾਰ ਰੈਂਕ ਕਰਨਾ।
- ਉਦਾਹਰਨ:
```
def filter_and_rank(items, query):
    ranked_items = sorted(items, key=lambda item: relevance_score(item, query), reverse=True)
    return ranked_items[:10]  # ਸਿਖਰਲੇ 10 ਸੰਬੰਧਿਤ ਆਈਟਮ ਵਾਪਸ ਕਰੋ
```

ਕੁਦਰਤੀ ਭਾਸ਼ਾ ਪ੍ਰਕਿਰਿਆ (NLP):

NLP ਤਕਨੀਕਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਯੂਜ਼ਰ ਦੀ ਪੁੱਛਤਾਂ ਨੂੰ ਸਮਝਣਾ ਅਤੇ ਸਬੰਧਤ ਜਾਣਕਾਰੀ ਲੱਭਣੀ।

ਉਦਾਹਰਨ:

def process_query(query):
    # ਵਰਤੋਂਕਾਰ ਦੀ ਪੁੱਛਤाछ ਤੋਂ ਮੁੱਖ ਜਾਣਕਾਰੀ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ NLP ਦੀ ਵਰਤੋਂ ਕਰੋ
    processed_query = nlp(query)
    return processed_query

ਯੂਜ਼ਰ ਫੀਡਬੈਕ ਏਕੀਕਰਨ:
- ਦਿੱਤੀ ਗਈਆਂ ਸਿਫਾਰਸ਼ਾਂ ਉੱਤੇ ਯੂਜ਼ਰ ਦੀ ਫੀਡਬੈਕ ਇਕੱਠੀ ਕਰਨਾ ਅਤੇ ਇਸ ਨੂੰ ਭਵਿੱਖ ਵਿੱਚ ਪ੍ਰਸੰਗਿਕਤਾ ਅੰਕੜੇ ਠੀਕ ਕਰਨ ਲਈ ਵਰਤਣਾ।
- ਉਦਾਹਰਨ:
```
def adjust_based_on_feedback(feedback, items):
    for item in items:
        if item['name'] in feedback['liked']:
            item['relevance'] += 1
        if item['name'] in feedback['disliked']:
            item['relevance'] -= 1
    return items
```

ਉਦਾਹਰਨ: ਟ੍ਰੈਵਲ ਏਜੈਂਟ ਵਿੱਚ ਪ੍ਰਸੰਗਿਕਤਾ ਦਾ ਮੁਲਾਂਕਣ

ਇਹਥੇ ਇੱਕ ਪ੍ਰਯੋਗਿਕ ਉਦਾਹਰਨ ਹੈ ਕਿ ਕਿਵੇਂ ਟ੍ਰੈਵਲ ਏਜੈਂਟ ਯਾਤਰਾ ਦੀਆਂ ਸਿਫਾਰਸ਼ਾਂ ਦੀ ਪ੍ਰਸੰਗਿਕਤਾ ਦਾ ਮੁਲਾਂਕਣ ਕਰ ਸਕਦਾ ਹੈ:

class Travel_Agent:
    def __init__(self):
        self.user_preferences = {}
        self.experience_data = []

    def gather_preferences(self, preferences):
        self.user_preferences = preferences

    def retrieve_information(self):
        flights = search_flights(self.user_preferences)
        hotels = search_hotels(self.user_preferences)
        attractions = search_attractions(self.user_preferences)
        return flights, hotels, attractions

    def generate_recommendations(self):
        flights, hotels, attractions = self.retrieve_information()
        ranked_hotels = self.filter_and_rank(hotels, self.user_preferences)
        itinerary = create_itinerary(flights, ranked_hotels, attractions)
        return itinerary

    def filter_and_rank(self, items, query):
        ranked_items = sorted(items, key=lambda item: self.relevance_score(item, query), reverse=True)
        return ranked_items[:10]  # ਸਿਰਫ਼ 10 ਸਭ ਤੋਂ ਸਬੰਧਿਤ ਆਈਟਮ ਵਾਪਸ ਕਰੋ

    def relevance_score(self, item, query):
        score = 0
        if item['category'] in query['interests']:
            score += 1
        if item['price'] <= query['budget']:
            score += 1
        if item['location'] == query['destination']:
            score += 1
        return score

    def adjust_based_on_feedback(self, feedback, items):
        for item in items:
            if item['name'] in feedback['liked']:
                item['relevance'] += 1
            if item['name'] in feedback['disliked']:
                item['relevance'] -= 1
        return items

# ਉਦਾਹਰਨ ਵਾਪਰਤਾ
travel_agent = Travel_Agent()
preferences = {
    "destination": "Paris",
    "dates": "2025-04-01 to 2025-04-10",
    "budget": "moderate",
    "interests": ["museums", "cuisine"]
}
travel_agent.gather_preferences(preferences)
itinerary = travel_agent.generate_recommendations()
print("Suggested Itinerary:", itinerary)
feedback = {"liked": ["Louvre Museum"], "disliked": ["Eiffel Tower (too crowded)"]}
updated_items = travel_agent.adjust_based_on_feedback(feedback, itinerary['hotels'])
print("Updated Itinerary with Feedback:", updated_items)

ਮਨਸੂਬੇ ਨਾਲ ਖੋਜ

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

ਮਨਸੂਬੇ ਨਾਲ ਖੋਜ ਵਿਚ ਮੁੱਖ ਸਿਧਾਂਤ

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

ਪ੍ਰਯੋਗਿਕ ਉਦਾਹਰਨ: ਟ੍ਰੈਵਲ ਏਜੈਂਟ ਵਿੱਚ ਮਨਸੂਬੇ ਨਾਲ ਖੋਜ

ਆਓ ਟ੍ਰੈਵਲ ਏਜੈਂਟ ਨੂੰ ਉਦਾਹਰਨ ਵਜੋਂ ਲੈ ਕੇ ਵੇਖੀਏ ਕਿ ਮਨਸੂਬੇ ਨਾਲ ਖੋਜ ਕਿਵੇਂ ਲਾਗੂ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ।

ਯੂਜ਼ਰ ਪਸੰਦਾਂ ਇਕੱਠੀਆਂ ਕਰਨਾ

class Travel_Agent:
    def __init__(self):
        self.user_preferences = {}

    def gather_preferences(self, preferences):
        self.user_preferences = preferences

ਯੂਜ਼ਰ ਦਾ ਮਨਸੂਬਾ ਸਮਝਣਾ

def identify_intent(query):
    if "book" in query or "purchase" in query:
        return "transactional"
    elif "website" in query or "official" in query:
        return "navigational"
    else:
        return "informational"

ਸੰਦਰਭ ਸਮਝ

def analyze_context(query, user_history):
    # ਮੌਜੂਦਾ ਕوری کو صارف کی تاریخ کے ساتھ ملائیں تاکہ سیاق و سباق کو سمجھا جا سکے
    context = {
        "current_query": query,
        "user_history": user_history
    }
    return context

ਨਤੀਜੇ ਖੋਜੋ ਅਤੇ ਨਿੱਜੀ ਬਣਾਓ

def search_with_intent(query, preferences, user_history):
    intent = identify_intent(query)
    context = analyze_context(query, user_history)
    if intent == "informational":
        search_results = search_information(query, preferences)
    elif intent == "navigational":
        search_results = search_navigation(query)
    elif intent == "transactional":
        search_results = search_transaction(query, preferences)
    personalized_results = personalize_results(search_results, user_history)
    return personalized_results

def search_information(query, preferences):
    # ਜਾਣਕਾਰੀ ਵਾਲੇ ਮਨੋਰਥ ਲਈ ਉਦਾਹਰਨ ਖੋਜ ਤਰਕ
    results = search_web(f"best {preferences['interests']} in {preferences['destination']}")
    return results

def search_navigation(query):
    # ਨੈਵੀਗੇਸ਼ਨ ਮਨੋਰਥ ਲਈ ਉਦਾਹਰਨ ਖੋਜ ਤਰਕ
    results = search_web(query)
    return results

def search_transaction(query, preferences):
    # ਲੈਣ-ਦੇਣ ਵਾਲੇ ਮਨੋਰਥ ਲਈ ਉਦਾਹਰਨ ਖੋਜ ਤਰਕ
    results = search_web(f"book {query} to {preferences['destination']}")
    return results

def personalize_results(results, user_history):
    # ਉਦਾਹਰਨ ਨਿੱਜੀਕਰਨ ਤਰਕ
    personalized = [result for result in results if result not in user_history]
    return personalized[:10]  # ਸਭ ਤੋਂ ਵਧੀਆ 10 ਨਿੱਜੀ ਨਤੀਜੇ ਵਾਪਸ ਕਰੋ

ਉਦਾਹਰਨ ਵਰਤੋਂ

travel_agent = Travel_Agent()
preferences = {
    "destination": "Paris",
    "interests": ["museums", "cuisine"]
}
travel_agent.gather_preferences(preferences)
user_history = ["Louvre Museum website", "Book flight to Paris"]
query = "best museums in Paris"
results = search_with_intent(query, preferences, user_history)
print("Search Results:", results)

4. ਇੱਕ ਸਧਨ ਵਜੋਂ ਕੋਡ ਤਿਆਰ ਕਰਨਾ

ਕੋਡ ਤਿਆਰ ਕਰਨ ਵਾਲੇ ਏਜੰਟ AI ਮਾਡਲਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕੋਡ ਲਿਖਦੇ ਅਤੇ ਚਲਾਉਂਦੇ ਹਨ, ਜਟਿਲ ਸਮੱਸਿਆਵਾਂ ਹੱਲ ਕਰਨ ਅਤੇ ਕੰਮਾਂ ਨੂੰ ਸੁਚਾਲੂ ਕਰਨ ਲਈ।

ਕੋਡ ਤਿਆਰ ਕਰਨ ਵਾਲੇ ਏਜੰਟ

ਕੋਡ ਤਿਆਰ ਕਰਨ ਵਾਲੇ ਏਜੰਟ ਜਨਰੇਟਿਵ AI ਮਾਡਲਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕੋਡ ਲਿਖਦੇ ਅਤੇ ਚਲਾਉਂਦੇ ਹਨ। ਇਹ ਏਜੰਟ ਜਟਿਲ ਸਮੱਸਿਆਵਾਂ ਹੱਲ ਕਰ ਸਕਦੇ ਹਨ, ਕੰਮ ਆਪਣੇ ਆਪ ਕਰ ਸਕਦੇ ਹਨ, ਅਤੇ ਵੱਖ-ਵੱਖ ਪ੍ਰੋਗ੍ਰਾਮਿੰਗ ਭਾਸ਼ਾਵਾਂ ਵਿੱਚ ਕੋਡ ਤਿਆਰ ਅਤੇ ਚਲਾ ਕੇ ਕੀਮਤੀ ਜਾਣਕਾਰੀਆਂ ਪ੍ਰਦਾਨ ਕਰ ਸਕਦੇ ਹਨ।

ਕਾਰਗਰ ਪ੍ਰਯੋਗ

ਸਵੈ-ਚਾਲਿਤ ਕੋਡ ਸਿਰਜੇਸ਼ਨ: ਖਾਸ ਕੰਮਾਂ ਲਈ ਕੋਡ ਟੁਕੜੇ ਤਿਆਰ ਕਰੋ, ਜਿਵੇਂ ਡਾਟਾ ਵਿਸ਼ਲੇਸ਼ਣ, ਵੈੱਬ ਸਕ੍ਰੈਪਿੰਗ, ਜਾਂ ਮਸ਼ੀਨ ਲਰਨਿੰਗ।
RAG ਵਜੋਂ SQL: ਡੇਟਾਬੇਸਾਂ ਵਿਚੋਂ ਡਾਟਾ ਪ੍ਰਾਪਤ ਕਰਨ ਅਤੇ ਸੰਚਾਲਿਤ ਕਰਨ ਲਈ SQL ਕਵੈਰੀਜ਼ ਦੀ ਵਰਤੋਂ ਕਰੋ।
ਸਮੱਸਿਆ ਹੱਲ ਕਰਨਾ: ਖਾਸ ਸਮੱਸਿਆਵਾਂ ਹੱਲ ਕਰਨ ਲਈ ਕੋਡ ਬਣਾਓ ਅਤੇ ਚਲਾਓ, ਜਿਵੇਂ ਐਲਗੋਰਿਥਮਾਂ ਨੂੰ ਅਪਟੀਮਾਈਜ਼ ਕਰਨਾ ਜਾਂ ਡਾਟਾ ਦਾ ਵਿਸ਼ਲੇਸ਼ਣ ਕਰਨਾ।

ਉਦਾਹਰਨ: ਡਾਟਾ ਵਿਸ਼ਲੇਸ਼ਣ ਲਈ ਕੋਡ ਤਿਆਰ ਕਰਨ ਵਾਲਾ ਏਜੰਟ

ਸੋਚੋ ਤੁਸੀਂ ਇੱਕ ਕੋਡ ਤਿਆਰ ਕਰਨ ਵਾਲੇ ਏਜੰਟ ਨੂੰ ਡਿਜ਼ਾਈਨ ਕਰ ਰਹੇ ਹੋ। ਇਹ ਇਸ ਤਰ੍ਹਾਂ ਕੰਮ ਕਰ ਸਕਦਾ ਹੈ:

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

ਉਦਾਹਰਨ: ਟਰੈਵਲ ਏਜੰਟ ਲਈ ਕੋਡ ਤਿਆਰ ਕਰਨ ਵਾਲਾ ਏਜੰਟ

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

ਕੋਡ ਤਿਆਰ ਕਰਨ ਵਾਲੇ ਏਜੰਟ ਦਾ ਸੰਖੇਪ

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

ਕਦਮ-ਬਾਈ-ਕਦਮ ਲਾਗੂ

ਯੂਜ਼ਰ ਪਸੰਦਾਂ ਇਕੱਠਾ ਕਰਨਾ

class Travel_Agent:
    def __init__(self):
        self.user_preferences = {}

    def gather_preferences(self, preferences):
        self.user_preferences = preferences

ਡਾਟਾ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਕੋਡ ਤਿਆਰ ਕਰਨਾ

def generate_code_to_fetch_data(preferences):
    # ਉਦਾਹਰਨ: ਉਪਭੋਗਤਾ ਦੀਆਂ ਪਸੰਦਾਂ ਦੇ ਆਧਾਰ 'ਤੇ ਉਡਾਣਾਂ ਲਈ ਕੋਡ ਤਿਆਰ ਕਰੋ
    code = f"""
    def search_flights():
        import requests
        response = requests.get('https://api.example.com/flights', params={preferences})
        return response.json()
    """
    return code

def generate_code_to_fetch_hotels(preferences):
    # ਉਦਾਹਰਨ: ਹੋਟਲਾਂ ਲਈ ਖੋਜ ਕਰਨ ਲਈ ਕੋਡ ਤਿਆਰ ਕਰੋ
    code = f"""
    def search_hotels():
        import requests
        response = requests.get('https://api.example.com/hotels', params={preferences})
        return response.json()
    """
    return code

ਤਿਆਰ ਕੀਤੇ ਕੋਡ ਨੂੰ ਚਲਾਉਣਾ

def execute_code(code):
    # ਉਤਪੰਨ ਕੋਡ ਨੂੰ exec ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਚਲਾਓ
    exec(code)
    result = locals()
    return result

travel_agent = Travel_Agent()
preferences = {
    "destination": "Paris",
    "dates": "2025-04-01 to 2025-04-10",
    "budget": "moderate",
    "interests": ["museums", "cuisine"]
}
travel_agent.gather_preferences(preferences)
   
flight_code = generate_code_to_fetch_data(preferences)
hotel_code = generate_code_to_fetch_hotels(preferences)
   
flights = execute_code(flight_code)
hotels = execute_code(hotel_code)

print("Flight Options:", flights)
print("Hotel Options:", hotels)

ਇਟਿਨਰੇਰੀ ਤਿਆਰ ਕਰਨਾ

def generate_itinerary(flights, hotels, attractions):
    itinerary = {
        "flights": flights,
        "hotels": hotels,
        "attractions": attractions
    }
    return itinerary

attractions = search_attractions(preferences)
itinerary = generate_itinerary(flights, hotels, attractions)
print("Suggested Itinerary:", itinerary)

ਪ੍ਰਤੀਕਿਰਿਆ ਦੇ ਆਧਾਰ ‘ਤੇ ਠੀਕ ਕਰਨਾ

def adjust_based_on_feedback(feedback, preferences):
    # ਯੂਜ਼ਰ ਫੀਡਬੈਕ ਦੇ ਆਧਾਰ 'ਤੇ ਪਸੰਦਾਂ ਨੂੰ ਠੀਕ ਕਰੋ
    if "liked" in feedback:
        preferences["favorites"] = feedback["liked"]
    if "disliked" in feedback:
        preferences["avoid"] = feedback["disliked"]
    return preferences

feedback = {"liked": ["Louvre Museum"], "disliked": ["Eiffel Tower (too crowded)"]}
updated_preferences = adjust_based_on_feedback(feedback, preferences)
   
# ਅਪਡੇਟ ਕੀਤੀਆਂ ਪਸੰਦਾਂ ਨਾਲ ਕੋਡ ਨੂੰ ਮੁੜ ਬਣਾਓ ਅਤੇ ਚਲਾਓ
updated_flight_code = generate_code_to_fetch_data(updated_preferences)
updated_hotel_code = generate_code_to_fetch_hotels(updated_preferences)
   
updated_flights = execute_code(updated_flight_code)
updated_hotels = execute_code(updated_hotel_code)
   
updated_itinerary = generate_itinerary(updated_flights, updated_hotels, attractions)
print("Updated Itinerary:", updated_itinerary)

ਵਾਤਾਵਰਣੀ ਜਾਗਰੂਕਤਾ ਅਤੇ ਤਰਕ ਨਾਲ ਲਾਭ ਉਠਾਉਣਾ

ਟੇਬਲ ਦੀ ਸਕੀਮਾ ਦੇ ਆਧਾਰ ‘ਤੇ ਸਹੀ ਤਰੀਕੇ ਨਾਲ ਕਵੈਰੀ ਤਿਆਰ ਕਰਨ ਦੀ ਪ੍ਰਕਿਰਿਆ ਵਾਤਾਵਰਣੀ ਜਾਗਰੂਕਤਾ ਅਤੇ ਤਰਕ ਨਾਲ ਸੁਧਾਰੀ ਜਾ ਸਕਦੀ ਹੈ।

ਇੱਥੇ ਇਹ ਕਿਵੇਂ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ:

ਸਕੀਮਾ ਨੂੰ ਸਮਝਨਾ: ਪদ্ধਤੀ ਟੇਬਲ ਦੀ ਸਕੀਮਾ ਨੂੰ ਸਮਝੇਗੀ ਅਤੇ ਇਸ ਜਾਣਕਾਰੀ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕਵੈਰੀ ਤਿਆਰ ਕਰਨ ਨੂੰ ਮਜ਼ਬੂਤ ਕਰੇਗੀ।
ਪ੍ਰਤੀਕਿਰਿਆ ਦੇ ਅਧਾਰ ‘ਤੇ ਠੀਕ ਕਰਨਾ: ਪద్ధਤੀ ਯੂਜ਼ਰ ਪਸੰਦਾਂ ਨੂੰ ਪ੍ਰਤੀਕਿਰਿਆ ਆਧਾਰਿਤ ਢੰਗ ਨਾਲ ਠੀਕ ਕਰੇਗੀ ਅਤੇ ਦਲੀਲ ਕਰੇਗੀ ਕਿ ਸਕੀਮਾ ਵਿੱਚ ਕਿਹੜੇ ਖੇਤਰ ਅਪਡੇਟ ਕਰਨ ਦੀ ਲੋੜ ਹੈ।
ਕਵੈਰੀ ਤਿਆਰ ਕਰਨਾ ਅਤੇ ਚਲਾਉਣਾ: ਪદ્ધਤੀ ਨਵੇਂ ਪਸੰਦਾਂ ਦੇ ਅਧਾਰ ‘ਤੇ ਅਪਡੇਟ ਕੀਤੇ ਉਡਾਣ ਅਤੇ ਹੋਟਲ ਦੇ ਡਾਟੇ ਨੂੰ ਲੈਣ ਲਈ ਕਵੈਰੀਆਂ ਤਿਆਰ ਕਰੇਗੀ ਅਤੇ ਚਲਾਏਗੀ।

ਇੱਥੇ ਇੱਕ ਸੁਧਾਰਿਆ ਹੋਇਆ Python ਕੋਡ ਉਦਾਹਰਨ ਹੈ ਜੋ ਇਹ ਫਿਕਰਾਂ ਸ਼ਾਮਲ ਕਰਦਾ ਹੈ:

def adjust_based_on_feedback(feedback, preferences, schema):
    # ਯੂਜ਼ਰ ਫੀਡਬੈਕ ਦੇ ਆਧਾਰ 'ਤੇ ਪਸੰਦਾਂ ਨੂੰ ਸਮਾਇਤ ਕਰੋ
    if "liked" in feedback:
        preferences["favorites"] = feedback["liked"]
    if "disliked" in feedback:
        preferences["avoid"] = feedback["disliked"]
    # ਹੋਰ ਸੰਬੰਧਿਤ ਪਸੰਦਾਂ ਨੂੰ ਸਮਾਇਤ ਕਰਨ ਲਈ ਸਕੀਮਾ ਦੇ ਆਧਾਰ 'ਤੇ ਤਰਕ
    for field in schema:
        if field in preferences:
            preferences[field] = adjust_based_on_environment(feedback, field, schema)
    return preferences

def adjust_based_on_environment(feedback, field, schema):
    # ਸਕੀਮਾ ਅਤੇ ਫੀਡਬੈਕ ਦੇ ਆਧਾਰ 'ਤੇ ਪਸੰਦਾਂ ਨੂੰ ਸਮਾਇਤ ਕਰਨ ਲਈ ਕਸਟਮ ਲੋਗਿਕ
    if field in feedback["liked"]:
        return schema[field]["positive_adjustment"]
    elif field in feedback["disliked"]:
        return schema[field]["negative_adjustment"]
    return schema[field]["default"]

def generate_code_to_fetch_data(preferences):
    # ਅਪਡੇਟ ਕੀਤੀਆਂ ਪਸੰਦਾਂ ਦੇ ਆਧਾਰ 'ਤੇ ਫਲਾਈਟ ਡੇਟਾ ਲੈਣ ਲਈ ਕੋਡ ਬਣਾਓ
    return f"fetch_flights(preferences={preferences})"

def generate_code_to_fetch_hotels(preferences):
    # ਅਪਡੇਟ ਕੀਤੀਆਂ ਪਸੰਦਾਂ ਦੇ ਆਧਾਰ 'ਤੇ ਹੋਟਲ ਡੇਟਾ ਲੈਣ ਲਈ ਕੋਡ ਬਣਾਓ
    return f"fetch_hotels(preferences={preferences})"

def execute_code(code):
    # ਕੋਡ ਦੀ ਨਕਲ ਚਲਾਉਣ ਅਤੇ ਨਕਲੀ ਡੇਟਾ ਵਾਪਸ ਕਰਨ ਦਾ ਅਨੁਕਰਣ ਕਰੋ
    return {"data": f"Executed: {code}"}

def generate_itinerary(flights, hotels, attractions):
    # ਫਲਾਈਟਾਂ, ਹੋਟਲਾਂ ਅਤੇ ਆਕਰਸ਼ਣਾਂ ਦੇ ਆਧਾਰ 'ਤੇ ਯਾਤਰਾ ਬਣਾਓ
    return {"flights": flights, "hotels": hotels, "attractions": attractions}

# ਉਦਾਹਰਨ ਸਕੀਮਾ
schema = {
    "favorites": {"positive_adjustment": "increase", "negative_adjustment": "decrease", "default": "neutral"},
    "avoid": {"positive_adjustment": "decrease", "negative_adjustment": "increase", "default": "neutral"}
}

# ਉਦਾਹਰਨ ਵਰਤੋਂ
preferences = {"favorites": "sightseeing", "avoid": "crowded places"}
feedback = {"liked": ["Louvre Museum"], "disliked": ["Eiffel Tower (too crowded)"]}
updated_preferences = adjust_based_on_feedback(feedback, preferences, schema)

# ਅਪਡੇਟ ਕੀਤੀਆਂ ਪਸੰਦਾਂ ਨਾਲ ਕੋਡ ਮੁੜ ਤਿਆਰ ਕਰੋ ਅਤੇ ਚਲਾਓ
updated_flight_code = generate_code_to_fetch_data(updated_preferences)
updated_hotel_code = generate_code_to_fetch_hotels(updated_preferences)

updated_flights = execute_code(updated_flight_code)
updated_hotels = execute_code(updated_hotel_code)

updated_itinerary = generate_itinerary(updated_flights, updated_hotels, feedback["liked"])
print("Updated Itinerary:", updated_itinerary)

ਵਿਆਖਿਆ - ਪ੍ਰਤੀਕਿਰਿਆ ਦੇ ਆਧਾਰ ‘ਤੇ ਬੁਕਿੰਗ

ਸਕੀਮਾ ਜਾਗਰੂਕਤਾ: schema ਡਿਕਸ਼ਨਰੀ ਦੱਸਦੀ ਹੈ ਕਿ ਪ੍ਰਤੀਕਿਰਿਆ ਦੇ ਆਧਾਰ ‘ਤੇ ਪਸੰਦਾਂ ਨੂੰ ਕਿਵੇਂ ਠੀਕ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ। ਇਸ ਵਿਚ favorites ਅਤੇ avoid ਵਰਗੇ ਖੇਤਰ ਹਨ, ਜਿਨ੍ਹਾਂ ਨਾਲ ਸਬੰਧਿਤ ਢੰਗ ਨਾਲ ਠੀਕ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।
ਪਸੰਦਾਂ ਨੂੰ ਠੀਕ ਕਰਨਾ (adjust_based_on_feedback ਮੈਥਡ): ਇਹ ਮੈਥਡ ਯੂਜ਼ਰ ਦੀ ਪ੍ਰਤੀਕਿਰਿਆ ਅਤੇ ਸਕੀਮਾ ਦੇ ਆਧਾਰ ‘ਤੇ ਪਸੰਦਾਂ ਨੂੰ ਠੀਕ ਕਰਦਾ ਹੈ।
ਵਾਤਾਵਰਣ-ਅਧਾਰਿਤ ਠੀਕ ਕਰਨਾ (adjust_based_on_environment ਮੈਥਡ): ਇਹ ਮੈਥਡ ਸਕੀਮਾ ਅਤੇ ਪ੍ਰਤੀਕਿਰਿਆ ਦੇ ਆਧਾਰ ‘ਤੇ ਠੀਕ ਕਰਦਾ ਹੈ।
ਕਵੈਰੀ ਤਿਆਰ ਕਰਨਾ ਅਤੇ ਚਲਾਉਣਾ: ਪੱਧਤੀ ਅਪਡੇਟ ਕੀਤੀਆਂ ਪਸੰਦਾਂ ਦੇ ਆਧਾਰ ‘ਤੇ ਅਪਡੇਟ ਕੀਤੇ ਉਡਾਣ ਅਤੇ ਹੋਟਲ ਡਾਟੇ ਨੂੰ ਲੈਣ ਲਈ ਕੋਡ ਤਿਆਰ ਕਰਦੀ ਹੈ ਅਤੇ ਇਹ ਕਵੈਰੀਆਂ ਚਲਾਏਗੀ।
ਇਟਿਨਰੇਰੀ ਤਿਆਰ ਕਰਨਾ: ਪੱਧਤੀ ਨਵੇਂ ਉਡਾਣ, ਹੋਟਲ ਅਤੇ ਆਕਰਸ਼ਣ ਡਾਟੇ ਦੇ ਆਧਾਰ ‘ਤੇ ਅਪਡੇਟ ਕੀਤੀ ਇਟਿਨਰੇਰੀ ਬਣਾਉਂਦੀ ਹੈ।

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

Retrieval-Augmented Generation (RAG) ਤਕਨਾਲੋਜੀ ਵਜੋਂ SQL ਦੀ ਵਰਤੋਂ

SQL (Structured Query Language) ਡੇਟਾਬੇਸਾਂ ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ ਇੱਕ ਸ਼ਕਤੀਸ਼ਾਲੀ ਸਧਨ ਹੈ। ਜਦੋਂ ਇਹ Retrieval-Augmented Generation (RAG) ਦੇ ਹਿੱਸੇ ਵਜੋਂ ਵਰਤੀ ਜਾਂਦੀ ਹੈ, ਤਾਂ SQL ਡੇਟਾਬੇਸਾਂ ਵਿੱਚੋਂ ਸਬੰਧਤ ਡਾਟਾ ਲਿਆਉਂਦੀ ਹੈ, ਜੋ AI ਏਜੰਟਾਂ ਨੂੰ ਜਵਾਬ ਜਾਂ ਕਾਰਵਾਈ ਤਿਆਰ ਕਰਨ ਵਿੱਚ ਮਦਦ ਕਰਦਾ ਹੈ। ਆਓ ਵੇਖੀਏ ਕਿ ਟਰੈਵਲ ਏਜੰਟ ਸੰਦਰਭ ਵਿੱਚ RAG ਤਕਨਾਲੋਜੀ ਵਜੋਂ SQL ਕਿਵੇਂ ਵਰਤੀ ਜਾ ਸਕਦੀ ਹੈ।

ਮੁੱਖ ਧਾਰਣਾ

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

ਅਰਜ਼ੀਆਂ

ਸਵੈ-ਚਾਲਿਤ ਕੋਡ ਸਿਰਜੇਸ਼ਨ: ਖਾਸ ਕੰਮਾਂ ਲਈ ਕੋਡ ਟੁਕੜੇ ਤਿਆਰ ਕਰੋ।
RAG ਵਜੋਂ SQL: ਡਾਟਾ ਸੰਚਾਲਿਤ ਕਰਨ ਲਈ SQL ਕਵੈਰੀਜ਼ ਦੀ ਵਰਤੋਂ ਕਰੋ।
ਸਮੱਸਿਆ ਹੱਲ ਕਰਨਾ: ਸਮੱਸਿਆਵਾਂ ਹੱਲ ਕਰਨ ਲਈ ਕੋਡ ਬਣਾਓ ਅਤੇ ਚਲਾਓ।

ਉਦਾਹਰਨ: ਇੱਕ ਡਾਟਾ ਵਿਸ਼ਲੇਸ਼ਣ ਏਜੰਟ:

ਕੰਮ: ਰੁਝਾਨ ਲੱਭਣ ਲਈ ਡਾਟਾਸੈੱਟ ਦਾ ਵਿਸ਼ਲੇਸ਼ਣ ਕਰੋ।
ਕਦਮ:
- ਡਾਟਾਸੈੱਟ ਲੋਡ ਕਰੋ।
- ਡਾਟਾ ਨੂੰ ਛਾਂਟਣ ਲਈ SQL ਕਵੈਰੀਜ਼ ਬਣਾਓ।
- ਕਵੈਰੀਜ਼ ਚਲਾਓ ਅਤੇ ਨਤੀਜੇ ਪ੍ਰਾਪਤ ਕਰੋ।
- ਵਿਜ਼ੂਅਲਾਈਜ਼ੇਸ਼ਨ ਅਤੇ ਜਾਣਕਾਰੀਆਂ ਤਿਆਰ ਕਰੋ।
ਸਰੋਤ: ਡਾਟਾਸੈੱਟ ਐਕਸੈਸ, SQL ਸਮਰੱਥਾ।
ਅਨੁਭਵ: ਭਵਿੱਖ ਦੀਆਂ ਵਿਸ਼ਲੇਸ਼ਣਾਂ ਨੂੰ ਸੁਧਾਰਨ ਲਈ ਪਿਛਲੇ ਨਤੀਜਿਆਂ ਦੀ ਵਰਤੋਂ।

ਕਾਰਗਰ ਉਦਾਹਰਨ: ਟਰੈਵਲ ਏਜੰਟ ਵਿੱਚ SQL ਦੀ ਵਰਤੋਂ

ਯੂਜ਼ਰ ਪਸੰਦਾਂ ਇਕੱਠਾ ਕਰਨਾ

class Travel_Agent:
    def __init__(self):
        self.user_preferences = {}

    def gather_preferences(self, preferences):
        self.user_preferences = preferences

SQL ਕਵੈਰੀਜ਼ ਤਿਆਰ ਕਰਨਾ

def generate_sql_query(table, preferences):
    query = f"SELECT * FROM {table} WHERE "
    conditions = []
    for key, value in preferences.items():
        conditions.append(f"{key}='{value}'")
    query += " AND ".join(conditions)
    return query

SQL ਕਵੈਰੀਜ਼ ਚਲਾਉਣਾ

import sqlite3

def execute_sql_query(query, database="travel.db"):
    connection = sqlite3.connect(database)
    cursor = connection.cursor()
    cursor.execute(query)
    results = cursor.fetchall()
    connection.close()
    return results

ਸਿਫਾਰਿਸ਼ਾਂ ਤਿਆਰ ਕਰਨਾ

def generate_recommendations(preferences):
    flight_query = generate_sql_query("flights", preferences)
    hotel_query = generate_sql_query("hotels", preferences)
    attraction_query = generate_sql_query("attractions", preferences)
       
    flights = execute_sql_query(flight_query)
    hotels = execute_sql_query(hotel_query)
    attractions = execute_sql_query(attraction_query)
       
    itinerary = {
        "flights": flights,
        "hotels": hotels,
        "attractions": attractions
    }
    return itinerary

travel_agent = Travel_Agent()
preferences = {
    "destination": "Paris",
    "dates": "2025-04-01 to 2025-04-10",
    "budget": "moderate",
    "interests": ["museums", "cuisine"]
}
travel_agent.gather_preferences(preferences)
itinerary = generate_recommendations(preferences)
print("Suggested Itinerary:", itinerary)

ਉਦਾਹਰਨ SQL ਕਵੈਰੀਜ਼

ਉਡਾਣ ਕਵੈਰੀ

SELECT * FROM flights WHERE destination='Paris' AND dates='2025-04-01 to 2025-04-10' AND budget='moderate';

ਹੋਟਲ ਕਵੈਰੀ

SELECT * FROM hotels WHERE destination='Paris' AND budget='moderate';

ਆਕਰਸ਼ਣ ਕਵੈਰੀ

SELECT * FROM attractions WHERE destination='Paris' AND interests='museums, cuisine';

Retrieval-Augmented Generation (RAG) ਤਕਨਾਲੋਜੀ ਦੇ ਹਿੱਸੇ ਵਜੋਂ SQL ਦੀ ਵਰਤੋਂ ਕਰਕੇ, AI ਏਜੰਟਾਂ ਜਿਵੇਂ ਟਰੈਵਲ ਏਜੰਟ ਮੁਤਾਬਿਕ ਅਤੇ ਵਿਆਕਤੀਗਤ ਜਾਣਕਾਰੀ ਪ੍ਰਾਪਤ ਅਤੇ ਇਸਤੇਮਾਲ ਕਰ ਸਕਦੇ ਹਨ।

ਮੈਟਾਕੋਗਨੀਸ਼ਨ ਦੀ ਉਦਾਹਰਨ

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

ਅਸੀਂ ਇਸ ਨੂੰ ਇੱਕ ਮੁਢਲੀ ਉਦਾਹਰਨ ਨਾਲ ਸਿਮੂਲੇਟ ਕਰਾਂਗੇ ਜਿੱਥੇ ਏਜੰਟ ਕੀਮਤ ਅਤੇ ਗੁਣਵੱਤਾ ਦੇ ਮਿਲਾਪ ‘ਤੇ ਹੋਟਲ ਚੁਣਦਾ ਹੈ, ਪਰ ਇਹ ਆਪਣੇ ਫੈਸਲਿਆਂ ‘ਤੇ “ਵਿਚਾਰ” ਕਰਦਾ ਹੈ ਅਤੇ ਉਹਨਾਂ ਅਨੁਸਾਰ ਠੀਕ ਕਰਦਾ ਹੈ।

ਇਹ ਕਿਵੇਂ ਮੈਟਾਕੋਗਨੀਸ਼ਨ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ:

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

ਇੱਥੇ ਇੱਕ ਉਦਾਹਰਨ ਹੈ:

class HotelRecommendationAgent:
    def __init__(self):
        self.previous_choices = []  # ਪਹਿਲਾਂ ਚੁਣੇ ਹੋਟਲਾਂ ਨੂੰ ਸંગ્રਹਿਤ ਕਰਦਾ ਹੈ
        self.corrected_choices = []  # ਸਹੀ ਕੀਤੀਆਂ ਚੋਣਾਂ ਨੂੰ ਸંગ્રਹਿਤ ਕਰਦਾ ਹੈ
        self.recommendation_strategies = ['cheapest', 'highest_quality']  # ਉਪਲਬਧ ਰਣਨੀਤੀਆਂ

    def recommend_hotel(self, hotels, strategy):
        """
        Recommend a hotel based on the chosen strategy.
        The strategy can either be 'cheapest' or 'highest_quality'.
        """
        if strategy == 'cheapest':
            recommended = min(hotels, key=lambda x: x['price'])
        elif strategy == 'highest_quality':
            recommended = max(hotels, key=lambda x: x['quality'])
        else:
            recommended = None
        self.previous_choices.append((strategy, recommended))
        return recommended

    def reflect_on_choice(self):
        """
        Reflect on the last choice made and decide if the agent should adjust its strategy.
        The agent considers if the previous choice led to a poor outcome.
        """
        if not self.previous_choices:
            return "No choices made yet."

        last_choice_strategy, last_choice = self.previous_choices[-1]
        # ਆਓ ਮੰਨ ਲੈਂਦੇ ਹਾਂ ਕਿ ਸਾਨੂੰ ਕੁਝ ਉਪਭੋਗਤਾ ਫੀਡਬੈਕ ਮਿਲਿਆ ਹੈ ਜੋ ਦੱਸਦਾ ਹੈ ਕਿ ਆਖਰੀ ਚੋਣ ਚੰਗੀ ਸੀ ਜਾਂ ਨਹੀਂ
        user_feedback = self.get_user_feedback(last_choice)

        if user_feedback == "bad":
            # ਜੇ ਪਿਛਲੀ ਚੋਣ ਅਸੰਤੁਸ਼ਟਜਨਕ ਸੀ ਤਾਂ ਰਣਨੀਤੀ ਨੂੰ ਢਾਲੋ
            new_strategy = 'highest_quality' if last_choice_strategy == 'cheapest' else 'cheapest'
            self.corrected_choices.append((new_strategy, last_choice))
            return f"Reflecting on choice. Adjusting strategy to {new_strategy}."
        else:
            return "The choice was good. No need to adjust."

    def get_user_feedback(self, hotel):
        """
        Simulate user feedback based on hotel attributes.
        For simplicity, assume if the hotel is too cheap, the feedback is "bad".
        If the hotel has quality less than 7, feedback is "bad".
        """
        if hotel['price'] < 100 or hotel['quality'] < 7:
            return "bad"
        return "good"

# ਹੋਟਲਾਂ ਦੀ ਇੱਕ ਸੂਚੀ ਦੀ ਸਿਮੂਲੇਸ਼ਨ ਕਰੋ (ਕੀਮਤ ਅਤੇ ਗੁਣਵੱਤਾ)
hotels = [
    {'name': 'Budget Inn', 'price': 80, 'quality': 6},
    {'name': 'Comfort Suites', 'price': 120, 'quality': 8},
    {'name': 'Luxury Stay', 'price': 200, 'quality': 9}
]

# ਇੱਕ ਏਜੰਟ ਬਣਾਓ
agent = HotelRecommendationAgent()

# ਕਦਮ 1: ਏਜੰਟ "ਸਬ ਤੋਂ ਸਸਤਾ" ਰਣਨੀਤੀ ਵਰਤਦਾ ਹੋਇਆ ਹੋਟਲ ਦੀ ਸਿਫਾਰਿਸ਼ ਕਰਦਾ ਹੈ
recommended_hotel = agent.recommend_hotel(hotels, 'cheapest')
print(f"Recommended hotel (cheapest): {recommended_hotel['name']}")

# ਕਦਮ 2: ਏਜੰਟ ਚੋਣ 'ਤੇ ਵਿਚਾਰ ਕਰਦਾ ਹੈ ਅਤੇ ਜਰੂਰੀ ਹੋਵੇ ਤਾਂ ਰਣਨੀਤੀ ਨੂੰ ਢਾਲਦਾ ਹੈ
reflection_result = agent.reflect_on_choice()
print(reflection_result)

# ਕਦਮ 3: ਏਜੰਟ ਦੁਬਾਰਾ ਸਿਫਾਰਿਸ਼ ਕਰਦਾ ਹੈ, ਇਸ ਵਾਰੀ ਢਾਲੀ ਹੋਈ ਰਣਨੀਤੀ ਦੀ ਵਰਤੋਂ ਕਰਦਿਆਂ
adjusted_recommendation = agent.recommend_hotel(hotels, 'highest_quality')
print(f"Adjusted hotel recommendation (highest_quality): {adjusted_recommendation['name']}")

ਏਜੰਟਾਂ ਦੀ ਮੈਟਾਕੋਗਨੀਸ਼ਨ ਯੋਗਤਾਵਾਂ

ਮੁੱਖ ਗੱਲ ਏਜੰਟ ਦੀ ਇਹ ਯੋਗਤਾ ਹੈ ਕਿ:

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

ਇਹ ਮੈਟਾਕੋਗਨੀਸ਼ਨ ਦੀ ਇੱਕ ਸਧਾਰਣ ਰੂਪ ਹੈ ਜਿੱਥੇ ਸਿਸਟਮ ਆਪਣੀਆਂ ਅੰਦਰੂਨੀ ਪ੍ਰਤੀਕਿਰਿਆਵਾਂ ਦੇ ਆਧਾਰ ‘ਤੇ ਆਪਣਾ ਤਰਕ ਨਿਰਣਾ ਪ੍ਰਕਿਰਿਆ ਸੁਧਾਰ ਸਕਦਾ ਹੈ।

ਨਤੀਜਾ

ਮੈਟਾਕੋਗਨੀਸ਼ਨ ਇੱਕ ਸ਼ਕਤੀਸ਼ਾਲੀ ਸਧਨ ਹੈ ਜੋ AI ਏਜੰਟਾਂ ਦੀ ਸਮਰੱਥਾ ਨੂੰ ਬਹੁਤ ਵਧਾ ਸਕਦਾ ਹੈ। ਮੈਟਾਕੋਗਨੀਸ਼ਨ ਪ੍ਰਕਿਰਿਆਵਾਂ ਸ਼ਾਮਲ ਕਰਕੇ, ਤੁਸੀਂ ਹੋਰ ਬੁੱਧੀਮਾਨ, ਅਨੁਕੂਲ ਅਤੇ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਏਜੰਟ ਡਿਜ਼ਾਈਨ ਕਰ ਸਕਦੇ ਹੋ। ਵੱਧ ਜਾਣਕਾਰੀ ਲਈ ನೀಡಿದ್ದಾರೆ ਗਏ ਸਰੋਤਾਂ ਦਾ ਅਧਿਐਨ ਜਾਰੀ ਰੱਖੋ ਅਤੇ AI ਏਜੰਟਾਂ ਵਿੱਚ ਮੈਟਾਕੋਗਨੀਸ਼ਨ ਦੀ ਦਿਲਚਸਪ ਦੁਨੀਆ ਨੂੰ ਖੋਜੋ।

ਮੈਟਾਕੋਗਨੀਸ਼ਨ ਡਿਜ਼ਾਈਨ ਪੈਟਰਨ ਬਾਰੇ ਹੋਰ ਸਵਾਲਾਂ ਹਨ?

ਹੋਰ ਸਿਖਣ ਵਾਲਿਆਂ ਨਾਲ ਮਿਲਣ, ਦਫਤਰ ਸਮਾਂ ਵਿੱਚ ਸ਼ਿਰਕਤ ਕਰਨ ਅਤੇ ਆਪਣੀਆਂ AI ਏਜੰਟਾਂ ਸੰਬੰਧੀ ਸਵਾਲਾਂ ਦੇ ਜਵਾਬ ਲੈਣ ਲਈ Microsoft Foundry Discord ਵਿੱਚ ਸ਼ਾਮਿਲ ਹੋਵੋ।

ਪਹਿਲਾ ਪਾਠ

ਮਲਟੀ-ਏਜੰਟ ਡਿਜ਼ਾਈਨ ਪੈਟਰਨ

ਅਗਲਾ ਪਾਠ

ਉਤਪਾਦਨ ਵਿੱਚ AI ਏਜੰਟ

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

This site is open source. Improve this page.