ਲੋਕਾਂ ਦੁਆਰਾ ਟਾਈਪ ਕੀਤੇ ਜਾਣ ਵਾਲੇ ਸ਼ਬਦਾਂ ਨੂੰ ਅਸਲ ਵਿੱਚ ਸਮਝਣ ਵਾਲਾ AI chatbot ਬਣਾਉਣ ਲਈ ਤੁਹਾਨੂੰ ਕਿਸੇ ਵੱਡੀ ਟੀਮ ਜਾਂ ਬਹੁਤ ਜ਼ਿਆਦਾ ਬਜਟ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ। 2025 ਵਿੱਚ, language model providers ਦੇ free tiers ਇਕੱਲੇ ਬਣਾਉਣ ਵਾਲਿਆਂ, ਵਿਦਿਆਰਥੀਆਂ ਅਤੇ side-project hackers ਨੂੰ ਉਹਨਾਂ ਉਹੀ natural language processing stacks ਤੱਕ ਸਿੱਧੀ ਪਹੁੰਚ ਦਿੰਦੇ ਹਨ ਜੋ ਮਿਲੀਅਨ-ਡਾਲਰ ਦੇ ਉਤਪਾਦਾਂ ਵਿੱਚ ਚੱਲਦੇ ਹਨ। ਰੁਕਾਵਟ ਹੁਣ ਬਦਲ ਗਈ ਹੈ। ਇਹ ਹੁਣ ਸ਼ੁਰੂ ਤੋਂ ਇੱਕ ਮਾਡਲ ਨੂੰ ਟ੍ਰੇਨ ਕਰਨ ਬਾਰੇ ਨਹੀਂ ਹੈ, ਜਿਸ ਲਈ GPU ਦੇ ਰੈਕ ਅਤੇ ਮਹੀਨਿਆਂ ਦੀ ਖੋਜ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। ਇਹ ਇੱਕ ਮੌਜੂਦਾ 'ਬ੍ਰੇਨ' (brain) ਨੂੰ ਕਾਲ ਕਰਨਾ ਸਿੱਖਣ ਅਤੇ ਉਸਨੂੰ ਕਿਸੇ ਲਾਭਦਾਇਕ ਚੀਜ਼ ਨਾਲ ਜੋੜਨ ਬਾਰੇ ਹੈ।
ਜੇਕਰ ਤੁਸੀਂ ਇੱਕ Python script ਲਿਖ ਸਕਦੇ ਹੋ ਅਤੇ API documentation ਪੜ੍ਹ ਸਕਦੇ ਹੋ, ਤਾਂ ਤੁਹਾਡੇ ਕੋਲ ਪਹਿਲਾਂ ਹੀ ਕੱਚਾ ਮਾਲ ਮੌਜੂਦ ਹੈ।
Free APIs ਸਭ ਕੁਝ ਕਿਉਂ ਬਦਲ ਦਿੰਦੀਆਂ ਹਨ
ਕੁਝ ਸਮਾਂ ਪਹਿਲਾਂ ਤੱਕ, ਇੱਕ conversational agent ਬਣਾਉਣ ਦਾ ਮਤਲਬ ਸੀ training data ਇਕੱਠਾ ਕਰਨਾ, text ਨੂੰ ਸਾਫ਼ ਕਰਨਾ, ਇੱਕ architecture ਚੁਣਨਾ, ਅਤੇ ਹਫ਼ਤਿਆਂ ਤੱਕ ਬਿਜਲੀ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਜਦੋਂ ਇੱਕ ਮਾਡਲ grammar ਅਤੇ context ਸਿੱਖ ਰਿਹਾ ਹੁੰਦਾ ਸੀ। ਹੁਣ ਉਸ ਵਿੱਚੋਂ ਜ਼ਿਆਦਾਤਰ ਕੰਮ commoditized ਹੋ ਗਿਆ ਹੈ। Providers ਵਿਸ਼ਾਲ pre-trained models ਨੂੰ ਹੋਸਟ ਕਰਦੇ ਹਨ ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਸਧਾਰਨ web endpoints ਰਾਹੀਂ ਉਪਲਬਧ ਕਰਵਾਉਂਦੇ ਹਨ। ਤੁਸੀਂ HTTPS ਰਾਹੀਂ text ਭੇਜਦੇ ਹੋ; ਉਹ ਇੱਕ prediction ਵਾਪਸ ਕਰਦੇ ਹਨ। ਉਹ prediction ਹੀ ਤੁਹਾਡੇ chatbot ਦਾ ਜਵਾਬ ਹੁੰਦਾ ਹੈ।
ਇਹ ਪ੍ਰਬੰਧ ਤੁਹਾਨੂੰ ਗਣਿਤ (mathematics) ਨੂੰ ਛੱਡ ਕੇ ਮਾਡਲ ਦੇ ਆਲੇ-ਦੁਆਲੇ ਦੀ ਮਸ਼ੀਨਰੀ 'ਤੇ ਧਿਆਨ ਕੇਂਦਰਿਤ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ। ਤੁਹਾਡਾ ਕੰਮ prompts ਨੂੰ ਪ੍ਰਬੰਧਿਤ ਕਰਨਾ, conversation memory ਨੂੰ ਸੰਭਾਲਣਾ, ਅਤੇ user experience ਨੂੰ ਰੂਪ ਦੇਣਾ ਬਣ ਜਾਂਦਾ ਹੈ। Free tiers ਇਸ ਲਈ ਮੌਜੂਦ ਹਨ ਕਿਉਂਕਿ providers ਚਾਹੁੰਦੇ ਹਨ ਕਿ developers ਉਹਨਾਂ ਦੇ platforms 'ਤੇ ਆਪਣੀਆਂ ਆਦਤਾਂ ਬਣਾਉਣ। ਇਹ ਸੀਮਾਵਾਂ ਆਮ ਤੌਰ 'ਤੇ prototypes, ਸਿੱਖਣ ਵਾਲੇ ਪ੍ਰੋਜੈਕਟਾਂ ਅਤੇ ਛੋਟੇ ਅੰਦਰੂਨੀ ਟੂਲਸ ਲਈ ਕਾਫ਼ੀ ਹਨ। ਇੱਕ ਵਾਰ ਜਦੋਂ ਤੁਸੀਂ ਇਹਨਾਂ ਤੋਂ ਅੱਗੇ ਵਧ ਜਾਂਦੇ ਹੋ, ਤਾਂ scaling ਸਿਰਫ਼ ਇੱਕ billing ਬਦਲਾਅ ਦੀ ਦੂਰੀ 'ਤੇ ਹੁੰਦੀ ਹੈ।
ਆਪਣਾ Core Stack ਸੈੱਟ ਕਰਨਾ
Python ਇਸ ਤਰ੍ਹਾਂ ਦੇ ਕੰਮ ਲਈ ਸਭ ਤੋਂ ਵਧੀਆ ਸ਼ੁਰੂਆਤੀ ਭਾਸ਼ਾ ਬਣੀ ਹੋਈ ਹੈ। ਇਸਦਾ syntax ਤੁਹਾਡੇ ਰਸਤੇ ਵਿੱਚ ਨਹੀਂ ਆਉਂਦਾ, ਅਤੇ ਲਗਭਗ ਹਰ AI provider ਕਿਸੇ ਵੀ ਹੋਰ ਭਾਸ਼ਾ ਤੋਂ ਪਹਿਲਾਂ Python ਵਿੱਚ copy-paste ਉਦਾਹਰਣਾਂ ਪ੍ਰਕਾਸ਼ਿਤ ਕਰਦਾ ਹੈ।
ਤੁਹਾਡੇ ਪਹਿਲੇ ਠੋਸ ਕਦਮ ਬਹੁਤ ਘੱਟ ਹਨ:
- Python 3.8 ਜਾਂ ਨਵਾਂ version install ਕਰੋ।
- ਆਪਣੇ terminal ਵਿੱਚ
pip install requestsਚਲਾ ਕੇrequestslibrary install ਕਰੋ। - OpenAI ਨਾਲ sign up ਕਰੋ ਅਤੇ ਆਪਣੇ account dashboard ਤੋਂ ਇੱਕ API key ਬਣਾਓ।
ਉਸ key ਨੂੰ ਇੱਕ environment variable ਜਾਂ .env file ਦੇ ਅੰਦਰ ਸਟੋਰ ਕਰੋ। ਇਸਨੂੰ ਕਦੇ ਵੀ ਸਿੱਧਾ ਆਪਣੇ source code ਵਿੱਚ ਪੇਸਟ ਨਾ ਕਰੋ। ਜੇਕਰ ਤੁਸੀਂ hardcoded key ਦੇ ਨਾਲ GitHub 'ਤੇ repository push ਕਰਦੇ ਹੋ, ਤਾਂ automated scrapers ਕੁਝ ਹੀ ਮਿੰਟਾਂ ਵਿੱਚ ਇਸਨੂੰ ਲੱਭ ਲੈਣਗੇ ਅਤੇ ਤੁਹਾਡੇ free credits ਖਤਮ ਕਰ ਦੇਣਗੇ। ਇੱਕ ਸਧਾਰਨ .env file ਇਸ ਤਰ੍ਹਾਂ ਦਿਖਾਈ ਦਿੰਦੀ ਹੈ:
OPENAI_API_KEY=sk-your-key-here
ਫਿਰ ਇਸਨੂੰ os.environ ਜਾਂ python-dotenv ਵਰਗੀ library ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਆਪਣੀ script ਵਿੱਚ load ਕਰੋ। ਇਹ ਇੱਕ ਆਦਤ ਸ਼ੌਕੀਆ ਪ੍ਰੋਜੈਕਟਾਂ ਨੂੰ ਉਹਨਾਂ ਪ੍ਰੋਜੈਕਟਾਂ ਤੋਂ ਵੱਖ ਕਰਦੀ ਹੈ ਜੋ ਅਸਲ ਦੁਨੀਆ ਵਿੱਚ ਟਿਕਦੇ ਹਨ।
ਆਪਣੇ ਪ੍ਰੋਜੈਕਟ ਲਈ ਢੁਕਵੀਂ API ਚੁਣਨਾ
ਕੋਡ ਦੀ ਇੱਕ ਹੋਰ ਲਾਈਨ ਲਿਖਣ ਤੋਂ ਪਹਿਲਾਂ, ਤਿੰਨ ਕਾਰਕਾਂ ਦੇ ਆਧਾਰ 'ਤੇ providers ਦੀ ਤੁਲਨਾ ਕਰਨ ਲਈ ਦਸ ਮਿੰਟ spend ਕਰੋ:
Free tiers ਲਈ usage limits। ਕੁਝ ਸੇਵਾਵਾਂ ਇੱਕ ਨਿਸ਼ਚਿਤ credit grant ਦਿੰਦੀਆਂ ਹਨ ਜੋ ਤਿੰਨ ਮਹੀਨਿਆਂ ਬਾਅਦ ਖਤਮ ਹੋ ਜਾਂਦੀ ਹੈ। ਹੋਰ ਹਰ ਮਹੀਨੇ token allowance ਨੂੰ reset ਕਰਦੇ ਹਨ। ਇੱਕ token ਲਗਭਗ ਇੱਕ ਆਮ ਅੰਗਰੇਜ਼ੀ ਸ਼ਬਦ ਦਾ ਤਿੰਨ-ਚੌਥਾਈ ਹੁੰਦਾ ਹੈ। ਜੇਕਰ free tier ਤੁਹਾਨੂੰ 200,000 tokens ਦਿੰਦਾ ਹੈ, ਤਾਂ ਇਹ ਹਜ਼ਾਰਾਂ ਸਧਾਰਨ ਗੱਲਬਾਤ ਲਈ ਕਾਫ਼ੀ ਹੈ, ਪਰ ਜੇਕਰ ਤੁਸੀਂ prompt ਵਿੱਚ ਪੂਰੀਆਂ ਕਿਤਾਬਾਂ ਪਾ ਦਿੰਦੇ ਹੋ ਤਾਂ ਇਹ ਜਲਦੀ ਖਤਮ ਹੋ ਜਾਵੇਗਾ। Rate limits ਦੀ ਵੀ ਜਾਂਚ ਕਰੋ। ਇੱਕ ਸੇਵਾ ਪ੍ਰਤੀ ਮਹੀਨਾ ਲੱਖਾਂ tokens ਦੀ ਇਜਾਜ਼ਤ ਦੇ ਸਕਦੀ ਹੈ ਪਰ ਤੁਹਾਨੂੰ ਪ੍ਰਤੀ ਮਿੰਟ ਤਿੰਨ requests ਤੱਕ ਸੀਮਤ ਕਰ ਸਕਦੀ ਹੈ।
Documentation ਦੀ ਗੁਣਵੱਤਾ। ਅਜਿਹੇ ਅਧਿਕਾਰਤ guides ਲੱਭੋ ਜੋ ਸਿਰਫ਼ curl commands ਹੀ ਨਹੀਂ, ਸਗੋਂ plain requests ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ Python ਉਦਾਹਰਣਾਂ ਨੂੰ ਵੀ ਦਿਖਾਉਂਦੇ ਹੋਣ। ਚੰਗੀ documentation error codes ਨੂੰ ਸਪਸ਼ਟ ਰੂਪ ਵਿੱਚ ਸਮਝਾਉਂਦੀ ਹੈ, ਖਾਸ ਕਰਕੇ HTTP 429 (rate limit) ਅਤੇ 401 (invalid key)। ਇਸ ਵਿੱਚ ਇਹ ਵੀ ਲਿਸਟ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ ਕਿ free tier 'ਤੇ ਕਿਹੜੇ models ਉਪਲਬਧ ਹਨ, ਕਿਉਂਕਿ ਸਭ ਤੋਂ ਸਸਤਾ plan ਅਕਸਰ ਨਵੇਂ flagship models ਨੂੰ ਸ਼ਾਮਲ ਨਹੀਂ ਕਰਦਾ।
Integration ਦੀ ਸੌਖ। ਇੱਕ ਸਾਫ਼ REST API ਜੋ JSON ਨੂੰ ਸਵੀਕਾਰ ਕਰਦੀ ਹੈ ਅਤੇ JSON ਵਾਪਸ ਕਰਦੀ ਹੈ, ਉਹ ਆਦਰਸ਼ ਹੈ। ਤੁਸੀਂ ਉਹਨਾਂ providers ਤੋਂ ਬਚਣਾ ਚਾਹੁੰਦੇ ਹੋ ਜੋ ਸਿਰਫ਼ ਇੱਕ text string ਭੇਜਣ ਲਈ ਤੁਹਾਨੂੰ ਭਾਰੀ proprietary SDKs install ਕਰਨ ਲਈ ਮਜਬੂਰ ਕਰਦੇ ਹਨ। ਜੇਕਰ ਤੁਸੀਂ requests.post() ਵਿੱਚ request ਬਣਾ ਸਕਦੇ ਹੋ, ਤਾਂ integration ਤੁਹਾਡੇ ਕੰਟਰੋਲ ਵਿੱਚ ਹੈ ਅਤੇ ਤੁਸੀਂ ਇਸਨੂੰ ਆਸਾਨੀ ਨਾਲ debug ਕਰ ਸਕਦੇ ਹੋ।
ਤੁਹਾਡੇ Chatbot ਦਾ ਦਿਲ
ਆਪਣੇ ਮੂਲ ਵਿੱਚ, ਤੁਹਾਡਾ application ਇੱਕ function ਹੈ ਜੋ ਇੱਕ prompt ਭੇਜਦਾ ਹੈ ਅਤੇ ਜਵਾਬ ਦੀ ਉਡੀਕ ਕਰਦਾ ਹੈ। ਤੁਸੀਂ ਆਪਣੇ message ਨੂੰ ਕੰਟੇਨ ਕਰਨ ਵਾਲੀ ਇੱਕ dictionary ਬਣਾਉਂਦੇ ਹੋ, ਇਸਨੂੰ JSON ਵਿੱਚ ਲਪੇਟਦੇ ਹੋ, Authorization header ਵਿੱਚ ਆਪਣੀ API key ਲਗਾਉਂਦੇ ਹੋ, ਅਤੇ ਇਸਨੂੰ provider ਦੇ completions ਜਾਂ chat endpoint 'ਤੇ POST ਕਰਦੇ ਹੋ। ਰਿਮੋਟ ਸਰਵਰ text ਨੂੰ process ਕਰਦਾ ਹੈ ਅਤੇ ਇੱਕ response object ਵਾਪਸ ਭੇਜਦਾ ਹੈ। ਤੁਹਾਡੀ script ਉਸ JSON ਨੂੰ parse ਕਰਦੀ ਹੈ ਅਤੇ ਤਿਆਰ ਕੀਤੀ ਗਈ string ਨੂੰ ਕੱਢਦੀ ਹੈ।
ਇੱਕ ਵਿਹਾਰਕ ਪਹਿਲਾ version ਸੰਕਲਪਤ ਰੂਪ ਵਿੱਚ ਇਸ ਤਰ੍ਹਾਂ ਦਿਖਾਈ ਦਿੰਦਾ ਹੈ:
- ਕੀਬੋਰਡ ਤੋਂ ਯੂਜ਼ਰ ਇਨਪੁਟ ਕੈਪਚਰ ਕਰੋ।
- ਇਸਨੂੰ ਉਸ ਪੇਲੋਡ ਫਾਰਮੈਟ ਵਿੱਚ ਪੈਕੇਜ ਕਰੋ ਜਿਸਦੀ API ਉਮੀਦ ਕਰਦੀ ਹੈ।
- HTTP ਰਿਕਵੈਸਟ ਭੇਜੋ।
- ਨੈੱਟਵਰਕ ਜਾਂ ਅਥੈਂਟੀਕੇਸ਼ਨ ਗਲਤੀਆਂ ਦੀ ਜਾਂਚ ਕਰੋ।
- ਵਾਪਸ ਮਿਲੇ JSON ਵਿੱਚੋਂ ਜਵਾਬ ਦਾ ਟੈਕਸਟ ਕੱਢੋ।
- ਇਸਨੂੰ ਸਕ੍ਰੀਨ 'ਤੇ ਪ੍ਰਿੰਟ ਕਰੋ।
ਉਹ ਲੂਪ—ਇਨਪੁਟ, ਪੈਕੇਜ, ਭੇਜਣਾ, ਪ੍ਰਾਪਤ ਕਰਨਾ, ਦਿਖਾਉਣਾ—ਹੀ ਪੂਰਾ ਇੰਜਣ ਹੈ। ਬਾਕੀ ਸਭ ਕੁਝ ਸਿਰਫ਼ ਸੁਧਾਰ (polish) ਹੈ।
ਜਦੋਂ ਤੁਸੀਂ ਪ੍ਰੋਟੋਟਾਈਪ ਤੋਂ ਅੱਗੇ ਵਧਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਗੱਲਬਾਤ ਦਾ ਇਤਿਹਾਸ (conversation history) ਬਣਾਈ ਰੱਖਣਾ ਚਾਹੋਗੇ। ਲੈਂਗੂਏਜ ਮਾਡਲ ਸਟੇਟਲੈੱਸ (stateless) ਹੁੰਦੇ ਹਨ; ਉਹ ਇਹ ਯਾਦ ਨਹੀਂ ਰੱਖਦੇ ਕਿ ਤੁਸੀਂ ਤਿੰਨ ਵਾਰ ਪਹਿਲਾਂ ਕੀ ਕਿਹਾ ਸੀ, ਜਦੋਂ ਤੱਕ ਤੁਸੀਂ ਹਰ ਵਾਰ ਉਸ ਇਤਿਹਾਸ ਨੂੰ ਪ੍ਰੋਂਪਟ ਵਿੱਚ ਵਾਪਸ ਨਹੀਂ ਪਾਉਂਦੇ। ਤੁਸੀਂ ਇਸਨੂੰ ਮੈਸੇਜ ਡਿਕਸ਼ਨਰੀਆਂ ਦੀ ਇੱਕ Python ਲਿਸਟ ਰੱਖ ਕੇ ਅਤੇ ਹਰ ਨਵੀਂ ਰਿਕਵੈਸਟ ਤੋਂ ਪਹਿਲਾਂ ਯੂਜ਼ਰ ਪ੍ਰੋਂਪਟ ਅਤੇ ਅਸਿਸਟੈਂਟ ਦੇ ਜਵਾਬਾਂ ਨੂੰ ਇਸ ਵਿੱਚ ਜੋੜ ਕੇ ਹੱਲ ਕਰਦੇ ਹੋ। ਲਿਸਟ ਵਧਦੀ ਜਾਂਦੀ ਹੈ, ਇਸ ਲਈ ਜਦੋਂ ਤੁਸੀਂ ਮਾਡਲ ਦੀ ਕੰਟੈਕਸਟ ਲਿਮਿਟ (context limit) ਦੇ ਨੇੜੇ ਹੁੰਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਪੁਰਾਣੇ ਟਰਨਾਂ ਨੂੰ ਛੋਟਾ (truncate) ਕਰ ਦਿੰਦੇ ਹੋ।
ਮਹੱਤਵਪੂਰਨ ਫੀਚਰਸ ਜੋੜਨਾ
ਇੱਕ ਵਾਰ ਜਦੋਂ ਬੇਸਿਕ ਕਾਲ ਭਰੋਸੇਯੋਗ ਤਰੀਕੇ ਨਾਲ ਕੰਮ ਕਰਨ ਲੱਗ ਜਾਂਦੀ ਹੈ, ਤਾਂ ਤੁਸੀਂ ਪ੍ਰੋਜੈਕਟ ਨੂੰ ਕੁਝ ਅਜਿਹਾ ਰੂਪ ਦੇ ਸਕਦੇ ਹੋ ਜਿਸਦੀ ਲੋਕ ਅਸਲ ਵਿੱਚ ਵਰਤੋਂ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹਨ।
tkinter ਨਾਲ ਇੱਕ ਸਧਾਰਨ ਯੂਜ਼ਰ ਇੰਟਰਫੇਸ ਬਣਾਓ। ਸਟੈਂਡਰਡ ਲਾਇਬ੍ਰੇਰੀ ਦਾ tkinter ਮੋਡਿਊਲ ਅਕਸਰ ਪੁਰਾਣਾ ਦਿਖਣ ਕਾਰਨ ਮਜ਼ਾਕ ਦਾ ਪਾਤਰ ਬਣਦਾ ਹੈ, ਪਰ ਇਹ ਹਰ Python ਇੰਸਟਾਲੇਸ਼ਨ ਦੇ ਨਾਲ ਆਉਂਦਾ ਹੈ ਅਤੇ ਇਸ ਲਈ ਕਿਸੇ ਬਾਹਰੀ ਡਿਪੈਂਡੈਂਸੀ ਦੀ ਲੋੜ ਨਹੀਂ ਹੁੰਦੀ। ਤੁਸੀਂ ਸੌ ਲਾਈਨਾਂ ਤੋਂ ਵੀ ਘੱਟ ਵਿੱਚ ਇੱਕ ਵਰਤੋਂਯੋਗ ਚੈਟ ਵਿੰਡੋ ਬਣਾ ਸਕਦੇ ਹੋ: ਗੱਲਬਾਤ ਦੇ ਲੌਗ ਲਈ ਇੱਕ Text ਵਿਜੇਟ, ਟਾਈਪ ਕਰਨ ਲਈ ਇੱਕ Entry ਵਿਜੇਟ, ਅਤੇ ਇੱਕ Button ਜੋ ਤੁਹਾਡੇ API ਫੰਕਸ਼ਨ ਨੂੰ ਚਲਾਉਂਦਾ ਹੈ। ਇਹ ਡਿਜ਼ਾਈਨ ਅਵਾਰਡ ਤਾਂ ਨਹੀਂ ਜਿੱਤੇਗਾ, ਪਰ ਇਹ ਤੁਹਾਡੇ ਸਕ੍ਰਿਪਟ ਨੂੰ ਇੱਕ ਟਰਮੀਨਲ ਦੀ ਚੀਜ਼ ਤੋਂ ਇੱਕ ਡੈਸਕਟੌਪ ਐਪਲੀਕੇਸ਼ਨ ਵਿੱਚ ਬਦਲ ਦਿੰਦਾ ਹੈ ਜਿਸ ਨੂੰ ਗੈਰ-ਤਕਨੀਕੀ ਦੋਸਤ ਵੀ ਵਰਤ ਸਕਦੇ ਹਨ।
ਵਿਸ਼ੇਸ਼ APIs ਦੀ ਵਰਤੋਂ ਕਰੋ। ਇੱਕ ਆਮ ਲੈਂਗੂਏਜ ਮਾਡਲ ਗੱਲਬਾਤ ਨੂੰ ਚੰਗੀ ਤਰ੍ਹਾਂ ਸੰਭਾਲਦਾ ਹੈ, ਪਰ ਇਹ ਹਰ ਕੰਮ ਲਈ ਅਪਟੀਮਾਈਜ਼ਡ ਨਹੀਂ ਹੁੰਦਾ। ਤੁਸੀਂ ਮੁੱਖ LLM ਕਾਲ ਤੋਂ ਪਹਿਲਾਂ ਜਾਂ ਬਾਅਦ ਵਿੱਚ ਵੱਖ-ਵੱਖ ਮੁਫ਼ਤ APIs ਰਾਹੀਂ ਯੂਜ਼ਰ ਦੇ ਇਨਪੁਟ ਨੂੰ ਭੇਜ ਸਕਦੇ ਹੋ। ਸੈਂਟੀਮੈਂਟ ਐਨਾਲਿਸਿਸ (Sentiment analysis) ਸੇਵਾਵਾਂ ਇਹ ਟੈਗ ਕਰ ਸਕਦੀਆਂ ਹਨ ਕਿ ਕੋਈ ਮੈਸੇਜ ਗੁੱਸੇ ਵਾਲਾ ਹੈ, ਖੁਸ਼ ਹੈ, ਜਾਂ ਨਿਰਪੱਖ ਹੈ। ਟ੍ਰਾਂਸਲੇਸ਼ਨ APIs ਜਵਾਬ ਨੂੰ ਦੂਜੀ ਭਾਸ਼ਾ ਵਿੱਚ ਬਦਲ ਸਕਦੀਆਂ ਹਨ। ਇਸ ਤਰ੍ਹਾਂ ਦੀ ਪਾਈਪਲਾਈਨ ਬਣਾਉਣਾ ਤੁਹਾਨੂੰ ਸਿਖਾਉਂਦਾ ਹੈ ਕਿ ਅਸਲ AI ਉਤਪਾਦ ਕਿਵੇਂ ਤਿਆਰ ਕੀਤੇ ਜਾਂਦੇ ਹਨ: ਇੰਟੈਂਟ ਡਿਟੈਕਸ਼ਨ (intent detection) ਲਈ ਇੱਕ ਮਾਡਲ, ਜਨਰੇਸ਼ਨ ਲਈ ਦੂਜਾ, ਅਤੇ ਪੋਸਟ-ਪ੍ਰੋਸੈਸਿੰਗ ਲਈ ਤੀਜਾ।
ਪ੍ਰੋਂਪਟ ਇੰਜੀਨੀਅਰਿੰਗ (prompt engineering) ਨਾਲ ਪ੍ਰਯੋਗ ਕਰੋ। ਇੱਥੇ ਉੱਨਤ NLP ਤਕਨੀਕਾਂ ਦਾ ਮਤਲਬ ਟ੍ਰਾਂਸਫਾਰਮਰ ਆਰਕੀਟੈਕਚਰ ਨੂੰ ਦੁਬਾਰਾ ਲਿਖਣਾ ਨਹੀਂ ਹੈ। ਇਸਦਾ ਮਤਲਬ ਆਪਣੇ ਪ੍ਰੋਂਪਟਾਂ ਨੂੰ ਵਧੇਰੇ ਧਿਆਨ ਨਾਲ ਸਟ੍ਰਕਚਰ ਕਰਨਾ ਹੈ। ਸਿਸਟਮ ਮੈਸੇਜ ਵਿੱਚ ਮਾਡਲ ਨੂੰ ਇੱਕ ਪਛਾਣ (persona) ਦਿਓ। ਅਸਲ ਯੂਜ਼ਰ ਦੇ ਸਵਾਲ ਤੋਂ ਪਹਿਲਾਂ ਪ੍ਰੋਂਪਟ ਵਿੱਚ ਦੋ ਜਾਂ ਤਿੰਨ ਨਮੂਨਾ ਪ੍ਰਸ਼ਨ-ਅਤੇ-ਉੱਤਰ ਜੋੜ ਕੇ few-shot ਉਦਾਹਰਣਾਂ ਦੀ ਵਰਤੋਂ ਕਰੋ। ਜੇਕਰ API temperature ਵਰਗੇ ਪੈਰਾਮੀਟਰਾਂ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦੀ ਹੈ, ਤਾਂ ਉਹਨਾਂ ਨੂੰ ਐਡਜਸਟ ਕਰੋ; ਘੱਟ ਮੁੱਲ ਆਉਟਪੁੱਟ ਨੂੰ ਵਧੇਰੇ ਕੇਂਦਰਿਤ ਅਤੇ ਨਿਰਧਾਰਤ (deterministic) ਬਣਾਉਂਦੇ ਹਨ, ਜਦੋਂ ਕਿ ਉੱਚ ਮੁੱਲ ਰਚਨਾਤਮਕਤਾ ਨੂੰ ਉਤਸ਼ਾਹਿਤ ਕਰਦੇ ਹਨ। ਇਹਨਾਂ ਨੂੰ ਅਜ਼ਮਾਉਣ ਵਿੱਚ ਕੁਝ ਵੀ ਖਰਚ ਨਹੀਂ ਹੁੰਦਾ ਪਰ ਇਹ ਜਵ