AI உதவியாளர்களால் சிந்திக்கவும், எழுதவும் மற்றும் குறியீடு (code) செய்யவும் முடியும். இருப்பினும், சமீப காலம் வரை, உண்மையான வேலைகள் நடக்கும் இடங்களிலிருந்து அவை விலக்கி வைக்கப்பட்டிருந்தன. ஒரு மனிதர் விவரங்களை நகலெடுத்து (copy) ஒரு சாட் விண்டோவில் ஒட்டாதவரை (paste), அவற்றால் உங்கள் திட்டக் கோப்புகளைத் திறக்கவோ, வாடிக்கையாளர் தரவுத்தளத்தைக் (database) query செய்யவோ, Slack திரெட்களைச் சரிபார்க்கவோ அல்லது GitHub களஞ்சியங்களுடன் (repositories) தொடர்பு கொள்ளவோ முடியாது. ஒவ்வொரு தொடர்பும் கைமுறையாகவும், துண்டு துண்டாகவும் மற்றும் தற்காலிகமாகவும் உள்ளது.
Model Context Protocol அல்லது MCP, அந்தத் தடையை உடைப்பதற்காக உருவாக்கப்பட்டது. ஒவ்வொரு ஒருங்கிணைப்பையும் (integration) ஒரு தனிப்பயனாக்கப்பட்ட கலைத் திட்டமாக கருதுவதற்குப் பதிலாக, MCP ஆனது AI மாடல்களுக்கும் வெளிப்புறக் கருவிகளுக்கும் இடையே ஒரு ஒற்றை, பொதுவான இடைமுகத்தை (interface) வழங்குகிறது. இதை செயற்கை நுண்ணறிவிற்கான ஒரு USB-C போர்ட் என்று நினைத்துக் கொள்ளுங்கள்: பல வகையான இணைப்புகளை ஏற்கும் ஒரே வடிவம். நீங்கள் ஒருமுறை அடாப்டரை (adapter) உருவாக்கிவிட்டால், எந்தவொரு இணக்கமான உதவியாளரும் உங்கள் அமைப்புகளுடன் பேசுவதற்கு அதைப் பயன்படுத்த முடியும்.
குழப்பமான பழைய முறை
இத்தகைய தரப்படுத்தல் (standardization) உருவாவதற்கு முன்பு, ஒரு AI-யை உங்கள் கருவிகளுடன் இணைப்பது என்பது மாடல் மற்றும் சேவை ஆகியவற்றின் ஒவ்வொரு சேர்க்கைக்கும் தனித்தனி பாலங்களைக் கட்டுவதைக் குறித்தது. உங்கள் பொறியியல் குழு ஒரு AI உதவியாளர் GitHub-ஐ அணுக விரும்பினால், ChatGPT-க்காக ஒரு பிரத்யேக GitHub ஒருங்கிணைப்பு தேவைப்பட்டது. பிறகு Claude-க்காக இன்னொன்று. பிறகு Gemini-க்காக இன்னொன்று. Slack, Google Drive, உள் தரவுத்தளங்கள் மற்றும் கோப்பு அமைப்புகளுக்கும் (file systems) இதே கதைதான் மீண்டும் மீண்டும் நடந்தது.
இந்த அணுகுமுறை டெவலப்பர்களின் நேரத்தை வீணடிக்கிறது. ஒரு API-லிருந்து தரவைப் பெறுதல், அதை வடிவமைத்தல் மற்றும் ஒரு மொழி மாடலுக்கு (language model) வழங்குதல் என ஏறக்குறைய ஒரே வேலையைச் செய்யும் இணையாக உள்ள குறியீட்டுத் தளங்களை (codebases) பராமரிக்க வேண்டிய கட்டாயத்திற்கு அணிகள் தள்ளப்படுகின்றன. பாதுகாப்பும் ஒரு பெரும் சவாலாக மாறுகிறது. ஒவ்வொரு தனிப்பயனாக்கப்பட்ட இணைப்பானும் (connector) அதன் சொந்த அங்கீகாரத் தர்க்கம் (authentication logic), டோக்கன் சேமிப்பு மற்றும் புதுப்பித்தல் சுழற்சியைக் கொண்டுள்ளது. ஒரு மாடல் அதன் API-யை மாற்றும்போதோ அல்லது ஒரு மூன்றாம் தரப்பு சேவை அதன் அனுமதிகளைப் புதுப்பிக்கும்போதோ, ஒவ்வொரு தனிப்பயனாக்கப்பட்ட ஒருங்கிணைப்பும் தனித்தனியாகக் கவனிக்கப்பட வேண்டும். இந்த கூடுதல் பணிச்சுமை (overhead) வேகமாகப் பெருகுகிறது, இதனால்தான் பல நம்பிக்கைக்குரிய AI டெமோக்கள் தினசரி பணிப்பாய்வுகளில் (workflows) இடம்பெறுவதில்லை.
ஒரு இணைப்பு, எந்த உதவியாளரும்
MCP கட்டமைப்பை முற்றிலும் மாற்றுகிறது. ஒவ்வொரு AI விற்பனையாளரும் ஒவ்வொரு கருவியையும் ஆதரிக்க வேண்டும் என்று கேட்பதற்குப் பதிலாக, இந்த நெறிமுறை (protocol) மாடல்களும் சேவைகளும் பேசக்கூடிய ஒரு பொதுவான மொழியை உருவாக்குகிறது. நீங்கள் ஒரு MCP இணைப்பை உருவாக்குகிறீர்கள். அந்த ஒற்றை இணைப்பு அனைத்து AI உதவியாளர்களுக்கும் பொருந்தும். மாடல் உங்கள் GitHub issues, Slack சேனல்கள், தரவுத்தளங்கள் அல்லது உள்ளூர் கோப்புகளை ஒரே தரப்படுத்தப்பட்ட பாதையின் மூலம் அணுக முடியும்.
இதன் வேறுபாடு கட்டமைப்பியல் சார்ந்தது (architectural). கடந்த காலத்தில், ஒருங்கிணைப்புகள் மாடல் மையமாக (model-centric) இருந்தன: எந்தக் கருவிகளை நீங்கள் பயன்படுத்தலாம் என்பதை உதவியாளர் விற்பனையாளர் கட்டுப்படுத்தினார். MCP சூழலை கருவி மையமாக (tool-centric) மாற்றுகிறது. தரவுத்தளம் அல்லது குறியீட்டுத் தளத்தை வைத்திருக்கும் குழு ஒரு MCP அடாப்டரை வெளியிடுகிறது. அந்த நெறிமுறையைப் புரிந்துகொள்ளும் எந்தவொரு மாடலும் இணைய முடியும். உங்கள் நிறுவனம் உதவியாளர்களை மாற்றினாலோ அல்லது பல மாடல்களை அருகருகே பயன்படுத்தினாலோ, உங்கள் ஒருங்கிணைப்புகள் உடைந்து போகாது அல்லது மீண்டும் ஆரம்பத்திலிருந்து உருவாக்க வேண்டிய அவசியமும் இல்லை.
நடைமுறையில் இது எப்படி இருக்கும்
AI-யை ஒரு சாட்போட் (chatbot) என்று கற்பனை செய்வதை நிறுத்திவிட்டு, அதை உங்கள் தற்போதைய அமைப்புகளில் ஒரு பங்கேற்பாளராகக் கருதத் தொடங்கும் போதுதான் MCP-யின் உண்மையான ஆற்றல் வெளிப்படுகிறது.
GitHub. MCP மூலம் இணைக்கப்பட்ட ஒரு AI, களஞ்சியங்களின் (repositories) பட்டியலைப் பெறுவதை விட மேலானவற்றைச் செய்ய முடியும். அது சமீபத்திய pull requests-களை ஆய்வு செய்யவும், கிளைகளை (branches) ஒப்பிடவும், சாத்தியமான பின்னடைவுகளைக் (regressions) கண்டறியவும் மற்றும் விரிவான சிக்கல்களை (issues) தானாகவே உருவாக்கவும் முடியும். கடந்த இருபத்தி நான்கு மணிநேரத்தின் ஒவ்வொரு commit-யிலும் பிழை கையாளுதல் (error handling) விடுபட்டுள்ளதா என்று சரிபார்க்க நீங்கள் அதனிடம் கேட்கலாம்; நீங்கள் ஒரு குறியீட்டுத் தொகுப்பைக் கூட நகலெடுக்கத் தேவையில்லை, அது வரிசை குறிப்புகளுடன் (line references) டிக்கெட்டுகளைத் திறக்கும்.
Google Drive. ஆவணங்களை ஒரு சாட் இடைமுகத்தில் பதிவேற்றுவதற்குப் பதிலாக, AI கோப்புகள் ஏற்கனவே இருக்கும் இடத்திலேயே அவற்றை வாசித்துச் சுருக்கமாக வழங்கும். கடந்த காலாண்டுத் திட்ட வரைவிற்கும் (roadmap) தற்போதைய வரைவு பட்ஜெட்டிற்கும் இடையிலான ஒப்பீட்டைப் கேட்கலாம்; உதவியாளர் இரண்டு ஸ்ப்ரெட்ஷீட்களையும் நேரடியாகப் பெற்று, நீங்கள் கடந்த வாரம் ஒட்டிய ஒரு நிலையான ஸ்னாப்ஷாட்டைப் பயன்படுத்துவதற்குப் பதிலாக, புதிய தரவுகளுடன் செயல்படும்.
Slack. தகவல் தொடர்பு இரு திசைகளிலும் நிகழும். AI ஒரு திட்ட சேனலில் (project channel) தினசரிச் சுருக்கங்களைப் பதிவிடலாம், ஒரு முக்கியமான தரவுத்தள வரம்பு (database threshold) எட்டப்படும்போது குழுவிற்கு எச்சரிக்கை செய்யலாம் அல்லது ஆதரவுத் திரெட்களை (support threads) வாசித்து, ஒரு பதிலை முன்மொழிவதற்கு முன் அவற்றை உள் ஆவணங்களுடன் ஒப்பிட்டுப் பார்க்கலாம்.
Databases. இயல்பான மொழி (Natural language) கேள்விகள் நேரடித் தரவுகளைச் சென்றடையும். கடந்த முப்பது நாட்களில் எத்தனை சோதனைப் பயனர்கள் (trial users) மாற்றமடைந்தனர் என்று நீங்கள் கேட்கலாம், உதவியாளர் உங்கள் தயாரிப்பு (production) அல்லது பகுப்பாய்வு (analytics) தரவுத்தளத்திலிருந்து நிகழ்நேரத்தில் (real time) பதிலைப் பெறும். இந்தத் தகவல் தற்போதையது, குறிப்பிட்டது மற்றும் ஒரு குறிப்பிட்ட தேதியில் முடிந்துவிடும் பயிற்சித் தரவுகளை விட உண்மைகளை அடிப்படையாகக் கொண்டது.
File Systems. உங்கள் கணினி அல்லது சேவையகங்களில் (servers) உள்ள திட்டக் கோப்புகளை அணுக AI-க்கு கட்டமைக்கப்பட்ட அணுகல் கிடைக்கிறது. நீங்கள் கோப்புத் தொகுப்புகளை (folder trees) கைமுறையாகப் பதிவேற்றத் தேவையில்லை; அது கோப்புப் பாதைகளை (directory layouts) ஸ்கேன் செய்யவும், உள்ளமைவு கோப்புகளை (configuration files) படிக்கவும் மற்றும் ஒரு குறியீட்டுத் தளத்தின் சூழலைப் புரிந்துகொள்ளவும் முடியும்.
மென்பொருள் மேம்பாட்டுக் கருவிகள் (Developer Tools). இங்குதான் நேர சேமிப்பு என்பது தெளிவாகத் தெரிகிறது. MCP மூலம் இயங்கும் ஒரு AI, சோதனைத் தொகுப்புகளை (test suites) இயக்கலாம், பில்ட் ஸ்கிரிப்ட்களை (build scripts) இயக்கலாம், லின்டிங் பிழைகளை (linting errors) சரிபார்க்கலாம் அல்லது வரிசைப்படுத்தல் பணிகளை (deployment tasks) தானியக்கமாக்கலாம். நீங்கள் ஒரு கட்டளையை (command) எழுதினால், அந்த உதவியாளர் உங்கள் சூழலில் உள்ள உண்மையான கருவிகளைத் தூண்டிவிடுகிறார், இதன் மூலம் பரிந்துரைக்கும் நிலைக்கும் செயல்படும் நிலைக்கும் இடையிலான இடைவெளியைக் குறைக்கிறார்.
உருவாக்குபவர்களுக்கு இது ஏன் முக்கியமானது
வேகம் என்பது ஒரு பலன் மட்டுமே. சிக்கலான தனிப்பயன் ஸ்கிரிப்ட்களுக்குப் பதிலாக ஒரு சீரான அணுகல் அடுக்கை (uniform access layer) உருவாக்குவதன் மூலம் MCP பாதுகாப்பையும் பலப்படுத்துகிறது. ஒவ்வொரு கருவியும் ஒரே நெறிமுறையின் (protocol) மூலம் இணையும்போது, நீங்கள் டஜன் கணக்கான முறைகளுக்குப் பதிலாக ஒரே ஒரு அங்கீகார முறையை (authentication pattern) நிர்வகிக்கலாம். அனுமதிகள் அடாப்டர் (adapter) மட்டத்தில் வரையறுக்கப்படுவதால், AI எதைப் பார்க்க முடியும் அல்லது எதை மாற்றியமைக்க முடியும் என்பதை நீங்கள் துல்லியமாகக் கட்டுப்படுத்தலாம். செயல்முறையில் (pipeline) குறைவான தனிப்பயன் குறியீடுகள் இருப்பதால், மறைமுகமான பாதிப்புகள் குறைகின்றன மற்றும் தணிக்கை (auditing) செய்வது எளிதாகிறது.
டெவலப்பர்களுக்கு, உற்பத்தித்திறன் அதிகரிப்பு என்பது உறுதியானது. பல AI தளங்களுக்காகத் தனித்தனி ஒருங்கிணைப்புகளை (integrations) எழுதுவதும் பராமரிப்பதும் சலிப்பூட்டும் உள்கட்டமைப்புப் பணியாகும், இது உங்கள் தயாரிப்பிற்குத் தனித்துவமான எதையும் சேர்க்காது. MCP அந்த அடிப்படைத் தேவைகளை (plumbing) ஒருமுறை எழுத அனுமதிப்பதன் மூலம், நீங்கள் உண்மையான வணிகப் பிரச்சனைகளைத் தீர்ப்பதில் கவனம் செலுத்த முடிகிறது. இந்த நெறிமுறை AI-யை ஒரு தனிமைப்படுத்தப்பட்ட புதுமையிலிருந்து உங்கள் செயல்பாட்டுத் தொகுப்பின் (operational stack) ஒரு உண்மையான அடுக்காக மாற்றுகிறது.
சுருக்கமாகச் சொன்னால்
MCP ஒரு மாதிரியை (model) புத்திசாலியாக மாற்றாது. அது அதை பயனுள்ளதாக மாற்றுகிறது. நேரடித் தரவை அணுக முடியாத ஒரு சக்திவாய்ந்த மொழி மாதிரி (language model), நிறுவனத்தின் விக்கி (wiki) பக்கங்களைத் திறக்கவோ அல்லது டெர்மினலை (terminal) தொடவோ தடைசெய்யப்பட்ட ஒரு திறமையான பொறியாளரைப் போன்றது. சூழல் இல்லாத அறிவு முழுமையற்றது.
இங்குள்ள மாற்றம் எளிமையானது ஆனால் ஆழமானது. மாதிரியை அது பயன்படுத்தும் கருவிகளிலிருந்து பிரிப்பதன் மூலம், உங்களுக்குத் தேவையான இணைப்பான்களை (connectors) உருவாக்க AI விற்பனையாளர்களுக்காகக் காத்திருக்கும் சுழற்சியை MCP நிறுத்துகிறது. நீங்கள் ஒருமுறை நீங்களே அந்தப் பாலத்தைக் கட்டினால், அது நீங்கள் பயன்படுத்தும் ஒவ்வொரு உதவியாளருக்கும் பயன்படும். ஒரு பணிப்பாய்வுடன் (workflow) தொடங்குங்கள். ஒரு ஒற்றை நெறிமுறை இணைப்பின் மூலம், உங்கள் திட்டக் கோப்புகளைப் படிக்கவும், தரவுத்தளத்தைக் (database) கண்டறியவும் அல்லது உங்கள் சோதனைத் தொகுப்பை இயக்கவும் AI-யை அனுமதிக்கவும். ஒரு நிலையான நினைவகக் ஜன்னலுக்குப் (static memory window) பதிலாக, உண்மையான நேரடிச் சூழலுடன் ஒரு உதவியாளர் செயல்படுவதைக் காணும்போது, வேறு எந்த முறையிலும் வேலை செய்வது ஒரு கையால் தட்டச்சு செய்வது போலத் தோன்றும்.