ਲਾਭ:
- ਇੱਕ ਏਜੰਟ ਨੂੰ 'ਮਾਡਲ + ਟੂਲਸ + ਲੂਪ' ਵਜੋਂ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨਾ ਅਤੇ ਇਹ ਫੈਸਲਾ ਕਰਨਾ ਕਿ ਕਦੋਂ ਇਸਦੀ ਲੋੜ ਹੋਵੇ
- ਨਾਮ, ਵਰਣਨ ਅਤੇ ਇਨਪੁਟ_ਸਕੀਮਾ ਨਾਲ ਟੂਲ ਪਰਿਭਾਸ਼ਾ ਨੂੰ ਲਿਖਣਾ
- ਟੂਲ_ਯੂਜ਼ ਅਤੇ ਟੂਲ_ਰਿਜ਼ਲਟ ਲੂਪ ਦੇ ਪ੍ਰਵਾਹ ਅਤੇ ਗਲਤੀ ਦੇ ਪ੍ਰਬੰਧਨ ਦੀ ਨਿਗਰਾਨੀ ਕਰਨਾ
ਹੁਣ ਤੱਕ, ਮਾਡਲ ਨੇ ਹਮੇਸ਼ਾ ਇੱਕ ਕੰਮ ਕੀਤਾ ਹੈ: ਟੈਕਸਟ ਇਨਪੁਟ ਪ੍ਰਾਪਤ ਕਰੋ, ਟੈਕਸਟ ਜਵਾਬ ਤਿਆਰ ਕਰੋ। ਪਰ ਅਸਲ ਕੰਮ ਲਈ ਅਕਸਰ ਟੈਕਸਟ ਤੋਂ ਵੱਧ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ; ਇੱਕ ਗਣਨਾ ਕਰਨਾ, ਇੱਕ ਡੇਟਾਬੇਸ ਦੀ ਪੁੱਛਗਿੱਛ ਕਰਨਾ, ਇੱਕ API ਨੂੰ ਕਾਲ ਕਰਨਾ, ਇੱਕ ਮੌਜੂਦਾ ਐਕਸਚੇਂਜ ਦਰ ਦਾ ਪਤਾ ਲਗਾਉਣਾ। ਮਾਡਲ ਇਹ ਚੀਜ਼ਾਂ ਖੁਦ ਨਹੀਂ ਕਰ ਸਕਦੀ - ਪਰ ਉਹ ਇਹ ਫੈਸਲਾ ਕਰ ਸਕਦੀ ਹੈ ਕਿ ਉਹਨਾਂ ਨੂੰ ਕਦੋਂ ਕਰਨ ਦੀ ਲੋੜ ਹੈ ਅਤੇ ਕਿਸੇ ਨੂੰ ਇਹ ਕਰਨ ਲਈ ਕਹਿ ਸਕਦੀ ਹੈ। ਇਹ ਉਹ ਹੈ ਜੋ ਟੂਲ ਦੀ ਵਰਤੋਂ ਮਾਡਲ ਦਿੰਦੀ ਹੈ, ਅਤੇ ਇਹ ਏਆਈ ਏਜੰਟਾਂ ਦਾ ਆਧਾਰ ਹੈ। ਇਸ ਯੂਨਿਟ ਵਿੱਚ, ਅਸੀਂ ਸਿੱਖਾਂਗੇ ਕਿ ਏਜੰਟ ਕੀ ਹੁੰਦਾ ਹੈ, ਟੂਲ ਨੂੰ ਕਿਵੇਂ ਪਰਿਭਾਸ਼ਿਤ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਅਤੇ ਟੂਲ_ਯੂਜ਼ ਲੂਪ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ।
ਇੱਕ ਏਜੰਟ ਕੀ ਹੈ? ਮਾਡਲ + ਟੂਲਸ + ਲੂਪ
ਇੱਕ AI ਏਜੰਟ ਵਿੱਚ ਤਿੰਨ ਭਾਗ ਹੁੰਦੇ ਹਨ: ਮਾਡਲ (ਦਿਮਾਗ ਜੋ ਫੈਸਲਾ ਲੈਂਦਾ ਹੈ), ਟੂਲ (ਫੰਕਸ਼ਨ ਜਿਨ੍ਹਾਂ ਨੂੰ ਮਾਡਲ ਕਾਲ ਕਰ ਸਕਦਾ ਹੈ: ਮੌਸਮ, ਡੇਟਾਬੇਸ ਪੁੱਛਗਿੱਛ, ਈਮੇਲ ਭੇਜੋ), ਅਤੇ ਲੂਪ (ਲੂਪ; ਮਾਡਲ ਟੂਲ ਨੂੰ ਕਾਲ ਕਰਦਾ ਹੈ, ਨਤੀਜਾ ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ, ਦੁਬਾਰਾ ਫੈਸਲਾ ਕਰਦਾ ਹੈ ਕਿ ਕੀ ਕਰਨਾ ਹੈ, ਅਤੇ ਹੋਰ)।
ਗੰਭੀਰ ਅੰਤਰ: ਇੱਕ ਸਿੰਗਲ ਪੈਟਰਨ ਕਾਲ ਇੱਕ ਏਜੰਟ ਨਹੀਂ ਹੈ। ਏਜੰਟ ਇੱਕ ਪ੍ਰਕਿਰਿਆ ਹੈ ਜਿਸ ਵਿੱਚ ਮਾਡਲ ਕਦਮ-ਦਰ-ਕਦਮ ਅੱਗੇ ਵਧਦਾ ਹੈ, ਹਰ ਪੜਾਅ 'ਤੇ ਟੂਲ ਨਤੀਜੇ ਦੇ ਆਧਾਰ 'ਤੇ ਅਗਲੀ ਚਾਲ ਦੀ ਚੋਣ ਕਰਦਾ ਹੈ। "ਇਨਸਾਨ ਵਾਂਗ ਸੋਚੋ, ਆਪਣੇ ਹੱਥਾਂ ਦੀ ਵਰਤੋਂ ਕਰੋ, ਨਤੀਜਾ ਦੇਖੋ, ਦੁਬਾਰਾ ਸੋਚੋ।"
ਇੱਕ ਮਹੱਤਵਪੂਰਨ ਤੱਥ: ਮਾਡਲ ਖੁਦ ਵਾਹਨ ਨਹੀਂ ਚਲਾਉਂਦਾ. ਮਾਡਲ ਸਿਰਫ਼ ਕਹਿੰਦਾ ਹੈ "ਮੈਂ ਇਹਨਾਂ ਇਨਪੁਟਸ ਨਾਲ ਇਸ ਟੂਲ ਨੂੰ ਕਾਲ ਕਰਨਾ ਚਾਹੁੰਦਾ ਹਾਂ"। ਤੁਹਾਡੀ ਐਪਲੀਕੇਸ਼ਨ (ਜਿਸ ਨੂੰ ਹਾਰਨੇਸ ਕਿਹਾ ਜਾਂਦਾ ਹੈ) ਟੂਲ ਨੂੰ ਚਲਾਉਂਦਾ ਹੈ ਅਤੇ ਨਤੀਜਾ ਮਾਡਲ ਨੂੰ ਵਾਪਸ ਕਰਦਾ ਹੈ। ਇਹ ਸੁਰੱਖਿਆ ਲਈ ਬਹੁਤ ਜ਼ਰੂਰੀ ਹੈ: ਮਾਡਲ ਸਿੱਧੇ ਤੁਹਾਡੇ ਸਿਸਟਮ ਨੂੰ ਨਹੀਂ ਛੂਹਦਾ; ਹਰ ਕਿਰਿਆ ਤੇਰੇ ਅਧੀਨ ਹੈ।
ਸੁਝਾਅ: ਏਜੰਟ ਨਾਲ ਹਰ ਸਮੱਸਿਆ ਨੂੰ ਹੱਲ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਨਾ ਕਰੋ। ਏਜੰਟ; ਦੇਰੀ, ਲਾਗਤਾਂ ਅਤੇ ਗਲਤੀਆਂ ਦੇ ਜੋਖਮ ਨੂੰ ਵਧਾਉਂਦਾ ਹੈ। ਪਹਿਲਾਂ ਪੁੱਛੋ: "ਕੀ ਇਹ ਇੱਕ ਸਿੰਗਲ ਕਾਲ ਜਾਂ ਇੱਕ ਨਿਸ਼ਚਿਤ ਵਰਕਫਲੋ ਨਾਲ ਹੱਲ ਕੀਤਾ ਜਾਵੇਗਾ?" ਜੇਕਰ ਜਵਾਬ ਹਾਂ ਵਿੱਚ ਹੈ, ਤਾਂ ਕਿਸੇ ਏਜੰਟ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ। ਏਜੰਟ ਓਪਨ-ਐਂਡ ਕਾਰਜਾਂ ਲਈ ਹੈ ਜਿੱਥੇ ਕਦਮ ਪਹਿਲਾਂ ਤੋਂ ਨਹੀਂ ਜਾਣੇ ਜਾ ਸਕਦੇ ਹਨ।
ਟੂਲ ਪਰਿਭਾਸ਼ਾ: ਨਾਮ, ਵਰਣਨ, ਇਨਪੁਟ_ਸਕੀਮਾ
ਮਾਡਲ ਵਿੱਚ ਇੱਕ ਟੂਲ ਪੇਸ਼ ਕਰਨ ਲਈ, ਤੁਸੀਂ ਤਿੰਨ ਚੀਜ਼ਾਂ ਦਿੰਦੇ ਹੋ:
- ਨਾਮ: ਵਾਹਨ ਦੀ ਪਛਾਣ, ਉਦਾਹਰਨ ਲਈ get_weather।
- ਵਰਣਨ: ਟੂਲ ਕੀ ਕਰਦਾ ਹੈ ਅਤੇ ਇਸਨੂੰ ਕਦੋਂ ਕਾਲ ਕਰਨਾ ਹੈ। ਇਹ ਸਭ ਤੋਂ ਮਹੱਤਵਪੂਰਨ ਖੇਤਰ ਹੈ ਜੋ ਮਾਡਲ ਨੂੰ ਸਹੀ ਸਮੇਂ 'ਤੇ ਸਹੀ ਟੂਲ ਚੁਣਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ. ਨਾ ਸਿਰਫ਼ "ਕੀ ਕਰਦਾ ਹੈ" ਸਗੋਂ "ਕਦੋਂ ਕਾਲ ਕਰੋ" ਵੀ ਲਿਖੋ।
- input_schema (ਇਨਪੁਟ ਸਕੀਮਾ): JSON ਸਕੀਮਾ ਜੋ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦੀ ਹੈ ਕਿ ਟੂਲ ਕਿਹੜੇ ਪੈਰਾਮੀਟਰਾਂ ਦੀ ਉਮੀਦ ਕਰਦਾ ਹੈ, ਕਿਸ ਕਿਸਮ ਵਿੱਚ।
# ਵਾਹਨ ਦੀ ਪਰਿਭਾਸ਼ਾ (ਸੰਕਲਪਿਕ — JSON ਸਕੀਮਾ){ "ਨਾਮ": "get_order_status", "description": "ਕਿਸੇ ਆਰਡਰ ਦੀ ਮੌਜੂਦਾ ਸ਼ਿਪਿੰਗ ਸਥਿਤੀ ਨੂੰ ਮੁੜ ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ। ਕਾਲ ਕਰੋ ਜਦੋਂ ਉਪਭੋਗਤਾ ਪੁੱਛਦਾ ਹੈ ਕਿ ਆਰਡਰ ਨੰਬਰ ਕਿੱਥੇ ਹੈ ਜਾਂ ਇਹ ਕਦੋਂ ਆਵੇਗਾ।", "ਇਨਪੁਟ_ਸਕੀਮਾ": { "type": "object", "properties": "description": "description": "description": "{description": " "ਆਰਡਰ ਨੰਬਰ, ਉਦਾਹਰਨ ਲਈ SP-1024"} }, "ਲੋੜੀਂਦਾ": ["order_no"] }}
ਇੱਕ ਚੰਗੇ ਟੂਲ ਦੇ ਵਰਣਨ ਲਈ ਨਿਯਮ: ਸਪਸ਼ਟ ਅਤੇ ਸੰਖੇਪ ਨਾਮ, "ਕਦੋਂ ਵਰਤਣਾ ਹੈ" ਦੇ ਨਾਲ ਵਰਣਨ, ਹਰੇਕ ਮਾਪਦੰਡ ਲਈ ਵਰਣਨ, ਅਸਲ ਵਿੱਚ ਲਾਜ਼ਮੀ ਤੌਰ 'ਤੇ ਲੋੜੀਂਦੀਆਂ ਚੀਜ਼ਾਂ ਨੂੰ ਸ਼ਾਮਲ ਕਰਨਾ। ਵਾਹਨਾਂ ਦੀ ਗਿਣਤੀ ਕੇਂਦਰਿਤ ਰੱਖੋ; ਇਸੇ ਤਰ੍ਹਾਂ ਦੇ ਵਾਹਨਾਂ ਦੇ ਦਰਜਨਾਂ ਮਾਡਲ ਹੈਰਾਨੀਜਨਕ ਹਨ।
ਖੇਤਰ
ਇਹ ਕੀ ਕਰਦਾ ਹੈ?
ਚੰਗੀ ਉਦਾਹਰਨ
ਬੁਰਾ ਉਦਾਹਰਨ
ਨਾਮ
ਵਾਹਨ ਆਈ.ਡੀ
ਆਰਡਰ_ਸਟੇਟਸ_ਗੇਟਿਰ
ਲਿਆਓ
ਵਰਣਨ
ਇਹ ਕੀ ਕਰਦਾ ਹੈ + ਕਦੋਂ ਕਾਲ ਕਰਨਾ ਹੈ
"ਕਾਰਗੋ ਸਥਿਤੀ ਵਾਪਸ ਕਰਦਾ ਹੈ; ਕਾਲ ਕਰੋ ਜਦੋਂ ਉਪਭੋਗਤਾ ਪੁੱਛਦਾ ਹੈ ਕਿ ਆਰਡਰ ਕਿੱਥੇ ਹੈ"
"ਡਾਟਾ ਲਿਆਉਂਦਾ ਹੈ"
input_schema
ਪੈਰਾਮੀਟਰ ਦੀ ਕਿਸਮ ਅਤੇ ਲੋੜ
{order_no: string, annotated}
ਕੋਈ ਚਿੱਤਰ/ਕੋਈ ਵੇਰਵਾ ਨਹੀਂ
tool_use → tool_result ਲੂਪ
ਚੱਕਰ ਇਸ ਤਰ੍ਹਾਂ ਕੰਮ ਕਰਦਾ ਹੈ, ਕਦਮ ਦਰ ਕਦਮ:
- ਤੁਸੀਂ ਮਾਡਲ ਨੂੰ ਉਪਭੋਗਤਾ ਪ੍ਰਸ਼ਨ + ਟੂਲ ਵਰਣਨ ਭੇਜਦੇ ਹੋ।
- ਮਾਡਲ ਜਾਂ ਤਾਂ ਸਿੱਧਾ ਜਵਾਬ ਦਿੰਦਾ ਹੈ ਜਾਂ ਇੱਕ ਟੂਲ_ਯੂਜ਼ ਬਲਾਕ ਤਿਆਰ ਕਰਦਾ ਹੈ: "ਆਰਡਰ_ਨੋ=SP-1024 ਨਾਲ ਆਰਡਰ_ਦੁਰੁਮੁ_ਗੇਟੀਰ ਨੂੰ ਕਾਲ ਕਰੋ।"
- ਤੁਹਾਡੀ ਐਪਲੀਕੇਸ਼ਨ ਅਸਲ ਵਿੱਚ ਟੂਲ ਨੂੰ ਚਲਾਉਂਦੀ ਹੈ (ਡੇਟਾਬੇਸ ਦੀ ਪੁੱਛਗਿੱਛ)
- ਤੁਸੀਂ ਟੂਲ_ਰਿਜ਼ਲਟ ਵਜੋਂ ਨਤੀਜਾ ਮਾਡਲ ਨੂੰ ਵਾਪਸ ਭੇਜਦੇ ਹੋ।
- ਇਸ ਨਤੀਜੇ ਦੇ ਨਾਲ, ਮਾਡਲ ਜਾਂ ਤਾਂ ਅੰਤਮ ਜਵਾਬ ਪੈਦਾ ਕਰਦਾ ਹੈ ਜਾਂ ਕਿਸੇ ਹੋਰ ਟੂਲ ਨੂੰ ਕਾਲ ਕਰਦਾ ਹੈ। ਚੱਕਰ ਉਦੋਂ ਤੱਕ ਜਾਰੀ ਰਹਿੰਦਾ ਹੈ ਜਦੋਂ ਤੱਕ ਮਾਡਲ "ਮੈਂ ਹੋ ਗਿਆ" ਨਹੀਂ ਕਹਿੰਦਾ।
# ਏਜੰਟ ਲੂਪ (ਸੰਕਲਪਿਕ) ਸੁਨੇਹੇ = [ਉਪਭੋਗਤਾ_ਸਵਾਲ] ਜਦੋਂ ਕਿ ਇਹ ਸੱਚ ਹੈ: ਜਵਾਬ = model.uret(messages, tools=tool_definitions) if response.tur == "ਟੂਲ_ਉਪਯੋਗ": ਨਤੀਜਾ = harness.run(response.tool_name, response.entries) # APPLICATION ਸੁਨੇਹੇ ਚਲਾਉਂਦਾ ਹੈ, # ਅੰਤਮ-ਰਿਜ਼ਲਟ ਰਿਟਰਨ ਟੂਲ +=ਰਿਜ਼ਲਟ ਰਿਟਰਨ; ਜਵਾਬ; ਲੂਪ ਸਿਰੇ
ਆਧੁਨਿਕ SDK ਟੂਲ ਦੌੜਾਕਾਂ ਦੀ ਪੇਸ਼ਕਸ਼ ਕਰਦੇ ਹਨ ਜੋ ਤੁਹਾਡੇ ਲਈ ਇਸ ਲੂਪ ਨੂੰ ਚਲਾਉਂਦੇ ਹਨ; ਤੁਸੀਂ ਸਿਰਫ਼ ਟੂਲ ਫੰਕਸ਼ਨ ਲਿਖੋ। ਪਰ ਪਰਦੇ ਪਿੱਛੇ ਅਜਿਹਾ ਹੀ ਹੋ ਰਿਹਾ ਹੈ।
ਗਲਤੀ ਪ੍ਰਬੰਧਨ
ਟੂਲ ਫੇਲ ਹੋ ਸਕਦੇ ਹਨ: ਆਰਡਰ ਨਹੀਂ ਮਿਲਿਆ, API ਸਮਾਂ ਖਤਮ ਹੋ ਗਿਆ, ਇਨਪੁਟ ਅਵੈਧ ਹੈ। ਜੇਕਰ ਤੁਸੀਂ ਟੂਲ ਨਹੀਂ ਚਲਾ ਸਕਦੇ ਹੋ, ਤਾਂ ਮਾੱਡਲ ਨੂੰ ਵਰਣਨਯੋਗ ਟੂਲ_ਨਤੀਜੇ ਵਜੋਂ ਗਲਤੀ ਵਾਪਸ ਕਰੋ ("ਗਲਤੀ: ਆਰਡਰ ਨੰਬਰ SP-9999 ਨਹੀਂ ਮਿਲਿਆ") ਅਤੇ ਗਲਤੀ ਫਲੈਗ। ਮਾਡਲ ਇਸਨੂੰ ਦੇਖ ਸਕਦਾ ਹੈ ਅਤੇ ਉਪਭੋਗਤਾ ਨੂੰ ਹੌਲੀ-ਹੌਲੀ ਸਮਝਾ ਸਕਦਾ ਹੈ, ਜਾਂ ਕਿਸੇ ਹੋਰ ਤਰੀਕੇ ਨਾਲ ਕੋਸ਼ਿਸ਼ ਕਰ ਸਕਦਾ ਹੈ। ਗਲਤੀ ਨੂੰ ਨਿਗਲ ਨਾ ਕਰੋ ਅਤੇ ਖਾਲੀ ਨਤੀਜੇ ਵਾਪਸ ਨਾ ਕਰੋ; ਮਾਡਲ ਨੂੰ ਪਤਾ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ ਕਿ ਕੀ ਗਲਤ ਹੋਇਆ ਹੈ.
ਕਮਜ਼ੋਰ/ਮਜ਼ਬੂਤ ਵਾਹਨ ਦਾ ਵਰਣਨ
ਕਮਜ਼ੋਰ (ਅਨਿਸ਼ਚਿਤ ਨਾਂਵ, "ਕਦੋਂ" ਨਹੀਂ):
name: "data", description: "data ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ"# ਮਾਡਲ ਨੂੰ ਇਹ ਨਹੀਂ ਪਤਾ ਕਿ ਕਦੋਂ ਅਤੇ ਕਿਵੇਂ ਕਾਲ ਕਰਨੀ ਹੈ; ਇਹ ਜਾਂ ਤਾਂ ਬਿਲਕੁਲ ਕਾਲ ਨਹੀਂ ਕਰਦਾ ਜਾਂ ਗਲਤ ਕਾਲ ਕਰਦਾ ਹੈ।
ਮਜ਼ਬੂਤ (ਨੈੱਟ ਨਾਮ + ਜਦੋਂ + ਪੈਰਾਮੀਟਰ ਵੇਰਵਾ):
name: "musteri_bakiyesi_getir" ਵਰਣਨ: "ਕਿਸੇ ਗਾਹਕ ਦੇ ਮੌਜੂਦਾ ਖਾਤੇ ਦਾ ਬਕਾਇਆ ਵਾਪਸ ਕਰਦਾ ਹੈ। ਜਦੋਂ ਉਪਭੋਗਤਾ ਡੈਬਿਟ, ਕ੍ਰੈਡਿਟ ਜਾਂ ਬਕਾਇਆ ਲਈ ਪੁੱਛਦਾ ਹੈ ਤਾਂ ਕਾਲ ਕਰੋ। ਭੁਗਤਾਨ ਨਹੀਂ ਕਰਦਾ।"input_schema: {custeri_id: string ("ਗਾਹਕ ID")}# ਮਾਡਲ ਸਹੀ ਸਮੇਂ 'ਤੇ ਕਾਲ ਕਰਦਾ ਹੈ, ਇਸਦੇ ਸਹੀ ਮਾਪਦੰਡਾਂ ਦੇ ਨਾਲ, ਜਾਣਦਾ ਹੈ।
ਤਿੰਨ ਮਿੰਨੀ ਕੇਸ
ਕੇਸ 1 - ਬੇਲੋੜਾ ਏਜੰਟ। ਇੱਕ ਟੀਮ ਨੇ ਇੱਕ ਮਲਟੀ-ਟੂਲ ਏਜੰਟ ਦੇ ਨਾਲ "ਸੰਖੇਪ ਪਾਠ" ਕਾਰੋਬਾਰ ਬਣਾਇਆ; ਹਰੇਕ ਰੀਕੈਪ ਵਿੱਚ 4 ਮਾਡਲ ਕਾਲਾਂ ਅਤੇ 9 ਸਕਿੰਟ ਲੱਗਦੇ ਹਨ। ਨੌਕਰੀ ਅਸਲ ਵਿੱਚ ਇੱਕ-ਕਾਲ ਦੀ ਨੌਕਰੀ ਸੀ। ਜਦੋਂ ਅਸੀਂ ਏਜੰਟ ਨੂੰ ਹਟਾ ਦਿੱਤਾ ਅਤੇ ਇਸਨੂੰ ਇੱਕ ਸਿੰਗਲ ਕਾਲ ਵਿੱਚ ਘਟਾ ਦਿੱਤਾ, ਤਾਂ ਸਮਾਂ ਘਟ ਕੇ 1.5 ਸਕਿੰਟ ਹੋ ਗਿਆ ਅਤੇ ਲਾਗਤ ਇੱਕ ਚੌਥਾਈ ਤੱਕ ਘਟ ਗਈ। ਸਬਕ: ਅਸਲ ਵਿੱਚ ਲੋੜ ਪੈਣ 'ਤੇ ਏਜੰਟ ਦੀ ਵਰਤੋਂ ਕਰੋ।
ਕੇਸ 2 - ਕਮਜ਼ੋਰ ਵਿਆਖਿਆ, ਗਲਤ ਕਾਲ। ਇੱਕ ਸਹਾਇਤਾ ਏਜੰਟ ਵਿੱਚ, ਇੱਕ ਅਸਪਸ਼ਟ ਟੂਲ ਜਿਸਨੂੰ ਫੈਚ ਕਿਹਾ ਜਾਂਦਾ ਹੈ, ਨੂੰ ਬੈਲੈਂਸ ਸਵਾਲ ਅਤੇ ਸ਼ਿਪਿੰਗ ਸਵਾਲ ਦੋਵਾਂ ਵਿੱਚ ਮਾਡਲ ਦੁਆਰਾ ਬੇਤਰਤੀਬੇ ਤੌਰ 'ਤੇ ਬੁਲਾਇਆ ਗਿਆ ਸੀ। ਜਦੋਂ ਵਾਹਨਾਂ ਨੂੰ ਸੰਤੁਲਨ_ਗੇਟੀਰ ਅਤੇ ਕਾਰਗੋ_ਦੁਰੁਮੁ_ਗੇਟੀਰ ਵਿੱਚ ਵੰਡਿਆ ਗਿਆ ਸੀ ਅਤੇ "ਕਾਲ ਕਦੋਂ" ਸਪੱਸ਼ਟੀਕਰਨ ਜੋੜਿਆ ਗਿਆ ਸੀ, ਤਾਂ ਗਲਤ ਵਾਹਨ ਚੋਣ 50 ਉਦਾਹਰਣਾਂ ਵਿੱਚੋਂ 18 ਤੋਂ ਘਟ ਕੇ 1 ਹੋ ਗਈ।
ਕੇਸ 3 - ਗਲਤੀ ਨਿਗਲ ਗਈ। ਜਦੋਂ ਆਰਡਰ ਨਹੀਂ ਮਿਲਿਆ ਤਾਂ ਇੱਕ ਏਜੰਟ ਖਾਲੀ ਨਤੀਜੇ ਵਾਪਸ ਕਰ ਰਿਹਾ ਸੀ; ਮਾਡਲ ਨੇ ਇਸਦੀ ਵਿਆਖਿਆ "ਆਰਡਰ ਡਿਲੀਵਰ ਕੀਤਾ ਗਿਆ ਸੀ" ਵਜੋਂ ਕੀਤਾ ਅਤੇ ਗਾਹਕ ਨੂੰ ਗੁੰਮਰਾਹ ਕੀਤਾ। ਜਦੋਂ ਗਲਤੀ ਸੁਨੇਹਾ tool_result ("ਆਰਡਰ ਨਹੀਂ ਮਿਲਿਆ") 'ਤੇ ਸਪੱਸ਼ਟ ਤੌਰ 'ਤੇ ਲਿਖਿਆ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਮਾਡਲ ਸਹੀ ਢੰਗ ਨਾਲ ਕਹਿੰਦਾ ਹੈ "ਮੈਨੂੰ ਇਹ ਨੰਬਰ ਨਹੀਂ ਮਿਲਿਆ, ਕੀ ਤੁਸੀਂ ਇਸ ਦੀ ਜਾਂਚ ਕਰ ਸਕਦੇ ਹੋ?" ਉਸਨੇ ਕਹਿਣਾ ਸ਼ੁਰੂ ਕੀਤਾ।
ਆਮ ਗਲਤੀਆਂ
- ਹਰ ਚੀਜ਼ ਨੂੰ ਏਜੰਟ ਵੱਲ ਮੋੜਨਾ: ਜਦੋਂ ਕਿ ਇੱਕ ਕਾਲ ਕਾਫ਼ੀ ਹੁੰਦੀ ਹੈ, ਏਜੰਟ ਲਾਗਤ ਅਤੇ ਦੇਰੀ ਜੋੜਦਾ ਹੈ।
- ਅਸਪਸ਼ਟ ਵਾਹਨ ਵਰਣਨ: ਮਾਡਲ ਨੂੰ ਪਤਾ ਨਹੀਂ ਕਿ ਕਦੋਂ ਕਾਲ ਕਰਨੀ ਹੈ; ਗਲਤ ਚੁਣਦਾ ਹੈ।
- ਇਹ ਸੋਚ ਕੇ ਕਿ ਮਾਡਲ ਵਾਹਨ ਚਲਾਉਂਦਾ ਹੈ: ਹਾਰਨੈੱਸ ਗੱਡੀ ਚਲਾਉਂਦਾ ਹੈ; ਮਾਡਲ ਸਿਰਫ਼ ਚਾਹੁੰਦਾ ਹੈ.
- ਗਲਤੀ ਨੂੰ ਨਿਗਲਣਾ: ਮਾਡਲ ਨੂੰ ਪਤਾ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ ਕਿ ਕੀ ਗਲਤ ਹੋਇਆ ਹੈ; ਓਪਨ ਟੂਲ_ਰਿਜ਼ਲਟ ਵਜੋਂ ਗਲਤੀ ਦਿਓ।
- ਬਹੁਤ ਸਾਰੇ ਸਮਾਨ ਵਾਹਨ: ਮਾਡਲ ਉਲਝਣ ਵਿੱਚ ਪੈ ਜਾਂਦਾ ਹੈ; ਟੂਲਸੈੱਟ ਨੂੰ ਫੋਕਸ ਅਤੇ ਨਿਊਨਤਮ ਰੱਖੋ।
ਧਿਆਨ ਦਿਓ: ਸਿਰਫ਼ ਕਿਉਂਕਿ ਮਾਡਲ ਕਹਿੰਦਾ ਹੈ "ਉਸ ਵਾਹਨ ਨੂੰ ਕਾਲ ਕਰੋ" ਦਾ ਮਤਲਬ ਇਹ ਨਹੀਂ ਹੈ ਕਿ ਕਾਰਵਾਈ ਕੀਤੀ ਜਾਣੀ ਚਾਹੀਦੀ ਹੈ। ਵਿਨਾਸ਼ਕਾਰੀ ਸਾਧਨਾਂ (ਮਿਟਾਓ, ਚੈੱਕਆਉਟ, ਈਮੇਲ) 'ਤੇ ਤੁਹਾਡੀ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਕਾਲ ਨੂੰ ਅੰਨ੍ਹੇਵਾਹ ਨਹੀਂ ਚਲਾਉਣਾ ਚਾਹੀਦਾ - ਇਹ ਅਗਲੀ ਇਕਾਈ ਵਿੱਚ ਸੁਰੱਖਿਆ ਵਿਸ਼ੇ ਦਾ ਮੁੱਖ ਹਿੱਸਾ ਹੈ।
ਸੰਖੇਪ ਵਿੱਚ
- ਏਜੰਟ = ਮਾਡਲ (ਫੈਸਲਾ) + ਟੂਲ (ਫੰਕਸ਼ਨ) + ਲੂਪ (ਕਾਲ ਟੂਲ, ਨਤੀਜਾ ਪ੍ਰਾਪਤ ਕਰੋ, ਦੁਬਾਰਾ ਫੈਸਲਾ ਕਰੋ)।
- ਇੱਕ ਸਿੰਗਲ ਪੈਟਰਨ ਕਾਲ ਇੱਕ ਏਜੰਟ ਨਹੀਂ ਹੈ; ਏਜੰਟ ਇੱਕ ਕਦਮ-ਦਰ-ਕਦਮ ਪ੍ਰਕਿਰਿਆ ਹੈ।
- ਮਾਡਲ ਵਾਹਨ ਨਹੀਂ ਚਲਾਉਂਦਾ; ਤੁਹਾਡੀ ਐਪਲੀਕੇਸ਼ਨ ਚਲਦੀ ਹੈ (ਹਾਰਨੈੱਸ) ਅਤੇ ਟੂਲ_ਨਤੀਜੇ ਵਜੋਂ ਨਤੀਜਾ ਵਾਪਸ ਕਰਦੀ ਹੈ।
- ਟੂਲ ਦੀ ਪਛਾਣ ਨਾਮ, ਵਰਣਨ (ਖਾਸ ਤੌਰ 'ਤੇ "ਕਦੋਂ ਕਾਲ ਕਰੋ"), ਅਤੇ input_schema ਦੁਆਰਾ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।
- ਲੂਪ ਟੂਲ_ਉਪਯੋਗ → ਹਾਰਨੈੱਸ ਰਨ → ਟੂਲ_ਨਤੀਜਾ → ਮਾਡਲ ਜਾਰੀ ਰਹਿੰਦਾ ਹੈ ਜਦੋਂ ਤੱਕ ਮਾਡਲ "ਹੋ ਗਿਆ" ਨਹੀਂ ਕਹਿੰਦਾ; ਗਲਤੀਆਂ ਦੀ ਸਪੱਸ਼ਟ ਰੂਪ ਵਿੱਚ ਮਾਡਲ ਨੂੰ ਰਿਪੋਰਟ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।
ਐਪਲੀਕੇਸ਼ਨ ਦਾ ਕੰਮ
ਆਪਣੇ ਖੁਦ ਦੇ ਕਾਰੋਬਾਰ ਤੋਂ 3 ਟੂਲ ਡਿਜ਼ਾਈਨ ਕਰੋ ਜੋ ਏਜੰਟ ਨੂੰ ਦਿੱਤੇ ਜਾ ਸਕਦੇ ਹਨ। (1) ਹਰ ਇੱਕ ਲਈ ਨਾਮ, "ਕਾਲ ਕਦੋਂ" ਦੇ ਨਾਲ ਵਰਣਨ ਅਤੇ ਇਨਪੁਟ_ਸਕੀਮਾ ਲਿਖੋ; ਘੱਟੋ-ਘੱਟ ਇੱਕ ਨੂੰ ਗੈਰ-ਵਿਨਾਸ਼ਕਾਰੀ ਰੀਡਿੰਗ ਟੂਲ ਅਤੇ ਇੱਕ ਗਣਨਾ ਹੋਣ ਦਿਓ। (2) ਇੱਕ ਯਥਾਰਥਵਾਦੀ ਉਪਭੋਗਤਾ ਪ੍ਰਸ਼ਨ ਚੁਣੋ ਅਤੇ ਹੱਥੀਂ ਲਿਖੋ ਕਦਮ ਦਰ ਕਦਮ (ਇੱਕ ਲੂਪ ਵਿੱਚ) ਇਹਨਾਂ ਵਿੱਚੋਂ ਕਿਹੜਾ ਟੂਲ ਮਾਡਲ ਕਿਸ ਇਨਪੁਟਸ ਨਾਲ ਕਾਲ ਕਰੇਗਾ ਅਤੇ tool_result ਆਉਣ ਤੋਂ ਬਾਅਦ ਇਹ ਕੀ ਕਰੇਗਾ। (3) ਇੱਕ ਦ੍ਰਿਸ਼ ਸੈਟ ਅਪ ਕਰੋ ਜਿਸ ਵਿੱਚ ਇੱਕ ਟੂਲ ਅਸਫਲ ਹੋ ਜਾਂਦਾ ਹੈ ਅਤੇ ਦਿਖਾਓ ਕਿ ਗਲਤੀ ਸੁਨੇਹਾ ਮਾਡਲ ਵਿੱਚ ਕਿਵੇਂ ਵਾਪਸ ਆਵੇਗਾ।
ਚੈੱਕਲਿਸਟ
- ਮੈਂ ਏਜੰਟ ਨੂੰ "ਮਾਡਲ + ਟੂਲਸ + ਲੂਪ" ਵਜੋਂ ਪਰਿਭਾਸ਼ਿਤ ਕਰ ਸਕਦਾ ਹਾਂ ਅਤੇ ਇਹ ਫੈਸਲਾ ਕਰ ਸਕਦਾ ਹਾਂ ਕਿ ਕਦੋਂ ਇਸਦੀ ਲੋੜ ਹੈ।
- [ ] ਮੈਂ ਜਾਣਦਾ ਹਾਂ ਕਿ ਹਾਰਨੈੱਸ ਵਾਹਨ ਨੂੰ ਚਲਾਉਂਦੀ ਹੈ, ਮਾਡਲ ਬੱਸ ਇਹ ਚਾਹੁੰਦਾ ਹੈ।
- ਮੈਂ [] ਨਾਮ, ਵਰਣਨ ("ਕਦੋਂ ਕਾਲ ਕਰੋ") ਅਤੇ ਇਨਪੁਟ_ਸਕੀਮਾ ਦੇ ਨਾਲ ਇੱਕ ਠੋਸ ਵਾਹਨ ਵਰਣਨ ਲਿਖ ਸਕਦਾ ਹਾਂ।
- ਮੈਂ [ ] ਟੂਲ_ਉਪਯੋਗ → ਟੂਲ_ਰਿਜ਼ਲਟ ਚੱਕਰ ਨੂੰ ਕਦਮ ਦਰ ਕਦਮ ਦੀ ਪਾਲਣਾ ਕਰ ਸਕਦਾ/ਸਕਦੀ ਹਾਂ।
- [ ] ਮੈਂ ਮਾਡਲ ਨੂੰ ਓਪਨ ਟੂਲ_ਰਿਜ਼ਲਟ ਵਜੋਂ ਟੂਲ ਗਲਤੀਆਂ ਦੀ ਰਿਪੋਰਟ ਕਰਦਾ ਹਾਂ।