எனது கோடிங் ஏஜெண்டுகளுக்காக ஒரு லோக்கல் கண்ட்ரோல் பிளேன் (Local Control Plane) உருவாக்கினேன்
வெவ்வேறு AI ஏஜெண்டுகளைப் பயன்படுத்துவது ஒரு குழப்பமாக இருந்தது.
நான் Copilot, Claude Code மற்றும் OpenCode ஆகியவற்றைப் பயன்படுத்தினேன். ஒவ்வொரு கருவிக்கும் (tool) அதன் சொந்த ஹோம் டைரக்டரி (home directory), அதன் சொந்த அமைப்புகள் (settings) மற்றும் அதன் சொந்த நினைவகம் (memory) இருந்தன. நான் ஒவ்வொரு முறையும் ஒரு புதிய திறன் அல்லது விதியைக் சேர்க்கும்போது, "இந்தக் கருவி இதை எங்கே எதிர்பார்க்கிறது?" என்று கேட்க வேண்டியிருந்தது.
எனது ஹோம் டைரக்டரி AI ஃபோல்டர்களின் குப்பைத் தொட்டியாக மாறியது.
ஏஜெண்டுகளுக்கு இடையே திட்டங்களை (plans) பரிமாற Markdown கோப்புகளைப் பயன்படுத்த முயன்றேன். அது உதவியது, ஆனால் தோல்வியடைந்தது. ஒரு ஏஜென்ட் ஒரு கருதுகோளை (assumption) தவறவிடுவதால், அடுத்த ஏஜென்ட் தவறான முடிவைத் தந்தது. கோப்புகள் தரவுகளை வழங்கின, ஆனால் அவை பகிரப்பட்ட சூழலை (shared context) வழங்கவில்லை.
எனக்கு ஒரு வழி தேவைப்பட்டது:
- உயர்நிலை விதிகளை (high-level rules) ஒருமுறை மட்டும் எழுத.
- அனுமதி விதிகளை (permission rules) ஒரே இடத்தில் வைத்திருக்க.
- திறன்களைக் கையால் நகலெடுப்பதைத் தவிர்க்க.
- வெவ்வேறு திட்டங்கள் மற்றும் அமர்வுகள் (sessions) முழுவதும் நினைவகத்தைப் பகிர.
இதைச் சரிசெய்ய நான் ஒரு லோக்கல் கண்ட்ரோல் பிளேன் உருவாக்கினேன்.
எனது அமைப்பின் (setup) மையம் ஒரு ஒற்றை டைரக்டரி: ~/.ai.
சிதறிக்கிடக்கும் ஃபோல்டர்களுக்குப் பதிலாக, நான் symlinks பயன்படுத்துகிறேன். கருவிகள் அவை தங்களின் சொந்த இடத்தில் இருப்பதாக நினைக்கின்றன, ஆனால் உண்மையான கட்டமைப்பு ஒரே இடத்தில் உள்ளது. நான் அனைத்து மாடல் டிராஃபிக்கையும் (model traffic) ஒரு லோக்கல் ப்ராக்ஸி (local proxy) மூலம் வழிநடத்துகிறேன் மற்றும் MCP வழியாக நினைவகத்திற்காகப் பகிரப்பட்ட SQLite தரவுத்தளத்தைப் பயன்படுத்துகிறேன்.
இது இரண்டு வெவ்வேறு பணிகளைப் பிரிக்கிறது:
- ரூட்டிங் (Routing): மாடல் கோரிக்கைகள் (requests) வழங்குநரை (provider) சென்றடைவதற்கு முன் ஒரு லோக்கல் ப்ராக்ஸி வழியாகச் செல்கின்றன.
- நினைவகம் (Memory): நீண்ட காலத் தகவல்கள் (long-lived facts) ஒரு லோக்கல் ஸ்டோரில் (local store) சேமிக்கப்படுகின்றன.
ஒரு மாடல் விசித்திரமாக நடந்துகொண்டால், நான் ப்ராக்ஸியைச் சரிபார்க்கிறேன். ஒரு ஏஜென்ட் ஒரு விவரத்தை மறந்தால், நான் நினைவகத்தைச் சரிபார்க்கிறேன். இது டீபக்கிங்கை (debugging) எளிதாக்குகிறது.
மீண்டும் கண்டறிய கடினமான விஷயங்களை எனது பகிரப்பட்ட நினைவகம் சேமிக்கிறது:
- திட்ட முடிவுகள் (Project decisions).
- ஆர்க்கிடெக்சர் குறிப்புகள் (Architecture notes).
- பணிப்பாய்வு விருப்பங்கள் (Workflow preferences).
- மீண்டும் மீண்டும் வரும் பிழைகள் (Recurring bugs).
நான் எனது பாதுகாப்பையும் (security) மையப்படுத்தினேன். கோடிங் தரநிலைகள் (coding standards) மற்றும் தடைசெய்யப்பட்ட கட்டளைகளுக்கு (denied commands) நான் பகிரப்பட்ட கோப்புகளைப் பயன்படுத்துகிறேன். இது ஒரு ஏஜென்ட்டிலிருந்து மற்றொரு ஏஜெண்டிற்கு மாறுவது சூழலின் பாதுகாப்பைப் பாதிக்காது என்பதை உறுதி செய்கிறது.
இது ஒரு சரியான ஏஜென்ட்டைக் கண்டறிவதைப் பற்றியது அல்ல. எனது ஏஜெண்டுகள் போதுமான சூழலைப் (context) பகிர்ந்து கொள்வதை உறுதி செய்வதைப் பற்றியது, இதனால் அவற்றுக்கிடையே மாறுவது மீண்டும் ஆரம்பத்திலிருந்து தொடங்குவது போல உணரப்படாது.
Source: https://dev.to/sperekrestova/i-built-a-local-control-plane-for-my-coding-agents-1bf7
விருப்பமான கற்றல் சமூகம்: https://t.me/GyaanSetuAi