ਲਾਭ:
- ਇੱਕ LLM API ਬੇਨਤੀ ਦੇ ਮੂਲ ਢਾਂਚੇ ਦਾ ਵਰਣਨ ਕਰ ਸਕਦਾ ਹੈ (ਐਂਡਪੁਆਇੰਟ, ਮਾਡਲ, ਸੁਨੇਹੇ, max_tokens)
- ਸਿਸਟਮ, ਉਪਭੋਗਤਾ ਅਤੇ ਸਹਾਇਕ ਦੀਆਂ ਭੂਮਿਕਾਵਾਂ ਅਤੇ ਰਾਜ ਰਹਿਤ ਗੱਲਬਾਤ ਇਤਿਹਾਸ ਵਿੱਚ ਅੰਤਰ ਨੂੰ ਸਮਝਦਾ ਹੈ
- ਵਾਪਸ ਕੀਤੇ ਜਵਾਬ ਦੇ ਖੇਤਰਾਂ (ਸਮੱਗਰੀ ਬਲਾਕ, ਸਟਾਪ_ਕਾਰਨ, ਵਰਤੋਂ) ਨੂੰ ਪੜ੍ਹ ਅਤੇ ਵਿਆਖਿਆ ਕਰ ਸਕਦਾ ਹੈ
ਪਿਛਲੇ ਮੋਡੀਊਲ ਵਿੱਚ, ਅਸੀਂ ਇੱਕ ਚੈਟ ਵਿੰਡੋ ਤੋਂ ਨਕਲੀ ਬੁੱਧੀ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਸੀ। ਪਰ ਜੇਕਰ ਤੁਸੀਂ AI ਨੂੰ ਆਪਣੇ ਉਤਪਾਦ, ਆਟੋਮੇਸ਼ਨ ਜਾਂ ਵਰਕਫਲੋ ਵਿੱਚ ਏਮਬੇਡ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਇੱਕ ਚੈਟ ਇੰਟਰਫੇਸ ਇਸਨੂੰ ਕੱਟ ਨਹੀਂ ਦੇਵੇਗਾ; ਤੁਹਾਨੂੰ ਮਾਡਲ ਨਾਲ ਪ੍ਰੋਗਰਾਮੇਟਿਕ ਤੌਰ 'ਤੇ ਕਨੈਕਟ ਕਰਨ ਦੀ ਲੋੜ ਹੈ, ਯਾਨੀ ਕੋਡ ਜਾਂ ਆਟੋਮੇਸ਼ਨ ਟੂਲ ਨਾਲ। ਇਸ ਬ੍ਰਿਜ ਦਾ ਨਾਮ API (ਐਪਲੀਕੇਸ਼ਨ ਪ੍ਰੋਗਰਾਮਿੰਗ ਇੰਟਰਫੇਸ, ਇਕਰਾਰਨਾਮਾ ਹੈ ਜੋ ਦੋ ਸਾਫਟਵੇਅਰ ਨੂੰ ਕੁਝ ਨਿਯਮਾਂ ਨਾਲ ਗੱਲ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ)। ਜਦੋਂ ਤੁਸੀਂ ਇਸ ਯੂਨਿਟ ਨੂੰ ਪੂਰਾ ਕਰਦੇ ਹੋ, ਤਾਂ ਤੁਹਾਨੂੰ ਪਤਾ ਲੱਗ ਜਾਵੇਗਾ ਕਿ LLM (ਵੱਡੀ ਭਾਸ਼ਾ ਮਾਡਲ) API ਬੇਨਤੀ ਕੀ ਬਣਦੀ ਹੈ, ਸੰਦੇਸ਼ ਦੀਆਂ ਭੂਮਿਕਾਵਾਂ ਕੀ ਹਨ, ਅਤੇ ਜਵਾਬ ਨੂੰ ਕਿਵੇਂ ਪੜ੍ਹਨਾ ਹੈ। ਇਹ ਉਹ ਬੁਨਿਆਦ ਹੈ ਜਿਸ 'ਤੇ ਬਾਕੀ ਮੋਡੀਊਲ ਬਣਾਇਆ ਜਾਵੇਗਾ।
API ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ?
API ਵਿੱਚ ਮੂਲ ਪ੍ਰਵਾਹ ਇਹ ਹੈ: ਤੁਸੀਂ ਇੱਕ ਖਾਸ ਫਾਰਮੈਟ ਵਿੱਚ ਇੱਕ ਬੇਨਤੀ ਭੇਜਦੇ ਹੋ; ਸਰਵਰ ਇੱਕ ਖਾਸ ਫਾਰਮੈਟ ਵਿੱਚ ਜਵਾਬ ਦਿੰਦਾ ਹੈ। LLM ਵਿੱਚ, ਇਹ ਆਮ ਤੌਰ 'ਤੇ ਇੱਕ ਸਿੰਗਲ ਪਤੇ (ਐਂਡਪੁਆਇੰਟ, ਸਰਵਰ 'ਤੇ ਫਿਕਸਡ ਐਡਰੈੱਸ ਜੋ ਤੁਹਾਡੀ ਬੇਨਤੀ ਨੂੰ ਸੰਭਾਲਦਾ ਹੈ) 'ਤੇ ਇੱਕ HTTP ਕਾਲ (HTTP: ਵੈੱਬ 'ਤੇ ਬੇਨਤੀ-ਜਵਾਬ ਦੇਣ ਲਈ ਮਿਆਰੀ ਪ੍ਰੋਟੋਕੋਲ) ਹੁੰਦਾ ਹੈ। ਉਦਾਹਰਨ ਲਈ, ਇੱਕ ਮੈਸੇਜਿੰਗ API ਵਿੱਚ, ਸਾਰੀਆਂ ਬੇਨਤੀਆਂ ਇੱਕ ਸਿੰਗਲ ਪਤੇ 'ਤੇ ਜਾਂਦੀਆਂ ਹਨ ਅਤੇ JSON (JavaScript ਆਬਜੈਕਟ ਨੋਟੇਸ਼ਨ - ਇੱਕ ਟੈਕਸਟ ਫਾਰਮੈਟ ਜਿਸ ਵਿੱਚ ਕੁੰਜੀ/ਮੁੱਲ ਜੋੜੇ ਹੁੰਦੇ ਹਨ ਜੋ ਮਨੁੱਖਾਂ ਅਤੇ ਮਸ਼ੀਨਾਂ ਦੋਵਾਂ ਦੁਆਰਾ ਪੜ੍ਹੇ ਜਾ ਸਕਦੇ ਹਨ) ਦੇ ਰੂਪ ਵਿੱਚ ਹੁੰਦੇ ਹਨ।
ਇੱਕ ਬੇਨਤੀ ਵਿੱਚ, ਤੁਸੀਂ ਘੱਟੋ-ਘੱਟ ਇਹ ਤਿੰਨ ਚੀਜ਼ਾਂ ਨਿਰਧਾਰਤ ਕਰਦੇ ਹੋ:
- ਮਾਡਲ: ਤੁਸੀਂ ਕਿਹੜਾ ਮਾਡਲ ਵਰਤੋਗੇ (ਉਦਾਹਰਨ ਲਈ ਇੱਕ ਤੇਜ਼ ਅਤੇ ਸਸਤਾ ਮਾਡਲ ਜਾਂ ਇੱਕ ਸ਼ਕਤੀਸ਼ਾਲੀ ਮਾਡਲ)।
- max_tokens: ਟੋਕਨਾਂ ਦੀ ਵੱਧ ਤੋਂ ਵੱਧ ਸੰਖਿਆ (ਸਭ ਤੋਂ ਛੋਟੀ ਇਕਾਈ ਜਿਸ ਵਿੱਚ ਟੈਕਸਟ ਨੂੰ ਪ੍ਰੋਸੈਸ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਜਿਸ ਨੂੰ ਅਗਲੀ ਯੂਨਿਟ ਵਿੱਚ ਵਿਸਥਾਰ ਵਿੱਚ ਪ੍ਰੋਸੈਸ ਕੀਤਾ ਜਾਵੇਗਾ) ਜੋ ਮਾਡਲ ਪੈਦਾ ਕਰ ਸਕਦਾ ਹੈ; ਭਾਵ ਆਉਟਪੁੱਟ ਸੀਮਾ।
- ਸੰਦੇਸ਼: ਉਹਨਾਂ ਸੰਦੇਸ਼ਾਂ ਦੀ ਸੂਚੀ ਜੋ ਗੱਲਬਾਤ ਨੂੰ ਬਣਾਉਂਦੇ ਹਨ।
ਕਦਮ ਦਰ ਕਦਮ: ਇੱਕ ਬੇਨਤੀ ਕਿਵੇਂ ਸੈਟ ਅਪ ਕਰਨੀ ਹੈ
- ਅੰਤਮ ਬਿੰਦੂ ਅਤੇ ਪ੍ਰਮਾਣ ਪੱਤਰ ਤਿਆਰ ਕਰੋ। ਤੁਸੀਂ ਇੱਕ ਸਿਰਲੇਖ ਵਿੱਚ ਬੇਨਤੀ ਵਿੱਚ ਆਪਣੀ API ਕੁੰਜੀ (ਗੁਪਤ ਸਤਰ ਜੋ ਤੁਹਾਡੀ ਪਛਾਣ ਨੂੰ ਸਾਬਤ ਕਰਦੀ ਹੈ) ਜੋੜਦੇ ਹੋ। ਤੁਸੀਂ ਕਦੇ ਵੀ ਕੋਡ ਵਿੱਚ ਕੁੰਜੀ ਨੂੰ ਏਮਬੈਡ ਨਹੀਂ ਕਰਦੇ ਹੋ; ਅਸੀਂ ਯੂਨਿਟ 9 ਵਿੱਚ ਸੁਰੱਖਿਅਤ ਸਟੋਰੇਜ ਨੂੰ ਕਵਰ ਕਰਾਂਗੇ।
- ਮਾਡਲ ਅਤੇ ਆਉਟਪੁੱਟ ਸੀਮਾ ਚੁਣੋ। ਇੱਕ ਸਧਾਰਨ ਕੰਮ ਲਈ ਲਾਈਟਵੇਟ ਮਾਡਲ + ਛੋਟੇ ਮੈਕਸ_ਟੋਕਨ; ਸ਼ਕਤੀਸ਼ਾਲੀ ਮਾਡਲ + ਇੱਕ ਗੁੰਝਲਦਾਰ ਕੰਮ ਲਈ ਵੱਡੀ ਸੀਮਾ।
- ਸੁਨੇਹਾ ਸੂਚੀ ਸੈੱਟਅੱਪ ਕਰੋ। List the system instruction, user message, and past rounds (if any).
- ਬੇਨਤੀ ਭੇਜੋ ਅਤੇ ਜਵਾਬ ਨੂੰ ਪਾਰਸ ਕਰੋ। ਵਾਪਸ ਕੀਤੇ JSON ਤੋਂ ਟੈਕਸਟ ਸਮੱਗਰੀ, ਰੋਕੋ ਕਾਰਨ ਅਤੇ ਟੋਕਨ ਵਰਤੋਂ ਪੜ੍ਹੋ।
ਸੁਨੇਹਾ ਰੋਲ: ਸਿਸਟਮ, ਉਪਭੋਗਤਾ, ਸਹਾਇਕ
ਇੱਕ ਗੱਲਬਾਤ ਇੱਕ ਕ੍ਰਮ ਵਿੱਚ ਵਿਵਸਥਿਤ ਕੀਤੇ ਸੁਨੇਹਿਆਂ ਦੇ ਹੁੰਦੇ ਹਨ, ਅਤੇ ਹਰੇਕ ਸੰਦੇਸ਼ ਦੀ ਇੱਕ ਭੂਮਿਕਾ ਹੁੰਦੀ ਹੈ। ਭੂਮਿਕਾ ਇਹ ਨਿਰਧਾਰਤ ਕਰਦੀ ਹੈ ਕਿ ਮਾਡਲ ਉਸ ਟੈਕਸਟ ਨੂੰ ਕਿਵੇਂ ਪੇਸ਼ ਕਰਦਾ ਹੈ।
ਭੂਮਿਕਾ
ਜੋ ਲਿਖਦਾ ਹੈ
ਮਕਸਦ
ਸਿਸਟਮ
ਡਿਵੈਲਪਰ/ਓਪਰੇਟਰ
ਸਥਾਈ ਨਿਰਦੇਸ਼, ਸ਼ਖਸੀਅਤ ਅਤੇ ਨਿਯਮ ਜੋ ਸਾਰੀ ਗੱਲਬਾਤ ਦੌਰਾਨ ਲਾਗੂ ਹੁੰਦੇ ਹਨ
ਉਪਭੋਗਤਾ
ਅੰਤਮ ਉਪਭੋਗਤਾ
ਉਪਭੋਗਤਾ ਦਾ ਮੌਜੂਦਾ ਸਵਾਲ ਜਾਂ ਇਨਪੁਟ
ਸਹਾਇਕ
ਮਾਡਲ
ਮਾਡਲ ਦੁਆਰਾ ਤਿਆਰ ਜਵਾਬ (ਅਤੇ ਪਿਛਲੇ ਜਵਾਬ)
ਸਿਸਟਮ ਰੋਲ ਬਹੁਤੇ ਪ੍ਰਦਾਤਾਵਾਂ ਵਿੱਚ ਬੇਨਤੀ ਬਾਡੀ ਵਿੱਚ ਇੱਕ ਵੱਖਰੇ ਸਿਸਟਮ ਖੇਤਰ ਵਜੋਂ ਉਪਲਬਧ ਹੈ; ਉਪਭੋਗਤਾ ਅਤੇ ਸਹਾਇਕ ਨੂੰ ਸੁਨੇਹਿਆਂ ਦੀ ਸੂਚੀ ਵਿੱਚ ਕ੍ਰਮਵਾਰ ਸੂਚੀਬੱਧ ਕੀਤਾ ਗਿਆ ਹੈ। Critical point: the system instruction is the high-level instruction, the user message is the request to be answered at that moment.
{ "model": "claude-opus-4-8", "max_tokens": 1024, "system": "ਤੁਸੀਂ ਇੱਕ ਕਾਰਪੋਰੇਟ ਸਹਾਇਤਾ ਸਹਾਇਕ ਹੋ। ਇੱਕ ਛੋਟਾ, ਰਸਮੀ ਅਤੇ ਪ੍ਰਮਾਣਿਤ ਜਵਾਬ ਦਿਓ। ਉਸ ਜਾਣਕਾਰੀ ਨੂੰ ਨਾ ਬਣਾਓ ਜਿਸ ਬਾਰੇ ਤੁਹਾਨੂੰ ਯਕੀਨ ਨਹੀਂ ਹੈ।", "messages": [ { "role": "user", "comtent return": "ਮੈਂ ਕੀ ਪ੍ਰਕਿਰਿਆ ਸ਼ੁਰੂ ਕਰਾਂ?" } ]}
ਬੋਲੀ ਰਾਜ ਰਹਿਤ ਹੈ
ਇੱਥੇ ਸਭ ਤੋਂ ਆਮ ਗਲਤ ਧਾਰਨਾ ਹੈ: LLM API ਕਾਲਾਂ ਸਟੇਟਲੈਸ ਹੁੰਦੀਆਂ ਹਨ — ਸਰਵਰ ਦੋ ਬੇਨਤੀਆਂ ਵਿਚਕਾਰ ਕੋਈ ਮੈਮੋਰੀ ਬਰਕਰਾਰ ਨਹੀਂ ਰੱਖਦਾ ਹੈ। ਮਾਡਲ ਨੂੰ ਤੁਹਾਡੀ ਪਿਛਲੀ ਬੇਨਤੀ ਯਾਦ ਨਹੀਂ ਹੈ। ਜੇਕਰ ਤੁਸੀਂ ਇੱਕ ਮਲਟੀ-ਰਾਊਂਡ ਚੈਟ ਸੈਟ ਅਪ ਕਰ ਰਹੇ ਹੋ, ਤਾਂ ਤੁਹਾਨੂੰ ਹਰੇਕ ਨਵੀਂ ਬੇਨਤੀ ਦੇ ਨਾਲ ਪਿਛਲੇ ਦੌਰ ਨੂੰ ਦੁਬਾਰਾ ਭੇਜਣ ਦੀ ਲੋੜ ਹੋਵੇਗੀ। ਮਾਡਲ ਦੀ "ਮੈਮੋਰੀ" ਵਿੱਚ ਤੁਹਾਡੇ ਦੁਆਰਾ ਭੇਜੇ ਗਏ ਸੁਨੇਹਿਆਂ ਦੀ ਸੂਚੀ ਹੁੰਦੀ ਹੈ।
{ "ਮਾਡਲ": "ਕਲਾਡ-ਓਪਸ-4-8", "ਮੈਕਸ_ਟੋਕਨ": 512, "ਸੁਨੇਹੇ": [ { "ਰੋਲ": "ਉਪਭੋਗਤਾ", "ਸਮੱਗਰੀ": "ਹੈਲੋ, ਮੇਰਾ ਨਾਮ ਡੇਨੀਜ਼ ਹੈ।" }, { "role": "assistant", "content": "ਹੈਲੋ ਡੇਨਿਜ਼, ਮੈਂ ਤੁਹਾਡੀ ਮਦਦ ਕਿਵੇਂ ਕਰ ਸਕਦਾ ਹਾਂ?" }, { "role": "user", "content": "ਮੈਂ ਹੁਣੇ ਆਪਣਾ ਨਾਮ ਕਿਹਾ, ਕੀ ਤੁਹਾਨੂੰ ਯਾਦ ਹੈ?" } ]}
ਤੀਜੇ ਸੁਨੇਹੇ ਦਾ ਸਹੀ ਉੱਤਰ ਦੇਣਾ ਤੁਹਾਡੇ ਪਿਛਲੇ ਦੋਵੇਂ ਸੰਦੇਸ਼ਾਂ ਨੂੰ ਭੇਜਣ 'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ। ਜੇਕਰ ਤੁਸੀਂ ਇਸਨੂੰ ਨਹੀਂ ਭੇਜਦੇ ਹੋ, ਤਾਂ ਮਾਡਲ "ਸਮੁੰਦਰ" ਨੂੰ ਨਹੀਂ ਜਾਣੇਗਾ ਅਤੇ ਗਲਤ ਜਵਾਬ ਦੇਵੇਗਾ। ਇਹ ਲਾਗਤ 'ਤੇ ਵੀ ਸਿੱਧਾ ਅਸਰ ਪਾਉਂਦਾ ਹੈ: ਗੱਲਬਾਤ ਜਿੰਨੀ ਲੰਬੀ ਹੋਵੇਗੀ, ਸੂਚੀ ਜਿੰਨੀ ਵੱਡੀ ਹੋਵੇਗੀ, ਹਰੇਕ ਬੇਨਤੀ ਜ਼ਿਆਦਾ ਟੋਕਨਾਂ ਦੀ ਖਪਤ ਕਰਦੀ ਹੈ।
ਸੰਕੇਤ: ਲੰਮੀ ਗੱਲਬਾਤ ਵਿੱਚ, ਪੂਰੇ ਇਤਿਹਾਸ ਨੂੰ ਭੇਜਣ ਦੀ ਬਜਾਏ ਪੁਰਾਣੇ ਦੌਰ (ਸਾਰਾਂਸ਼ + ਆਖਰੀ ਕੁਝ ਦੌਰ) ਨੂੰ ਸੰਖੇਪ ਅਤੇ ਮੂਵ ਕਰਨਾ ਲਾਗਤ ਨੂੰ ਘਟਾਉਂਦਾ ਹੈ ਅਤੇ ਸੰਦਰਭ ਵਿੰਡੋ ਨੂੰ ਸੁਰੱਖਿਅਤ ਰੱਖਦਾ ਹੈ। ਅਸੀਂ ਇਸਨੂੰ ਯੂਨਿਟ 6 ਅਤੇ 11 ਵਿੱਚ ਡੂੰਘਾ ਕਰਾਂਗੇ।
ਜਵਾਬ ਪੜ੍ਹੋ
ਜਦੋਂ ਮਾਡਲ ਇੱਕ ਜਵਾਬ ਦਿੰਦਾ ਹੈ, ਤਾਂ ਤੁਹਾਨੂੰ ਇੱਕ ਢਾਂਚਾਗਤ ਵਸਤੂ ਮਿਲਦੀ ਹੈ, ਨਾ ਕਿ ਸਧਾਰਨ ਟੈਕਸਟ। ਆਮ ਖੇਤਰ:
{ "id": "msg_01ABC...", "model": "claude-opus-4-8", "role": "assistant", "content": [ { "type": "text", "text": "ਵਾਪਸੀ ਸ਼ੁਰੂ ਕਰਨ ਲਈ, ਆਪਣੇ ਖਾਤੇ ਵਿੱਚ 'My Orders' ਪੰਨੇ 'ਤੇ ਜਾਓ..." } ], "stop_reason": "stop_reason": "stop_reason" "input_tokens": 47, "output_tokens": 88 }}
- ਸਮੱਗਰੀ: ਜਵਾਬ ਆਪਣੇ ਆਪ; ਇਹ ਸਮੱਗਰੀ ਬਲਾਕਾਂ ਦੀ ਇੱਕ ਸੂਚੀ ਹੈ। ਟੈਕਸਟ ਬਲਾਕ ਦਾ ਟੈਕਸਟ ਖੇਤਰ ਅਸਲ ਜਵਾਬ ਹੈ।
- stop_reason: ਮਾਡਲ ਕਿਉਂ ਬੰਦ ਹੋਇਆ। end_turn = ਕੁਦਰਤੀ ਅੰਤ; max_tokens = ਆਉਟਪੁੱਟ ਸੀਮਾ 'ਤੇ ਫਸਿਆ (ਜਵਾਬ ਅਧੂਰਾ ਹੋ ਸਕਦਾ ਹੈ); ਇਨਕਾਰ = ਸੁਰੱਖਿਆ ਕਾਰਨਾਂ ਕਰਕੇ ਇਨਕਾਰ ਕੀਤਾ। ਤੁਹਾਡੇ ਕੋਡ ਨੂੰ ਹਮੇਸ਼ਾ stop_reason ਪਹਿਲਾਂ ਦੇਖਣਾ ਚਾਹੀਦਾ ਹੈ।
- ਵਰਤੋਂ: ਇਨਪੁਟ ਅਤੇ ਆਉਟਪੁੱਟ ਟੋਕਨ ਨੰਬਰ। ਇਹ ਲਾਗਤ ਅਤੇ ਸੀਮਾ ਟਰੈਕਿੰਗ ਦਾ ਆਧਾਰ ਹੈ।
ਧਿਆਨ ਦਿਓ: ਜੇਕਰ stop_reason max_tokens ਹੈ, ਤਾਂ ਜਵਾਬ ਪੂਰਾ ਨਹੀਂ ਹੁੰਦਾ। ਇਸ ਨੂੰ "ਸਫਲ ਪ੍ਰਤੀਕਿਰਿਆ" ਦੇ ਰੂਪ ਵਿੱਚ ਮੰਨਣਾ ਅਤੇ ਉਪਭੋਗਤਾ ਨੂੰ ਅੱਧਾ ਟੈਕਸਟ ਦਿਖਾਉਣਾ ਉਤਪਾਦਨ ਵਿੱਚ ਸਭ ਤੋਂ ਆਮ ਗਲਤੀਆਂ ਵਿੱਚੋਂ ਇੱਕ ਹੈ। ਜਾਂ ਤਾਂ ਅਧਿਕਤਮ_ਟੋਕਨ ਵਧਾਓ ਜਾਂ ਸਟ੍ਰੀਮਿੰਗ ਦੀ ਵਰਤੋਂ ਕਰੋ।
ਕਮਜ਼ੋਰ ਪ੍ਰੋਂਪਟ / ਮਜ਼ਬੂਤ ਪ੍ਰੋਂਪਟ
ਦੋ ਵੱਖ-ਵੱਖ ਸਿਸਟਮ ਪ੍ਰੋਂਪਟ ਦੇ ਨਾਲ ਇੱਕੋ ਕੰਮ:
# ਕਮਜ਼ੋਰ ਤੁਸੀਂ ਇੱਕ ਸਹਾਇਕ ਹੋ। ਸਵਾਲਾਂ ਦਾ ਜਵਾਬ ਦਿਓ.
# STRONGਤੁਸੀਂ ਇੱਕ ਕਾਰਪੋਰੇਟ ਸਹਾਇਤਾ ਸਹਾਇਕ ਹੋ। ਨਿਯਮ:- ਪ੍ਰਦਾਨ ਕੀਤੇ ਗਏ ਪਾਲਿਸੀ ਦਸਤਾਵੇਜ਼ ਵਿਚਲੀ ਜਾਣਕਾਰੀ 'ਤੇ ਪੂਰੀ ਤਰ੍ਹਾਂ ਭਰੋਸਾ ਕਰੋ; ਜੇਕਰ ਇਹ ਦਸਤਾਵੇਜ਼ ਵਿੱਚ ਨਹੀਂ ਹੈ, ਤਾਂ ਕਹੋ "ਮੇਰੇ ਕੋਲ ਇਹ ਜਾਣਕਾਰੀ ਨਹੀਂ ਹੈ, ਮੈਂ ਇਸਨੂੰ ਸੰਬੰਧਿਤ ਯੂਨਿਟ ਨੂੰ ਭੇਜ ਰਿਹਾ ਹਾਂ।" - ਜਵਾਬ 3 ਵਾਕਾਂ ਤੋਂ ਵੱਧ ਨਹੀਂ ਹੋਣੇ ਚਾਹੀਦੇ, ਰਸਮੀ ਅਤੇ ਸਪੱਸ਼ਟ ਹੋਣੇ ਚਾਹੀਦੇ ਹਨ। - ਨਿੱਜੀ ਡੇਟਾ (TC ID ਨੰਬਰ, ਕਾਰਡ ਨੰਬਰ) ਦੀ ਮੰਗ ਨਾ ਕਰੋ ਅਤੇ ਦੁਹਰਾਓ ਨਾ। - ਜਦੋਂ ਤੁਹਾਨੂੰ ਯਕੀਨ ਨਹੀਂ ਹੁੰਦਾ ਤਾਂ ਅੰਦਾਜ਼ਾ ਨਾ ਲਗਾਓ.
ਸ਼ਕਤੀਸ਼ਾਲੀ ਸੰਸਕਰਣ; ਇਹ ਅਨਿਸ਼ਚਿਤਤਾ ਵਿੱਚ ਸਕੋਪ, ਫਾਰਮ, ਸੁਰੱਖਿਆ ਹਾਸ਼ੀਏ ਅਤੇ ਵਿਵਹਾਰ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਦਾ ਹੈ। ਮਾਡਲ ਆਉਟਪੁੱਟ ਦੀ ਇਕਸਾਰਤਾ ਇਸ ਸਪਸ਼ਟਤਾ ਤੋਂ ਸਿੱਧੇ ਆਉਂਦੀ ਹੈ।
ਤਿੰਨ ਮਿੰਨੀ ਕੇਸ
ਕੇਸ 1 — ਸਪੋਰਟ ਬੋਟ (ਰਾਜ ਰਹਿਤ ਹੋਣ ਦਾ ਜਾਲ)। ਇੱਕ ਈ-ਕਾਮਰਸ ਟੀਮ ਨੇ ਬੋਟ ਨੂੰ ਲਾਈਵ ਲਿਆ; ਜਦੋਂ ਉਪਭੋਗਤਾ ਨੇ ਕਿਹਾ "ਪਿਛਲਾ ਆਰਡਰ ਰੱਦ ਕਰੋ", ਬੋਟ ਆਰਡਰ ਨੰਬਰ ਨੂੰ "ਭੁੱਲ ਗਿਆ"। ਕਾਰਨ: ਉਹ ਹਰ ਬੇਨਤੀ ਨੂੰ ਸਿਰਫ਼ ਆਖਰੀ ਸੰਦੇਸ਼ ਦੇ ਨਾਲ ਭੇਜ ਰਹੇ ਸਨ। ਹੱਲ: ਉਹਨਾਂ ਨੇ ਸੁਨੇਹਿਆਂ ਦੀ ਸੂਚੀ ਵਿੱਚ ਆਖਰੀ 6 ਦੌਰ ਸ਼ਾਮਲ ਕੀਤੇ। ਨਤੀਜਾ: ਸੰਦਰਭ ਸੁਰੱਖਿਅਤ ਰੱਖਿਆ ਗਿਆ ਹੈ, ਪਰ ਪ੍ਰਤੀ ਬੇਨਤੀ ਇੰਪੁੱਟ 40 ਟੋਕਨਾਂ ਤੋਂ ~600 ਟੋਕਨਾਂ ਤੱਕ ਵਧ ਗਈ ਹੈ — ਅਸੀਂ ਯੂਨਿਟ 2 ਵਿੱਚ ਲਾਗਤ ਪਾਠ ਨੂੰ ਕਵਰ ਕਰਾਂਗੇ।
ਕੇਸ 2 - ਅਧੂਰਾ ਇਕਰਾਰਨਾਮਾ ਸੰਖੇਪ। ਇੱਕ ਕਾਨੂੰਨੀ ਟੀਮ 10 ਪੰਨਿਆਂ ਦੇ ਇਕਰਾਰਨਾਮੇ ਦੀ ਰੂਪਰੇਖਾ ਦੇ ਰਹੀ ਸੀ; max_tokens: 300 ਘੱਟ ਰਹੇ, ਸਾਰਾਂਸ਼ ਅੱਧ-ਵਾਕ ਨੂੰ ਕੱਟ ਰਹੇ ਸਨ। stop_reason ਹਰ ਵਾਰ max_tokens ਸੀ ਪਰ ਕੋਈ ਨਹੀਂ ਦੇਖ ਰਿਹਾ ਸੀ। ਅਧਿਕਤਮ_ਟੋਕਨਾਂ ਨੂੰ 1500 ਤੱਕ ਵਧਾ ਦਿੱਤਾ ਗਿਆ ਅਤੇ ਸਟਾਪ_ਰੀਜ਼ਨ ਜਾਂਚ ਸ਼ਾਮਲ ਕੀਤੀ ਗਈ; ਕੱਟੀ ਗਈ ਸੰਖੇਪ ਦਰ 18% ਤੋਂ ਘਟ ਕੇ 0% ਹੋ ਗਈ ਹੈ।
ਕੇਸ 3 — ਮਿਕਸਿੰਗ ਰੋਲ। ਇੱਕ ਮਾਰਕੀਟਿੰਗ ਟੀਮ ਸਿਸਟਮ ਨੂੰ ਖਾਲੀ ਛੱਡ ਕੇ, ਉਪਭੋਗਤਾ ਸੰਦੇਸ਼ ਵਿੱਚ ਸਾਰੀਆਂ ਹਦਾਇਤਾਂ ਲਿਖ ਰਹੀ ਸੀ। ਜਦੋਂ ਉਪਭੋਗਤਾ ਇੰਪੁੱਟ ਨੂੰ ਹਦਾਇਤਾਂ ਨਾਲ ਮਿਲਾਇਆ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਮਾਡਲ ਕਈ ਵਾਰ "ਪਿਛਲੇ ਨਿਯਮਾਂ ਨੂੰ ਭੁੱਲ ਜਾਓ" ਲਈ ਉਪਭੋਗਤਾ ਦੇ ਹੁਕਮ ਦੀ ਪਾਲਣਾ ਕਰੇਗਾ। ਉਹਨਾਂ ਨੇ ਸਥਾਈ ਨਿਯਮਾਂ ਨੂੰ ਸਿਸਟਮ ਵਿੱਚ ਤਬਦੀਲ ਕਰ ਦਿੱਤਾ; ਵਰਤੋਂਕਾਰ ਇਨਪੁਟ ਨੂੰ ਹਦਾਇਤਾਂ ਤੋਂ ਵੱਖ ਕਰਨ ਨਾਲ, ਨਿਯਮਾਂ ਦੀ ਉਲੰਘਣਾ ਵਿੱਚ ਕਾਫ਼ੀ ਕਮੀ ਆਈ ਹੈ।
ਆਮ ਗਲਤੀਆਂ
- ਅਤੀਤ ਨੂੰ ਭੇਜਣਾ ਭੁੱਲਣਾ: ਮਾਡਲ ਨੂੰ "ਯਾਦ ਨਹੀਂ" ਮੰਨਿਆ ਜਾਂਦਾ ਹੈ; ਜਦੋਂ ਕਿ ਇਹ ਰਾਜ ਰਹਿਤ ਹੈ। ਤੁਸੀਂ ਪ੍ਰਸੰਗ ਨੂੰ ਚੁੱਕਦੇ ਹੋ।
- `ਸਟਾਪ_ਕਾਰਨ` ਨੂੰ ਨਹੀਂ ਦੇਖ ਰਹੇ: ਅਧਿਕਤਮ_ਟੋਕਨਾਂ ਨਾਲ ਰੋਕੇ ਗਏ ਜਵਾਬ ਨੂੰ ਪੂਰਾ ਮੰਨਿਆ ਜਾਂਦਾ ਹੈ।
- 'ਉਪਭੋਗਤਾ' ਵਿੱਚ ਹਦਾਇਤਾਂ ਨੂੰ ਏਮਬੈਡ ਕਰਨਾ: ਸਿਸਟਮ ਵਿੱਚ ਨਿਰੰਤਰ ਨਿਯਮ; ਤਤਕਾਲ ਇਨਪੁਟ ਉਪਭੋਗਤਾ ਨੂੰ ਜਾਂਦਾ ਹੈ। ਮਿਲਾਉਣਾ ਸੁਰੱਖਿਆ ਕਮਜ਼ੋਰੀਆਂ ਬਣਾਉਂਦਾ ਹੈ।
- ਇੱਕ ਸਾਦੇ ਸਤਰ ਲਈ 'ਸਮੱਗਰੀ' ਨੂੰ ਗਲਤ ਕਰਨਾ: ਜਵਾਬ ਬਲਾਕਾਂ ਦੀ ਸੂਚੀ ਹੈ; ਪਹਿਲੇ ਟੈਕਸਟ ਬਲਾਕ ਦੇ ਟੈਕਸਟ ਖੇਤਰ ਨੂੰ ਪੜ੍ਹੋ, ਅੰਨ੍ਹੇ ਸੂਚਕਾਂਕ ਨਾਲ ਸਮੱਗਰੀ[0] ਪ੍ਰਾਪਤ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਇਸਦੀ ਕਿਸਮ ਦੀ ਪੁਸ਼ਟੀ ਕਰੋ।
- ਕੋਡ ਵਿੱਚ ਕੁੰਜੀ ਨੂੰ ਸ਼ਾਮਲ ਕਰਨਾ: ਇੱਕ ਵਾਤਾਵਰਣ ਵੇਰੀਏਬਲ (ਯੂਨਿਟ 9) ਦੀ ਵਰਤੋਂ ਕਰੋ।
ਡੂੰਘੇ: ਸਮਗਰੀ ਬਲਾਕ ਅਤੇ ਮਲਟੀ-ਪਾਰਟ ਜਵਾਬ
ਇਹ ਸਮਝਣਾ ਕਿ ਜਵਾਬ ਵਿੱਚ ਸਮੱਗਰੀ ਖੇਤਰ ਇੱਕ ਸੂਚੀ ਕਿਉਂ ਹੈ, ਉਹਨਾਂ ਉੱਨਤ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਲਈ ਬੁਨਿਆਦੀ ਹੈ ਜਿਹਨਾਂ ਦਾ ਤੁਸੀਂ ਬਾਅਦ ਵਿੱਚ ਸਾਹਮਣਾ ਕਰੋਗੇ। ਕਈ ਵਾਰ ਮਾਡਲ ਟੈਕਸਟ ਦੇ ਇੱਕ ਬਲਾਕ ਨੂੰ ਨਹੀਂ, ਸਗੋਂ ਕਈ ਬਲਾਕਾਂ ਨੂੰ ਵਾਪਸ ਕਰਦਾ ਹੈ: ਸੋਚ ਦਾ ਇੱਕ ਬਲਾਕ, ਟੈਕਸਟ ਦਾ ਇੱਕ ਬਲਾਕ; ਜਾਂ ਟੂਲ ਵਰਤੋਂ ਬਲਾਕ ਦੇ ਬਾਅਦ ਟੈਕਸਟ ਦਾ ਇੱਕ ਬਲਾਕ। ਇਸ ਲਈ ਅੰਨ੍ਹੇਵਾਹ ਸਮੱਗਰੀ[0] ਨੂੰ "ਜਵਾਬ" ਵਜੋਂ ਗਿਣਨਾ ਨਾਜ਼ੁਕ ਹੈ। ਸਹੀ ਪਹੁੰਚ ਇਹ ਹੈ ਕਿ ਸੂਚੀ ਵਿੱਚੋਂ ਲੰਘਣਾ ਅਤੇ ਇਸਨੂੰ ਕਿਸਮ ਦੁਆਰਾ ਕ੍ਰਮਬੱਧ ਕਰਨਾ: ਤੁਸੀਂ ਉਹਨਾਂ ਬਲਾਕਾਂ ਦੀ ਟੈਕਸਟ ਸਮੱਗਰੀ ਨੂੰ ਇਕੱਠਾ ਕਰਦੇ ਹੋ ਜਿਨ੍ਹਾਂ ਦੀ ਕਿਸਮ ਫੀਲਡ ਟੈਕਸਟ ਹੈ, ਅਤੇ ਹੋਰ ਕਿਸਮਾਂ (ਸੋਚ, ਟੂਲ) ਨੂੰ ਵੱਖਰੇ ਤੌਰ 'ਤੇ ਵਰਤਾਓ।
ਇਹ ਅੰਤਰ ਅਭਿਆਸ ਵਿੱਚ ਕੀ ਕਰਦਾ ਹੈ ਇਹ ਹੈ ਕਿ ਤੁਸੀਂ ਮਾਡਲ ਦੇ ਤਰਕ (ਜੇ ਕੋਈ ਹੈ) ਨੂੰ ਉਪਭੋਗਤਾ ਨੂੰ ਦੱਸੇ ਬਿਨਾਂ ਲੌਗ ਕਰ ਸਕਦੇ ਹੋ, ਟੂਲ ਕਾਲਾਂ ਨੂੰ ਵੱਖਰੇ ਤਰਕ ਲਈ ਰੀਡਾਇਰੈਕਟ ਕਰ ਸਕਦੇ ਹੋ, ਅਤੇ ਸਿਰਫ਼ ਸਕ੍ਰੀਨ 'ਤੇ ਅਸਲ ਜਵਾਬ ਨੂੰ ਪ੍ਰਿੰਟ ਕਰ ਸਕਦੇ ਹੋ। ਜਿਵੇਂ-ਜਿਵੇਂ ਮੋਡੀਊਲ ਅੱਗੇ ਵਧਦਾ ਹੈ (ਖ਼ਾਸਕਰ ਯੂਨਿਟ 4 ਅਤੇ 11 ਵਿੱਚ) ਤੁਸੀਂ ਦੇਖੋਗੇ ਕਿ ਇਹ ਬਲਾਕ ਢਾਂਚਾ ਆਉਟਪੁੱਟ ਨੂੰ ਪ੍ਰਮਾਣਿਤ ਕਰਨ ਅਤੇ ਨਿਰਦੇਸ਼ਿਤ ਕਰਨ ਲਈ ਕਿੰਨਾ ਉਪਯੋਗੀ ਹੈ।
ਇੱਕ ਹੋਰ ਵਿਹਾਰਕ ਨੁਕਤਾ: ਤੁਸੀਂ ਵੱਖ-ਵੱਖ ਪ੍ਰਦਾਤਾ ਪਲੇਟਫਾਰਮਾਂ (ਸਿੱਧਾ API, ਇੱਕ ਕਲਾਉਡ ਪ੍ਰਦਾਤਾ ਦੁਆਰਾ) ਤੋਂ ਇੱਕੋ ਮਾਡਲ ਤੱਕ ਪਹੁੰਚ ਕਰ ਸਕਦੇ ਹੋ। ਹਾਲਾਂਕਿ ਅੰਤਮ ਬਿੰਦੂ ਦਾ ਪਤਾ ਅਤੇ ਪ੍ਰਮਾਣਿਕਤਾ ਫਾਰਮੈਟ ਬਦਲ ਸਕਦਾ ਹੈ, ਮੂਲ ਸੰਕਲਪ ਜਿਵੇਂ ਕਿ ਸੰਦੇਸ਼ ਦੀਆਂ ਭੂਮਿਕਾਵਾਂ, ਰਾਜ ਰਹਿਤਤਾ, ਅਤੇ ਜਵਾਬ ਬਣਤਰ ਇੱਕੋ ਜਿਹੇ ਰਹਿੰਦੇ ਹਨ। ਇਸ ਲਈ ਇਸ ਯੂਨਿਟ ਦੀਆਂ ਮੂਲ ਗੱਲਾਂ ਲਾਗੂ ਹੁੰਦੀਆਂ ਹਨ ਭਾਵੇਂ ਤੁਸੀਂ ਕੋਈ ਵੀ ਪਲੇਟਫਾਰਮ ਵਰਤਦੇ ਹੋ।
ਸੰਖੇਪ ਵਿੱਚ
ਇੱਕ LLM API ਬੇਨਤੀ ਵਿੱਚ ਮਾਡਲ, ਆਉਟਪੁੱਟ ਸੀਮਾ, ਅਤੇ ਸੁਨੇਹਾ ਸੂਚੀ ਸ਼ਾਮਲ ਹੁੰਦੀ ਹੈ; ਰੋਲ (ਸਿਸਟਮ, ਉਪਭੋਗਤਾ, ਸਹਾਇਕ) ਮਾਡਲ ਦੇ ਵਿਵਹਾਰ ਨੂੰ ਨਿਰਧਾਰਤ ਕਰਦੇ ਹਨ। ਕਾਲਾਂ ਸਟੇਟਲੈੱਸ ਹਨ: ਤੁਸੀਂ ਹਰ ਬੇਨਤੀ ਦੇ ਨਾਲ ਸੰਦਰਭ ਰੱਖਦੇ ਹੋ। ਜਵਾਬ ਇੱਕ ਢਾਂਚਾਗਤ ਵਸਤੂ ਹੈ; ਸਮੱਗਰੀ, stop_reason ਅਤੇ ਵਰਤੋਂ ਖੇਤਰਾਂ ਨੂੰ ਪੜ੍ਹਨਾ ਅਤੇ ਵਿਆਖਿਆ ਕਰਨਾ ਉਤਪਾਦਨ ਵਿੱਚ ਟਿਕਾਊਤਾ ਦਾ ਆਧਾਰ ਹੈ।
ਐਪਲੀਕੇਸ਼ਨ ਦਾ ਕੰਮ
ਆਪਣੇ ਖੁਦ ਦੇ ਪੇਸ਼ੇ ਤੋਂ ਕੋਈ ਕੰਮ ਚੁਣੋ (ਜਿਵੇਂ ਕਿ ਆਉਣ ਵਾਲੇ ਈ-ਮੇਲ ਨੂੰ ਛਾਂਟਣਾ, ਸੰਖੇਪ ਸਾਰਾਂਸ਼ ਬਣਾਉਣਾ)। ਕਾਗਜ਼ ਦੇ ਇੱਕ ਟੁਕੜੇ 'ਤੇ: (1) 4-5 ਨਿਯਮਾਂ ਦੇ ਨਾਲ ਸਿਸਟਮ ਪ੍ਰੋਂਪਟ ਲਿਖੋ, (2) ਇੱਕ ਨਮੂਨਾ ਉਪਭੋਗਤਾ ਸੁਨੇਹਾ ਅਤੇ 2-ਰਾਉਂਡ ਇਤਿਹਾਸ ਸੈੱਟ ਕਰੋ, ਜੇਕਰ ਕੋਈ ਹੋਵੇ, (3) max_tokens ਲਈ ਇੱਕ ਵਾਜਬ ਮੁੱਲ ਨਿਰਧਾਰਤ ਕਰੋ ਅਤੇ ਜਾਇਜ਼ਤਾ ਲਿਖੋ, (4) ਸੂਚੀ ਬਣਾਓ ਕਿ ਤੁਸੀਂ ਵਾਪਸ ਕੀਤੇ ਜਵਾਬ ਵਿੱਚ ਕਿਹੜੇ stop_reason ਮੁੱਲਾਂ ਨੂੰ ਸੰਭਾਲੋਗੇ ਅਤੇ ਕਿਵੇਂ।
ਚੈੱਕਲਿਸਟ
- [ ] ਮੈਂ ਬੇਨਤੀ ਦੇ ਤਿੰਨ ਲਾਜ਼ਮੀ ਭਾਗਾਂ ਨੂੰ ਗਿਣ ਸਕਦਾ/ਸਕਦੀ ਹਾਂ (ਮਾਡਲ, ਅਧਿਕਤਮ_ਟੋਕਨ, ਸੁਨੇਹੇ)।
- [ ] ਮੈਂ ਸਿਸਟਮ, ਉਪਭੋਗਤਾ ਅਤੇ ਸਹਾਇਕ ਭੂਮਿਕਾਵਾਂ ਵਿੱਚ ਅੰਤਰ ਦੀ ਵਿਆਖਿਆ ਕਰ ਸਕਦਾ ਹਾਂ।
- [ ] ਮੈਂ ਜਾਣਦਾ ਹਾਂ ਕਿ ਕਾਲਾਂ ਸਟੇਟਲੈੱਸ ਹਨ ਅਤੇ ਮੈਨੂੰ ਅਤੀਤ ਨੂੰ ਸੰਭਾਲਣ ਦੀ ਲੋੜ ਹੈ।
- ਮੈਂ [ ] ਸਮੱਗਰੀ, stop_reason ਅਤੇ ਵਰਤੋਂ ਖੇਤਰਾਂ ਨੂੰ ਪੜ੍ਹ ਅਤੇ ਟਿੱਪਣੀ ਕਰ ਸਕਦਾ/ਸਕਦੀ ਹਾਂ।
- [ ] max_tokens ਨਾਲ ਮੈਂ ਕੱਟੇ ਹੋਏ ਜਵਾਬ ਨੂੰ ਨੋਟਿਸ ਅਤੇ ਸੰਭਾਲ ਸਕਦਾ/ਸਕਦੀ ਹਾਂ।