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

Model Context Protocol, ਜਾਂ MCP, ਉਸ ਕੰਧ ਨੂੰ ਤੋੜਨ ਲਈ ਬਣਾਇਆ ਗਿਆ ਸੀ। ਹਰੇਕ ਇੰਟੀਗ੍ਰੇਸ਼ਨ ਨੂੰ ਇੱਕ ਕਸਟਮ ਆਰਟ ਪ੍ਰੋਜੈਕਟ ਵਜੋਂ ਦੇਖਣ ਦੀ ਬਜਾਏ, MCP AI ਮਾਡਲਾਂ ਅਤੇ ਬਾਹਰੀ ਟੂਲਜ਼ ਵਿਚਕਾਰ ਇੱਕ ਸਿੰਗਲ, ਸਾਂਝਾ ਇੰਟਰਫੇਸ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ। ਇਸਨੂੰ ਆਰਟੀਫੀਸ਼ੀਅਲ ਇੰਟੈਲੀਜੈਂਸ ਲਈ ਇੱਕ USB-C ਪੋਰਟ ਵਜੋਂ ਸਮਝੋ: ਇੱਕ ਅਜਿਹਾ ਆਕਾਰ ਜੋ ਕਈ ਤਰ੍ਹਾਂ ਦੇ ਕਨੈਕਸ਼ਨਾਂ ਨੂੰ ਸਵੀਕਾਰ ਕਰਦਾ ਹੈ। ਤੁਸੀਂ ਐਡਾਪਟਰ ਨੂੰ ਇੱਕ ਵਾਰ ਬਣਾਉਂਦੇ ਹੋ, ਅਤੇ ਕੋਈ ਵੀ ਅਨੁਕੂਲ (compatible) ਸਹਾਇਕ ਇਸਦੀ ਵਰਤੋਂ ਤੁਹਾਡੇ ਸਿਸਟਮਾਂ ਨਾਲ ਗੱਲ ਕਰਨ ਲਈ ਕਰ ਸਕਦਾ ਹੈ।

ਪੁਰਾਣਾ ਉਲਝਣ ਭਰਿਆ ਤਰੀਕਾ

ਇਸ ਤਰ੍ਹਾਂ ਦੇ ਮਿਆਰੀਕਰਨ (standardization) ਦੇ ਹੋਣ ਤੋਂ ਪਹਿਲਾਂ, ਇੱਕ AI ਨੂੰ ਤੁਹਾਡੇ ਟੂਲਜ਼ ਨਾਲ ਜੋੜਨ ਦਾ ਮਤਲਬ ਸੀ ਮਾਡਲ ਅਤੇ ਸਰਵਿਸ ਦੇ ਹਰ ਸੁਮੇਲ ਲਈ ਵੱਖਰੇ ਪੁਲ ਬਣਾਉਣਾ। ਜੇਕਰ ਤੁਹਾਡੀ ਇੰਜੀਨੀਅਰਿੰਗ ਟੀਮ ਚਾਹੁੰਦੀ ਸੀ ਕਿ ਇੱਕ AI assistant GitHub ਤੱਕ ਪਹੁੰਚ ਕਰੇ, ਤਾਂ ਤੁਹਾਨੂੰ ChatGPT ਲਈ ਇੱਕ ਸਮਰਪਿਤ GitHub ਇੰਟੀਗ੍ਰੇਸ਼ਨ ਦੀ ਲੋੜ ਸੀ। ਫਿਰ Claude ਲਈ ਇੱਕ ਹੋਰ। ਫਿਰ Gemini ਲਈ ਇੱਕ ਹੋਰ। ਇਹੀ ਕਹਾਣੀ Slack, Google Drive, ਅੰਦਰੂਨੀ ਡਾਟਾਬੇਸ ਅਤੇ ਫਾਈਲ ਸਿਸਟਮਾਂ ਲਈ ਦੁਹਰਾਈ ਗਈ।

ਇਹ ਪਹੁੰਚ ਡਿਵੈਲਪਰਾਂ ਦਾ ਸਮਾਂ ਬਰਬਾਦ ਕਰਦੀ ਹੈ। ਟੀਮਾਂ ਅੰਤ ਵਿੱਚ ਅਜਿਹੇ ਸਮਾਨ ਕੋਡਬੇਸ (codebases) ਨੂੰ ਬਣਾਈ ਰੱਖਦੀਆਂ ਹਨ ਜੋ ਲਗਭਗ ਇੱਕੋ ਜਿਹਾ ਕੰਮ ਕਰਦੇ ਹਨ: ਇੱਕ API ਤੋਂ ਡਾਟਾ ਪ੍ਰਾਪਤ ਕਰਨਾ, ਇਸਨੂੰ ਫਾਰਮੈਟ ਕਰਨਾ, ਅਤੇ ਇੱਕ ਭਾਸ਼ਾ ਮਾਡਲ ਨੂੰ ਦੇਣਾ। ਸੁਰੱਖਿਆ ਵੀ ਇੱਕ ਡਰਾਉਣਾ ਸੁਪਨਾ ਬਣ ਜਾਂਦੀ ਹੈ। ਹਰ ਵਿਸ਼ੇਸ਼ ਕਨੈਕਟਰ ਆਪਣਾ ਖੁਦ ਦਾ ਪ੍ਰਮਾਣਿਕਤਾ (authentication) ਲੌਜਿਕ, ਟੋਕਨ ਸਟੋਰੇਜ, ਅਤੇ ਅਪਡੇਟ ਚੱਕਰ ਲਿਆਉਂਦਾ ਹੈ। ਜਦੋਂ ਕੋਈ ਮਾਡਲ ਆਪਣੀ API ਬਦਲਦਾ ਹੈ ਜਾਂ ਕੋਈ Third-party ਸਰਵਿਸ ਆਪਣੀਆਂ ਇਜਾਜ਼ਤਾਂ (permissions) ਨੂੰ ਅਪਡੇਟ ਕਰਦੀ ਹੈ, ਤਾਂ ਹਰੇਕ ਕਸਟਮ ਇੰਟੀਗ੍ਰੇਸ਼ਨ ਨੂੰ ਵਿਅਕਤੀਗਤ ਧਿਆਨ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। ਇਹ ਬੋਝ ਤੇਜ਼ੀ ਨਾਲ ਵਧਦਾ ਹੈ, ਜਿਸ ਕਾਰਨ ਇੰਨੇ ਸਾਰੇ ਉਮੀਦਵਾਰ AI ਡੈਮੋ ਕਦੇ ਵੀ ਰੋਜ਼ਾਨਾ ਵਰਤੋਂ ਦੇ ਕੰਮਾਂ (workflows) ਵਿੱਚ ਸ਼ਾਮਲ ਨਹੀਂ ਹੋ ਪਾਉਂਦੇ।

ਇੱਕ ਕਨੈਕਸ਼ਨ, ਕੋਈ ਵੀ ਸਹਾਇਕ

MCP ਢਾਂਚੇ ਨੂੰ ਪੂਰੀ ਤਰ੍ਹਾਂ ਬਦਲ ਦਿੰਦਾ ਹੈ। ਹਰੇਕ AI ਵੈਂਡਰ ਨੂੰ ਹਰ ਟੂਲ ਦਾ ਸਮਰਥਨ ਕਰਨ ਲਈ ਕਹਿਣ ਦੀ ਬਜਾਏ, ਇਹ ਪ੍ਰੋਟੋਕੋਲ ਇੱਕ ਸਾਂਝੀ ਭਾਸ਼ਾ ਬਣਾਉਂਦਾ ਹੈ ਜੋ ਮਾਡਲਾਂ ਅਤੇ ਸਰਵਿਸਾਂ ਦੋਵੇਂ ਬੋਲ ਸਕਦੇ ਹਨ। ਤੁਸੀਂ ਇੱਕ MCP ਕਨੈਕਸ਼ਨ ਬਣਾਉਂਦੇ ਹੋ। ਉਹ ਸਿੰਗਲ ਕਨੈਕਸ਼ਨ ਸਾਰੇ AI assistants 'ਤੇ ਕੰਮ ਕਰਦਾ ਹੈ। ਮਾਡਲ ਉਸੇ ਮਿਆਰੀ ਮਾਰਗ ਰਾਹੀਂ ਤੁਹਾਡੇ GitHub issues, Slack channels, ਡਾਟਾਬੇਸ, ਜਾਂ ਲੋਕਲ ਫਾਈਲਾਂ ਤੱਕ ਪਹੁੰਚਦਾ ਹੈ।

ਅੰਤਰ ਆਰਕੀਟੈਕਚਰਲ (architectural) ਹੈ। ਅਤੀਤ ਵਿੱਚ, ਇੰਟੀਗ੍ਰੇਸ਼ਨ ਮਾਡਲ-ਕੇਂਦ੍ਰਿਤ (model-centric) ਸਨ: ਸਹਾਇਕ ਵੈਂਡਰ ਇਹ ਨਿਰਧਾਰਤ ਕਰਦਾ ਸੀ ਕਿ ਤੁਸੀਂ ਕਿਹੜੇ ਟੂਲ ਵਰਤ ਸਕਦੇ ਹੋ। MCP ਈਕੋਸਿਸਟਮ ਨੂੰ ਟੂਲ-ਕੇਂਦ੍ਰਿਤ (tool-centric) ਬਣਾਉਂਦਾ ਹੈ। ਜੋ ਟੀਮ ਡਾਟਾਬੇਸ ਜਾਂ ਕੋਡਬੇਸ ਦੀ ਮਾਲਕ ਹੈ, ਉਹ ਇੱਕ MCP ਐਡਾਪਟਰ ਪ੍ਰਕਾਸ਼ਿਤ ਕਰਦੀ ਹੈ। ਕੋਈ ਵੀ ਮਾਡਲ ਜੋ ਇਸ ਪ੍ਰੋਟੋਕੋਲ ਨੂੰ ਸਮਝਦਾ ਹੈ, ਉਹ ਕਨੈਕਟ ਹੋ ਸਕਦਾ ਹੈ। ਜੇਕਰ ਤੁਹਾਡੀ ਕੰਪਨੀ ਸਹਾਇਕ (assistants) ਬਦਲਦੀ ਹੈ ਜਾਂ ਇੱਕੋ ਸਮੇਂ ਕਈ ਮਾਡਲਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੀ ਹੈ, ਤਾਂ ਤੁਹਾਡੀਆਂ ਇੰਟੀਗ੍ਰੇਸ਼ਨਾਂ ਟੁੱਟਦੀਆਂ ਨਹੀਂ ਹਨ ਜਾਂ ਉਹਨਾਂ ਨੂੰ ਸ਼ੁਰੂ ਤੋਂ ਮੁੜ ਬਣਾਉਣ ਦੀ ਲੋੜ ਨਹੀਂ ਪੈਂਦੀ।

ਅਭਿਆਸ ਵਿੱਚ ਇਹ ਕਿਹੋ ਜਿਹਾ ਦਿਖਾਈ ਦਿੰਦਾ ਹੈ

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

GitHub. MCP ਰਾਹੀਂ ਜੁੜਿਆ ਇੱਕ AI ਰਿਪੋਜ਼ਟਰੀਆਂ ਦੀ ਸੂਚੀ ਪ੍ਰਾਪਤ ਕਰਨ ਤੋਂ ਵੱਧ ਕੁਝ ਕਰ ਸਕਦਾ ਹੈ। ਇਹ ਹਾਲ ਹੀ ਦੇ pull requests ਦੀ ਸਮੀਖਿਆ ਕਰ ਸਕਦਾ ਹੈ, branches ਦੀ ਤੁਲਨਾ ਕਰ ਸਕਦਾ ਹੈ, ਸੰਭਾਵੀ regressions ਦੀ ਪਛਾਣ ਕਰ ਸਕਦਾ ਹੈ, ਅਤੇ ਆਪਣੇ ਆਪ ਵਿਸਤ੍ਰਿਤ issues ਬਣਾ ਸਕਦਾ ਹੈ। ਤੁਸੀਂ ਇਸਨੂੰ ਪਿਛਲੇ ਚੌਵੀ ਘੰਟਿਆਂ ਦੇ ਹਰ commit ਦੀ ਗਲਤੀਆਂ (error handling) ਦੀ ਜਾਂਚ ਕਰਨ ਲਈ ਕਹਿ ਸਕਦੇ ਹੋ, ਅਤੇ ਇਹ ਤੁਹਾਡੇ ਦੁਆਰਾ ਕੋਡ ਦਾ ਇੱਕ ਵੀ ਬਲਾਕ ਕਾਪੀ ਕੀਤੇ ਬਿਨਾਂ ਲਾਈਨ ਰੈਫਰੈਂਸਾਂ ਦੇ ਨਾਲ ਟਿਕਟਾਂ ਖੋਲ੍ਹ ਦੇਵੇਗਾ।

Google Drive. ਦਸਤਾਵੇਜ਼ਾਂ ਨੂੰ ਚੈਟ ਇੰਟਰਫੇਸ ਵਿੱਚ ਅਪਲੋਡ ਕਰਨ ਦੀ ਬਜਾਏ, AI ਫਾਈਲਾਂ ਨੂੰ ਉੱਥੇ ਹੀ ਪੜ੍ਹਦਾ ਅਤੇ ਸੰਖੇਪ (summarize) ਕਰਦਾ ਹੈ ਜਿੱਥੇ ਉਹ ਪਹਿਲਾਂ ਹੀ ਮੌਜੂਦ ਹਨ। ਪਿਛਲੀ ਤਿਮਾਹੀ ਦੇ ਰੋਡਮੈਪ ਅਤੇ ਮੌਜੂਦਾ ਡਰਾਫਟ ਬਜਟ ਵਿਚਕਾਰ ਤੁਲਨਾ ਕਰਨ ਲਈ ਕਹੋ, ਅਤੇ ਸਹਾਇਕ ਸਿੱਧੇ ਦੋਵੇਂ ਸਪ੍ਰੈਡਸ਼ੀਟਾਂ ਪ੍ਰਾਪਤ ਕਰ ਲਵੇਗਾ, ਪਿਛਲੇ ਹਫ਼ਤੇ ਤੁਹਾਡੇ ਦੁਆਰਾ ਪੇਸਟ ਕੀਤੇ ਗਏ ਸਟੈਟਿਕ ਸਨੈਪਸ਼ੌਟ ਦੀ ਬਜਾਏ ਤਾਜ਼ਾ ਡਾਟਾ ਨਾਲ ਕੰਮ ਕਰੇਗਾ।

Slack. ਸੰਚਾਰ ਦੋਵੇਂ ਤਰਫੋਂ ਹੁੰਦਾ ਹੈ। AI ਇੱਕ ਪ੍ਰੋਜੈਕਟ ਚੈਨਲ 'ਤੇ ਰੋਜ਼ਾਨਾ ਸਾਰ (summaries) ਪੋਸਟ ਕਰ ਸਕਦਾ ਹੈ, ਜਦੋਂ ਕੋਈ ਮਹੱਤਵਪੂਰਨ ਡਾਟਾਬੇਸ ਸੀਮਾ (threshold) ਪੂਰੀ ਹੁੰਦੀ ਹੈ ਤਾਂ ਟੀਮ ਨੂੰ ਸੁਚੇਤ ਕਰ ਸਕਦਾ ਹੈ, ਜਾਂ ਜਵਾਬ ਦੇਣ ਦਾ ਸੁਝਾਅ ਦੇਣ ਤੋਂ ਪਹਿਲਾਂ ਸਪੋਰਟ ਥ

ਡਿਵੈਲਪਰ ਟੂਲਜ਼ (Developer Tools). ਇਹ ਉਹ ਜਗ੍ਹਾ ਹੈ ਜਿੱਥੇ ਸਮੇਂ ਦੀ ਬਚਤ ਸਪੱਸ਼ਟ ਹੋ ਜਾਂਦੀ ਹੈ। MCP ਰਾਹੀਂ ਚੱਲਣ ਵਾਲਾ ਇੱਕ AI ਟੈਸਟ ਸੂਟਾਂ (test suites) ਨੂੰ ਚਲਾ ਸਕਦਾ ਹੈ, ਬਿਲਡ ਸਕ੍ਰਿਪਟਾਂ (build scripts) ਨੂੰ ਰਨ ਕਰ ਸਕਦਾ ਹੈ, ਲਿੰਟਿੰਗ ਗਲਤੀਆਂ (linting errors) ਦੀ ਜਾਂਚ ਕਰ ਸਕਦਾ ਹੈ, ਜਾਂ ਡਿਪਲਾਈਮੈਂਟ ਕਾਰਜਾਂ ਨੂੰ ਆਟੋਮੇਟ ਕਰ ਸਕਦਾ ਹੈ। ਤੁਸੀਂ ਇੱਕ ਕਮਾਂਡ ਲਿਖਦੇ ਹੋ, ਅਤੇ ਸਹਾਇਕ ਤੁਹਾਡੇ ਵਾਤਾਵਰਣ ਵਿੱਚ ਅਸਲ ਟੂਲਿੰਗ ਨੂੰ ਚਾਲੂ ਕਰ ਦਿੰਦਾ ਹੈ, ਜਿਸ ਨਾਲ ਸੁਝਾਅ ਅਤੇ ਅਮਲੀਕਰਨ (execution) ਵਿਚਕਾਰਲੇ ਪਾੜੇ ਨੂੰ ਖਤਮ ਕਰ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ।

ਇਹ ਬਿਲਡਰਾਂ ਲਈ ਕਿਉਂ ਮਹੱਤਵਪੂਰਨ ਹੈ

ਰਫ਼ਤਾਰ ਸਿਰਫ਼ ਇੱਕ ਫਾਇਦਾ ਹੈ। MCP ਕਸਟਮ ਸਕ੍ਰਿਪਟਾਂ ਦੇ ਗੁੰਝਲਦਾਰ ਜਾਲ ਨੂੰ ਇੱਕ ਸਮਾਨ ਐਕਸੈਸ ਲੇਅਰ (access layer) ਨਾਲ ਬਦਲ ਕੇ ਸੁਰੱਖਿਆ ਨੂੰ ਵੀ ਮਜ਼ਬੂਤ ਕਰਦਾ ਹੈ। ਜਦੋਂ ਹਰ ਟੂਲ ਇੱਕੋ ਪ੍ਰੋਟੋਕੋਲ ਰਾਹੀਂ ਜੁੜਦਾ ਹੈ, ਤਾਂ ਤੁਸੀਂ ਦਰਜਨਾਂ ਦੀ ਬਜਾਏ ਸਿਰਫ਼ ਇੱਕ ਪ੍ਰਮਾਣਿਕਤਾ ਪੈਟਰਨ (authentication pattern) ਦਾ ਪ੍ਰਬੰਧ ਕਰਦੇ ਹੋ। ਇਜਾਜ਼ਤਾਂ (Permissions) ਐਡਾਪਟਰ ਪੱਧਰ 'ਤੇ ਨਿਰਧਾਰਤ ਕੀਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ, ਇਸ ਲਈ ਤੁਸੀਂ ਨਿਯੰਤਰਣ ਕਰਦੇ ਹੋ ਕਿ AI ਕੀ ਦੇਖ ਸਕਦਾ ਹੈ ਜਾਂ ਕੀ ਬਦਲ ਸਕਦਾ ਹੈ। ਪਾਈਪਲਾਈਨ ਵਿੱਚ ਘੱਟ ਕਸਟਮ ਕੋਡ ਹੁੰਦਾ ਹੈ, ਜਿਸਦਾ ਮਤਲਬ ਹੈ ਘੱਟ ਲੁਕੀਆਂ ਹੋਈਆਂ ਕਮਜ਼ੋਰੀਆਂ (vulnerabilities) ਅਤੇ ਆਸਾਨ ਆਡਿਟਿੰਗ।

ਡਿਵੈਲਪਰਾਂ ਲਈ, ਉਤਪਾਦਕਤਾ ਵਿੱਚ ਵਾਧਾ ਸਪੱਸ਼ਟ ਹੈ। ਕਈ AI ਪਲੇਟਫਾਰਮਾਂ ਲਈ ਵੱਖਰੇ ਇੰਟੀਗ੍ਰੇਸ਼ਨ ਲਿਖਣਾ ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਬਣਾਈ ਰੱਖਣਾ ਇੱਕ ਉਬਾਊ ਇਨਫਰਾਸਟ੍ਰਕਚਰ ਕੰਮ ਹੈ ਜੋ ਤੁਹਾਡੇ ਉਤਪਾਦ ਵਿੱਚ ਕੁਝ ਵੀ ਵਿਲੱਖਣ ਨਹੀਂ ਜੋੜਦਾ। MCP ਤੁਹਾਨੂੰ ਉਹ ਪਲੰਬਿੰਗ (plumbing) ਇੱਕ ਵਾਰ ਲਿਖਣ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ ਅਤੇ ਫਿਰ ਅਸਲ ਵਪਾਰਕ ਸਮੱਸਿਆਵਾਂ ਨੂੰ ਹੱਲ ਕਰਨ ਵੱਲ ਵਧਣ ਦੀ ਸਹੂਲਤ ਦਿੰਦਾ ਹੈ। ਇਹ ਪ੍ਰੋਟੋਕੋਲ AI ਨੂੰ ਇੱਕ ਅਲੱਗ-ਥਲੱਗ ਨਵੀਨਤਾ ਤੋਂ ਬਦਲ ਕੇ ਤੁਹਾਡੇ ਓਪਰੇਸ਼ਨਲ ਸਟੈਕ (operational stack) ਦੀ ਇੱਕ ਅਸਲ ਲੇਅਰ ਬਣਾ ਦਿੰਦਾ ਹੈ।

ਨਿਚੋੜ (The Bottom Line)

MCP ਕਿਸੇ ਮਾਡਲ ਨੂੰ ਸਮਾਰਟ ਨਹੀਂ ਬਣਾਉਂਦਾ। ਇਹ ਇਸਨੂੰ ਉਪਯੋਗੀ ਬਣਾਉਂਦਾ ਹੈ। ਲਾਈਵ ਡੇਟਾ ਤੱਕ ਪਹੁੰਚ ਤੋਂ ਬਿਨਾਂ ਇੱਕ ਸ਼ਕਤੀਸ਼ਾਲੀ ਭਾਸ਼ਾ ਮਾਡਲ ਇੱਕ ਕੁਸ਼ਲ ਇੰਜੀਨੀਅਰ ਵਾਂਗ ਹੈ ਜਿਸ ਨੂੰ ਕੰਪਨੀ ਦੇ wiki ਨੂੰ ਖੋਲ੍ਹਣ ਜਾਂ terminal ਨੂੰ ਛੂਹਣ ਦੀ ਮਨਾਹੀ ਹੈ। ਸੰਦਰਭ (context) ਤੋਂ ਬਿਨਾਂ ਬੁੱਧੀ ਅਧੂਰੀ ਹੈ।

ਇੱਥੇ ਬਦਲਾਅ ਸਰਲ ਪਰ ਡੂੰਘਾ ਹੈ। ਮਾਡਲ ਨੂੰ ਉਹਨਾਂ ਟੂਲਜ਼ ਤੋਂ ਵੱਖ ਕਰਕੇ ਜੋ ਉਹ ਵਰਤਦਾ ਹੈ, MCP ਉਹ ਚੱਕਰ ਰੋਕਦਾ ਹੈ ਜਿਸ ਵਿੱਚ ਤੁਹਾਨੂੰ ਲੋੜੀਂਦੇ ਕਨੈਕਟਰ ਬਣਾਉਣ ਲਈ AI ਵੈਂਡਰਾਂ ਦੀ ਉਡੀਕ ਕਰਨੀ ਪੈਂਦੀ ਹੈ। ਤੁਸੀਂ ਇੱਕ ਵਾਰ ਖੁਦ ਪੁਲ ਬਣਾਉਂਦੇ ਹੋ, ਅਤੇ ਇਹ ਤੁਹਾਡੇ ਦੁਆਰਾ ਅਪਣਾਏ ਗਏ ਹਰ ਸਹਾਇਕ ਦੀ ਸੇਵਾ ਕਰਦਾ ਹੈ। ਇੱਕ ਵਰਕਫਲੋ (workflow) ਨਾਲ ਸ਼ੁਰੂ ਕਰੋ। ਇੱਕ ਸਿੰਗਲ ਪ੍ਰੋਟੋਕੋਲ ਕਨੈਕਸ਼ਨ ਰਾਹੀਂ AI ਨੂੰ ਆਪਣੀਆਂ ਪ੍ਰੋਜੈਕਟ ਫਾਈਲਾਂ ਪੜ੍ਹਨ, database ਨੂੰ query ਕਰਨ ਜਾਂ ਆਪਣੇ test suite ਨੂੰ ਚਲਾਉਣ ਦਿਓ। ਇੱਕ ਵਾਰ ਜਦੋਂ ਤੁਸੀਂ ਇੱਕ ਸਹਾਇਕ ਨੂੰ static memory window ਦੀ ਬਜਾਏ ਅਸਲ, ਲਾਈਵ ਸੰਦਰਭ ਨਾਲ ਕੰਮ ਕਰਦੇ ਹੋਏ ਦੇਖ ਲੈਂਦੇ ਹੋ, ਤਾਂ ਕਿਸੇ ਹੋਰ ਤਰੀਕੇ ਨਾਲ ਕੰਮ ਕਰਨਾ ਇੱਕ ਹੱਥ ਨਾਲ ਟਾਈਪ ਕਰਨ ਵਾਂਗ ਮਹਿਸੂਸ ਹੁੰਦਾ ਹੈ।