ਆਪਣੀ ਐਪ ਵਿੱਚ AI ਫੀਚਰ ਕਿਵੇਂ ਜੋੜੀਏ

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

ਜ਼ਿਆਦਾਤਰ AI ਫੀਚਰਾਂ ਪਿੱਛੇ ਚਾਰ ਪੈਟਰਨ

ਕੱਢਣਾ ਅਤੇ ਵਰਗੀਕਰਨ ਅਕਸਰ ਸਭ ਤੋਂ ਕੀਮਤੀ ਹੁੰਦੇ ਹਨ ਅਤੇ ਸਭ ਤੋਂ ਘੱਟ ਦਿਖਾਈ ਦਿੰਦੇ ਹਨ। ਇਹ ਹਰ ਰਿਕਾਰਡ 'ਤੇ ਕਿਸੇ ਦੇ ਕੁਝ ਮਿੰਟ ਚੁੱਪਚਾਪ ਬਚਾਉਂਦੇ ਹਨ, ਅਤੇ ਕਿਉਂਕਿ ਨਤੀਜਾ ਇੱਕ ਤੈਅ ਸ਼ਕਲ ਵਿੱਚ ਹੁੰਦਾ ਹੈ, ਇਸ ਲਈ ਇਸਦੀ ਆਪਣੇ ਆਪ ਜਾਂਚ ਹੋ ਸਕਦੀ ਹੈ। ਚੈਟ ਸਭ ਤੋਂ ਵੱਧ ਦਿਖਦਾ ਹੈ ਪਰ ਸਭ ਤੋਂ ਔਖਾ ਸਹੀ ਕਰਨ ਲਈ ਹੈ, ਅਤੇ ਇਸਦੀ ਆਪਣੀ ਗਾਈਡ ਹੈ: AI ਚੈਟਬੋਟ ਐਪ ਕਿਵੇਂ ਬਣਾਈਏ।

ਇਹ ਤੁਹਾਡੀ ਐਪ ਵਿੱਚ ਕਿਵੇਂ ਫਿੱਟ ਹੁੰਦਾ ਹੈ

ਹਰ ਪੈਟਰਨ ਦੀ ਸ਼ਕਲ ਇੱਕੋ ਜਿਹੀ ਹੈ:

1. ਯੂਜ਼ਰ ਕੋਈ ਕਾਰਵਾਈ ਕਰਦਾ ਹੈ: “ਸਾਰ” 'ਤੇ ਕਲਿੱਕ ਕਰਦਾ ਹੈ, ਫਾਈਲ ਅਪਲੋਡ ਕਰਦਾ ਹੈ, ਜਾਂ ਸੁਨੇਹਾ ਭੇਜਦਾ ਹੈ।
2. ਤੁਹਾਡਾ ਫਰੰਟ ਐਂਡ ਤੁਹਾਡੇ ਆਪਣੇ ਸਰਵਰ ਨੂੰ ਕਾਲ ਕਰਦਾ ਹੈ, AI ਪ੍ਰਦਾਤਾ ਨੂੰ ਨਹੀਂ।
3. ਤੁਹਾਡਾ ਸਰਵਰ ਬੇਨਤੀ ਬਣਾਉਂਦਾ ਹੈ: ਸਿਸਟਮ ਹਿਦਾਇਤਾਂ, ਯੂਜ਼ਰ ਦਾ ਇਨਪੁੱਟ, ਅਤੇ ਤੁਹਾਡੇ ਡੇਟਾਬੇਸ ਤੋਂ ਉਹ ਡੇਟਾ ਜੋ ਮਾਡਲ ਨੂੰ ਚਾਹੀਦਾ ਹੈ, ਸਿਰਫ਼ ਉਹ ਡੇਟਾ ਜੋ ਇਸ ਯੂਜ਼ਰ ਨੂੰ ਵੇਖਣ ਦੀ ਇਜਾਜ਼ਤ ਹੈ।
4. ਤੁਹਾਡਾ ਸਰਵਰ LLM API ਨੂੰ ਕਾਲ ਕਰਦਾ ਹੈ ਇੱਕ ਐਨਵਾਇਰਨਮੈਂਟ ਵੈਰੀਏਬਲ ਵਿੱਚ ਸੇਵ ਕੀਤੀ ਕੀ ਨਾਲ।
5. ਤੁਹਾਡਾ ਸਰਵਰ ਜਵਾਬ ਦੀ ਜਾਂਚ ਕਰਦਾ ਹੈ: ਠੀਕ JSON, ਜਾਣਿਆ ਲੇਬਲ, ਵਾਜਬ ਲੰਬਾਈ, ਅਤੇ ਫਿਰ ਸੇਵ ਜਾਂ ਵਾਪਸ ਭੇਜਦਾ ਹੈ।
6. ਫਰੰਟ ਐਂਡ ਨਤੀਜਾ ਦਿਖਾਉਂਦਾ ਹੈ, ਲੰਮੇ ਜਵਾਬਾਂ ਲਈ ਆਉਂਦੇ ਹੀ ਟੈਕਸਟ ਸਟ੍ਰੀਮ ਕਰਦਾ ਹੋਇਆ।

ਕੀ ਸਰਵਰ 'ਤੇ ਕਦਮ 4 ਵਿੱਚ ਰਹਿੰਦੀ ਹੈ ਅਤੇ ਕਦੇ ਬ੍ਰਾਊਜ਼ਰ ਤੱਕ ਨਹੀਂ ਪਹੁੰਚਦੀ। ਜੇ API ਦਾ ਵਿਚਾਰ ਨਵਾਂ ਹੈ, ਤਾਂ API ਕੀ ਹੁੰਦਾ ਹੈ ਇੱਕ ਛੋਟੀ ਜਾਣ-ਪਛਾਣ ਹੈ, ਅਤੇ LLM APIs ਕਿਵੇਂ ਵਰਤੀਏ ਟੋਕਨ, ਮਾਡਲ ਅਤੇ ਕੀਆਂ ਬਾਰੇ ਹੋਰ ਡੂੰਘਾਈ ਨਾਲ ਦੱਸਦੀ ਹੈ।

ਪ੍ਰਦਾਤਾ ਅਤੇ ਮਾਡਲ ਚੁਣਨਾ

ਵੱਡੇ ਪ੍ਰਦਾਤਾ, ਜਿਵੇਂ OpenAI, Anthropic, Google ਅਤੇ ਹੋਰ, ਸਾਰੇ ਲਗਭਗ ਇੱਕੋ ਜਿਹੀ ਬਣਤਰ ਵਾਲੇ ਟੈਕਸਟ APIs ਦਿੰਦੇ ਹਨ। ਚੁਣਦੇ ਸਮੇਂ ਇਹ ਸਵਾਲ ਉਪਯੋਗੀ ਹਨ:

• ਤੁਹਾਡੇ ਕੰਮ 'ਤੇ ਗੁਣਵੱਤਾ। ਦੋ ਜਾਂ ਤਿੰਨ ਮਾਡਲਾਂ 'ਤੇ ਆਪਣੀ ਐਪ ਦੇ ਕੁਝ ਅਸਲ ਉਦਾਹਰਣ ਅਜ਼ਮਾਓ। ਫਰਕ ਅਕਸਰ ਤੁਹਾਡੇ ਡੇਟਾ 'ਤੇ ਆਮ ਬੈਂਚਮਾਰਕਾਂ ਨਾਲੋਂ ਸਾਫ਼ ਦਿਸਦਾ ਹੈ।
• ਆਕਾਰ ਬਨਾਮ ਖਰਚਾ। ਪ੍ਰਦਾਤਾ ਵੱਡੇ ਅਤੇ ਵਧੇਰੇ ਸਮਰੱਥ ਮਾਡਲ ਦਿੰਦੇ ਹਨ, ਅਤੇ ਛੋਟੇ, ਸਸਤੇ ਅਤੇ ਤੇਜ਼ ਵੀ। ਵਰਗੀਕਰਨ ਅਤੇ ਸਧਾਰਨ ਕੱਢਣਾ ਅਕਸਰ ਛੋਟੇ ਮਾਡਲ 'ਤੇ ਚੰਗਾ ਚੱਲਦਾ ਹੈ; ਲੰਮੀ ਸੋਚ ਜਾਂ ਬਾਰੀਕ ਲਿਖਤ ਲਈ ਵੱਡਾ ਚਾਹੀਦਾ ਹੋ ਸਕਦਾ ਹੈ।
• ਬਣਤਰ ਵਾਲਾ ਆਉਟਪੁੱਟ। ਕੱਢਣ ਅਤੇ ਵਰਗੀਕਰਨ ਲਈ, ਅਜਿਹਾ API ਫੀਚਰ ਚੁਣੋ ਜੋ ਮਾਡਲ ਨੂੰ ਤੁਹਾਡੀ ਦਿੱਤੀ ਸਕੀਮਾ ਨਾਲ ਮਿਲਦਾ JSON ਵਾਪਸ ਕਰਨ ਦੇਵੇ, ਨਾ ਕਿ ਫ੍ਰੀ ਟੈਕਸਟ ਪਾਰਸ ਕਰਨਾ।
• ਡੇਟਾ ਦੀ ਸੰਭਾਲ। ਪ੍ਰਦਾਤਾ ਦੀਆਂ ਸ਼ਰਤਾਂ ਪੜ੍ਹੋ ਕਿ API ਇਨਪੁੱਟ ਸਟੋਰ ਹੁੰਦੇ ਹਨ ਜਾਂ ਟ੍ਰੇਨਿੰਗ ਲਈ ਵਰਤੇ ਜਾਂਦੇ ਹਨ, ਅਤੇ ਕੀ ਇਹ ਤੁਹਾਡੇ ਯੂਜ਼ਰਾਂ ਦੇ ਡੇਟਾ ਲਈ ਠੀਕ ਹੈ।
• ਸੀਮਾਵਾਂ। ਨਵੇਂ ਅਕਾਊਂਟਾਂ ਦੀਆਂ ਰੇਟ ਸੀਮਾਵਾਂ ਅਕਸਰ ਘੱਟ ਹੁੰਦੀਆਂ ਹਨ; ਲਾਂਚ ਤੋਂ ਪਹਿਲਾਂ ਜਾਂਚ ਲਓ।

ਮਾਡਲ ਦੇ ਨਾਮ ਅਤੇ ਕੀਮਤਾਂ ਅਕਸਰ ਬਦਲਦੇ ਹਨ, ਇਸ ਲਈ ਕੋਡ ਵਿੱਚ ਮਾਡਲ ਦਾ ਨਾਮ ਕਈ ਥਾਵਾਂ 'ਤੇ ਹਾਰਡ-ਕੋਡ ਕਰਨ ਦੀ ਬਜਾਏ ਸੰਰਚਨਾ ਤੋਂ ਪੜ੍ਹੋ।

ਇੱਕ ਫੀਚਰ ਜੋੜਨਾ, ਕਦਮ ਦਰ ਕਦਮ

ਇੱਕ ਠੋਸ ਉਦਾਹਰਣ ਲਓ: ਇੱਕ ਛੋਟਾ CRM ਜਿੱਥੇ ਹਰ ਸੰਪਰਕ ਕੋਲ ਨੋਟਾਂ ਦਾ ਲੰਮਾ ਇਤਿਹਾਸ ਹੈ।

1. ਕੀ ਸੇਵ ਕਰੋ। ਆਪਣੇ ਪ੍ਰਦਾਤਾ ਦੇ ਡੈਸ਼ਬੋਰਡ ਵਿੱਚ ਕੀ ਬਣਾਓ ਅਤੇ ਉਸਨੂੰ ਸਰਵਰ-ਸਾਈਡ ਸੀਕ੍ਰੇਟ ਵਜੋਂ ਸੇਵ ਕਰੋ, ਜਿਵੇਂ OPENAI_API_KEY ਜਾਂ ANTHROPIC_API_KEY।

2. ਇੱਕ ਤੰਗ ਫੀਚਰ ਮੰਗੋ:

ਸੰਪਰਕ ਪੇਜ 'ਤੇ ਇੱਕ "Summarise" ਬਟਨ ਜੋੜੋ। ਸਰਵਰ 'ਤੇ, ਸੰਪਰਕ ਦੇ ਆਖਰੀ 20 ਨੋਟ [PROVIDER] ਨੂੰ ਸੀਕ੍ਰੇਟ [ENV_NAME] ਵਰਤ ਕੇ ਭੇਜੋ, ਅਤੇ ਹਿਦਾਇਤ ਦਿਓ ਕਿ ਤਿੰਨ ਬੁਲੇਟ ਲਿਖੇ: ਮੌਜੂਦਾ ਸਥਿਤੀ, ਖੁੱਲ੍ਹੇ ਸਵਾਲ, ਅਗਲਾ ਕਦਮ। ਸਿਰਫ਼ ਉਹ ਨੋਟ ਸ਼ਾਮਲ ਕਰੋ ਜੋ ਲੌਗਇਨ ਯੂਜ਼ਰ ਵੇਖ ਸਕਦਾ ਹੈ। ਲੋਡਿੰਗ ਹਾਲਤ ਦਿਖਾਓ, ਸਾਰ ਨੂੰ ਟਾਈਮਸਟੈਂਪ ਨਾਲ ਸੇਵ ਕਰੋ, ਅਤੇ ਜੇ ਕਾਲ ਫੇਲ੍ਹ ਹੋਵੇ ਤਾਂ "Couldn't summarise right now" ਦਿਖਾਓ। ਕੀ ਕਦੇ ਬ੍ਰਾਊਜ਼ਰ ਨੂੰ ਨਾ ਭੇਜੋ।

3. ਜਿੱਥੇ ਟਾਈਪਿੰਗ ਬਚੇ, ਉੱਥੇ ਕੱਢਣਾ ਜੋੜੋ:

ਜਦੋਂ ਯੂਜ਼ਰ "Quick add" ਬਾਕਸ ਵਿੱਚ ਈਮੇਲ ਸਿਗਨੇਚਰ ਪੇਸਟ ਕਰੇ, ਤਾਂ ਸਰਵਰ 'ਤੇ [PROVIDER] ਨੂੰ ਕਾਲ ਕਰੋ ਅਤੇ ਨਾਮ, ਕੰਪਨੀ, ਅਹੁਦਾ, ਈਮੇਲ ਅਤੇ ਫੋਨ ਵਾਲਾ JSON ਵਾਪਸ ਕਰੋ, ਪ੍ਰਦਾਤਾ ਦਾ ਬਣਤਰ ਵਾਲਾ ਆਉਟਪੁੱਟ ਫੀਚਰ ਵਰਤ ਕੇ। JSON ਨੂੰ ਸਰਵਰ 'ਤੇ ਜਾਂਚੋ, ਨਵਾਂ ਸੰਪਰਕ ਫਾਰਮ ਉਸ ਨਾਲ ਭਰੋ, ਅਤੇ ਯੂਜ਼ਰ ਨੂੰ ਸੇਵ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਸੋਧਣ ਦਿਓ। ਅੰਦਾਜ਼ਾ ਲਾਉਣ ਦੀ ਬਜਾਏ ਖਾਲੀ ਛੱਡੋ।

"ਸੇਵ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਯੂਜ਼ਰ ਸੋਧੇ" ਇਹ ਸਭ ਤੋਂ ਅਹਿਮ ਹਿੱਸਾ ਹੈ: ਮਾਡਲ ਸੁਝਾਉਂਦਾ ਹੈ, ਫੈਸਲਾ ਵਿਅਕਤੀ ਕਰਦਾ ਹੈ।

4. ਪਿਛੋਕੜ ਵਿੱਚ ਵਰਗੀਕਰਨ ਕਰੋ:

ਜਦੋਂ ਨਵੀਂ ਸਪੋਰਟ ਟਿਕਟ ਆਵੇ, ਇਸਨੂੰ ਬਿਲਕੁਲ ਇਨ੍ਹਾਂ ਵਿੱਚੋਂ ਇੱਕ ਵਿੱਚ ਵਰਗੀਕ੍ਰਿਤ ਕਰੋ: billing, bug, feature request, account access, other। ਇੱਕ ਛੋਟਾ, ਘੱਟ ਖਰਚੇ ਵਾਲਾ ਮਾਡਲ ਵਰਤੋ। ਜੇ ਜਵਾਬ ਇਨ੍ਹਾਂ ਲੇਬਲਾਂ ਵਿੱਚੋਂ ਨਾ ਹੋਵੇ, ਤਾਂ "other" ਸੇਵ ਕਰੋ। ਲੇਬਲ ਨੂੰ ਸੋਧਣਯੋਗ ਟੈਗ ਵਜੋਂ ਦਿਖਾਓ।

5. ਅਸਲ ਗੜਬੜ ਵਾਲੇ ਡੇਟਾ ਨਾਲ ਜਾਂਚੋ: ਲੰਮੇ ਨੋਟ, ਖਾਲੀ ਨੋਟ, ਹੋਰ ਭਾਸ਼ਾਵਾਂ, ਬਿਨਾਂ ਫੋਨ ਨੰਬਰ ਵਾਲਾ ਸਿਗਨੇਚਰ, ਅਤੇ ਰਿਲੀਜ਼ ਤੋਂ ਪਹਿਲਾਂ ਵੀਹ ਨਤੀਜੇ ਨਾਲ-ਨਾਲ ਦੇਖੋ।

ਕੰਮ ਕਰਨ ਵਾਲੀਆਂ ਹਿਦਾਇਤਾਂ ਕਿਵੇਂ ਲਿਖੋ

ਹਰ ਬੇਨਤੀ ਨਾਲ ਭੇਜੀਆਂ ਹਿਦਾਇਤਾਂ (ਜਿਨ੍ਹਾਂ ਨੂੰ ਅਕਸਰ ਸਿਸਟਮ ਪ੍ਰੋਂਪਟ ਕਿਹਾ ਜਾਂਦਾ ਹੈ) ਵਿੱਚ ਹੀ ਕੁਆਲਟੀ ਦੀ ਜੜ੍ਹ ਹੁੰਦੀ ਹੈ।

• ਦੱਸੋ ਕਿ ਇਹ ਕਿਸ ਲਈ ਹੈ ਅਤੇ ਚੰਗਾ ਨਤੀਜਾ ਕਿਹੋ ਜਿਹਾ ਹੈ। “ਸਾਰ ਵਿਕਰੀ ਕਰਨ ਵਾਲਾ ਕਾਲ ਤੋਂ ਪਹਿਲਾਂ 10 ਸਕਿੰਟਾਂ ਵਿੱਚ ਪੜ੍ਹਦਾ ਹੈ” ਮਾਡਲ ਨੂੰ ਇੱਕ ਨਿਸ਼ਾਨਾ ਦਿੰਦਾ ਹੈ।
• ਫਾਰਮੈਟ ਤੈਅ ਕਰੋ। ਬੁਲੇਟਾਂ ਦੀ ਸਹੀ ਗਿਣਤੀ, ਲੰਬਾਈ ਦੀ ਹੱਦ, ਫੀਲਡ, ਲੇਬਲ।
• ਦੱਸੋ ਕਿ ਅਨਿਸ਼ਚਿਤ ਹੋਣ 'ਤੇ ਕੀ ਕਰਨਾ ਹੈ। “ਜੇ ਨੋਟ ਅਗਲੇ ਕਦਮ ਦਾ ਜ਼ਿਕਰ ਨਾ ਕਰਨ, ਤਾਂ ਲਿਖੋ 'No next step recorded'।” ਇਸ ਨਾਲ ਕਾਢੇ ਹੋਏ ਜਵਾਬ ਘਟਦੇ ਹਨ।
• ਦੋ ਜਾਂ ਤਿੰਨ ਉਦਾਹਰਣ ਦਿਓ ਕੱਢਣ ਅਤੇ ਵਰਗੀਕਰਨ ਲਈ ਚੰਗੇ ਇਨਪੁੱਟ ਅਤੇ ਆਉਟਪੁੱਟ ਦੇ।
• ਹਿਦਾਇਤਾਂ ਨੂੰ ਯੂਜ਼ਰ ਸਮੱਗਰੀ ਤੋਂ ਵੱਖ ਰੱਖੋ, ਅਤੇ ਯੂਜ਼ਰ ਸਮੱਗਰੀ ਨੂੰ ਸਾਫ਼ ਲੇਬਲ ਕਰੋ, ਤਾਂ ਜੋ ਮਾਡਲ ਦੋਵਾਂ ਨੂੰ ਫਰਕ ਕਰ ਸਕੇ।

ਪ੍ਰੋਂਪਟ ਆਪਣੇ ਕੋਡਬੇਸ ਵਿੱਚ ਫਾਈਲਾਂ ਵਿੱਚ ਰੱਖੋ, ਤਾਂ ਜੋ ਉਹ ਬਾਕੀ ਕੋਡ ਵਾਂਗ ਵਰਜਨ ਕੀਤੇ ਅਤੇ ਸਮੀਖਿਆ ਯੋਗ ਰਹਿਣ।

ਖਰਚਾ ਕਾਬੂ ਵਿੱਚ ਰੱਖਣਾ

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

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

ਜੇ AI ਫੀਚਰ ਤੁਹਾਡੇ ਉਤਪਾਦ ਦਾ ਕੇਂਦਰ ਹਨ, ਤਾਂ ਉਨ੍ਹਾਂ ਦਾ ਚੱਲਣ ਦਾ ਖਰਚਾ ਆਪਣੀ ਕੀਮਤ ਵਿੱਚ ਗਿਣੋ, ਨਾ ਕਿ ਆਪਣੇ ਉੱਤੇ ਸਹਾਰੋ।

ਸੁਰੱਖਿਆ ਅਤੇ ਭਰੋਸਾ

AI ਦਾ ਨਤੀਜਾ ਸੰਭਾਵਨਾ 'ਤੇ ਅਧਾਰਤ ਹੈ। ਇਹ ਭਰੋਸੇ ਨਾਲ ਗਲਤ ਹੋ ਸਕਦਾ ਹੈ, ਅਤੇ ਜੋ ਟੈਕਸਟ ਇਹ ਪੜ੍ਹਦਾ ਹੈ ਉਸ ਨਾਲ ਭਟਕਾਇਆ ਜਾ ਸਕਦਾ ਹੈ। ਇਸ ਲਈ ਬਣਾਓ:

• ਨਤੀਜੇ ਨੂੰ ਅਵਿਸ਼ਵਾਸਯੋਗ ਇਨਪੁੱਟ ਮੰਨੋ। ਬਣਤਰ ਦੀ ਜਾਂਚ ਕਰੋ, HTML ਵਜੋਂ ਦਿਖਾਉਣ ਤੋਂ ਪਹਿਲਾਂ ਇਸਨੂੰ ਐਸਕੇਪ ਕਰੋ, ਅਤੇ ਇਸਨੂੰ ਕਦੇ ਕੋਡ ਜਾਂ ਡੇਟਾਬੇਸ ਕਵੇਰੀ ਵਜੋਂ ਨਾ ਚਲਾਓ।
• ਜਿਸ ਚੀਜ਼ ਦੇ ਨਤੀਜੇ ਹਨ, ਉਸ ਵਿੱਚ ਮਨੁੱਖ ਨੂੰ ਸ਼ਾਮਲ ਰੱਖੋ: ਈਮੇਲ ਭੇਜਣਾ, ਰਿਕਾਰਡ ਬਦਲਣਾ, ਭੁਗਤਾਨ ਵਾਪਸ ਕਰਨਾ। ਮਾਡਲ ਡਰਾਫਟ ਬਣਾਉਂਦਾ ਹੈ; ਇਨਸਾਨ ਪੱਕਾ ਕਰਦਾ ਹੈ।
• ਪ੍ਰੋਂਪਟ ਇੰਜੈਕਸ਼ਨ ਤੋਂ ਬਚਾਅ ਕਰੋ। ਦਸਤਾਵੇਜ਼ ਜਾਂ ਸੁਨੇਹੇ ਵਿੱਚ “ਆਪਣੀਆਂ ਹਿਦਾਇਤਾਂ ਨੂੰ ਅਣਡਿੱਠਾ ਕਰੋ” ਵਰਗਾ ਟੈਕਸਟ ਹੋ ਸਕਦਾ ਹੈ। ਮਾਡਲ ਨੂੰ ਸਿਰਫ਼ ਉਹੀ ਦਿਖਾਓ ਜੋ ਮੌਜੂਦਾ ਯੂਜ਼ਰ ਵੇਖ ਸਕਦਾ ਹੈ, ਅਤੇ ਉਸਨੂੰ ਅਜਿਹੇ ਟੂਲ ਨਾ ਦਿਓ ਜੋ ਤੁਹਾਡਾ ਕੋਡ ਪਹਿਲਾਂ ਇਜਾਜ਼ਤ ਜਾਂਚੇ ਬਿਨਾਂ ਸੰਵੇਦਨਸ਼ੀਲ ਕਾਰਵਾਈਆਂ ਕਰ ਸਕਣ।
• AI ਸਮੱਗਰੀ ਨੂੰ ਲੇਬਲ ਕਰੋ, ਤਾਂ ਜੋ ਯੂਜ਼ਰ ਜਾਣ ਕਿ ਸਾਰ ਜਾਂ ਸੁਝਾਅ ਬਣਾਇਆ ਗਿਆ ਸੀ ਅਤੇ ਉਹ ਉਸਨੂੰ ਜਾਂਚ ਸਕਣ।
• ਫੇਲ੍ਹ ਹੋਣ ਨੂੰ ਸੁਚੱਜੇ ਢੰਗ ਨਾਲ ਸੰਭਾਲੋ। ਪ੍ਰਦਾਤਾਵਾਂ ਵਿੱਚ ਆਊਟੇਜ ਅਤੇ ਰੇਟ ਸੀਮਾਵਾਂ ਹੁੰਦੀਆਂ ਹਨ। ਟਾਈਮ ਆਊਟ ਕਰੋ, ਸਾਫ਼ ਸੁਨੇਹਾ ਦਿਖਾਓ, ਅਤੇ ਬਾਕੀ ਐਪ ਨੂੰ ਚੱਲਦਾ ਰਹਿਣ ਦਿਓ।
• ਵੇਖੋ ਕਿ ਯੂਜ਼ਰ ਕੀ ਭੇਜਦੇ ਹਨ। ਖੁੱਲ੍ਹੇ ਟੈਕਸਟ ਇਨਪੁੱਟਾਂ ਲਈ ਮੌਡਰੇਸ਼ਨ ਕਦਮ 'ਤੇ ਵਿਚਾਰ ਕਰੋ, ਅਤੇ ਆਪਣੀ ਪ੍ਰਾਈਵੇਸੀ ਪਾਲਿਸੀ ਵਿੱਚ ਸਾਫ਼ ਲਿਖੋ ਕਿ ਸਮੱਗਰੀ ਤੀਜੀ ਧਿਰ AI ਪ੍ਰਦਾਤਾ ਵੱਲੋਂ ਪ੍ਰਕਿਰਿਆ ਹੁੰਦੀ ਹੈ।

ਸੁਰੱਖਿਆ ਜਾਂਚਾਂ ਦੀ ਵਿਆਪਕ ਸੂਚੀ AI ਨਾਲ ਬਣੀਆਂ ਐਪਾਂ ਲਈ ਸੁਰੱਖਿਆ ਚੈੱਕਲਿਸਟ ਵਿੱਚ ਹੈ।

ਆਮ ਗਲਤੀਆਂ

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

Mythex ਵਿੱਚ AI ਫੀਚਰ ਜੋੜਨਾ

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

ਸਵਾਲ