నా కోడింగ్ ఏజెంట్ల కోసం నేను ఒక లోకల్ కంట్రోల్ ప్లేన్ను నిర్మించాను
వేర్వేరు AI ఏజెంట్లను ఉపయోగించడం ఒక గందరగోళంగా ఉండేది.
నేను Copilot, Claude Code, మరియు OpenCodeలను ఉపయోగించేవాడిని. ప్రతి సాధనానికి (tool) దాని స్వంత హోమ్ డైరెక్టరీ, దాని స్వంత సెట్టింగ్లు మరియు దాని స్వంత మెమరీ ఉండేవి. నేను ప్రతిసారీ కొత్త నైపుణ్యాన్ని లేదా రూల్ను జోడించినప్పుడు, "ఈ టూల్ దీనిని ఎక్కడ ఆశిస్తుంది?" అని అడగాల్సి వచ్చేది.
నా హోమ్ డైరెక్టరీ AI ఫోల్డర్ల యొక్క ఒక చెత్త డ్రాయర్లా మారిపోయింది.
ఏజెంట్ల మధ్య ప్లాన్లను పంచుకోవడానికి నేను Markdown ఫైళ్లను ఉపయోగించడానికి ప్రయత్నించాను. అది కొంతవరకు సహాయపడింది, కానీ విఫలమైంది. ఒక ఏజెంట్ ఒక ఊహను (assumption) వదిలేస్తే, తదుపరి ఏజెంట్ తప్పు ఫలితాన్ని ఇచ్చేది. ఫైళ్లు డేటాను అందించాయి కానీ, అవి ఉమ్మడి సందర్భాన్ని (shared context) అందించలేకపోయాయి.
నాకు ఈ క్రింది వాటి కోసం ఒక మార్గం అవసరమైంది:
- హై-లెవల్ రూల్స్ను ఒక్కసారి మాత్రమే రాయడం.
- పర్మిషన్ రూల్స్ను ఒకే చోట ఉంచడం.
- నైపుణ్యాలను మాన్యువల్గా కాపీ చేయడం ఆపడం.
- వివిధ ప్రాజెక్ట్లు మరియు సెషన్ల మధ్య మెమరీని పంచుకోవడం.
దీనిని పరిష్కరించడానికి నేను ఒక లోకల్ కంట్రోల్ ప్లేన్ను నిర్మించాను.
నా సెటప్ యొక్క ప్రధాన భాగం ఒకే ఒక డైరెక్టరీ: ~/.ai.
చెల్లాచెదురుగా ఉన్న ఫోల్డర్లకు బదులుగా, నేను symlinks ఉపయోగిస్తాను. టూల్స్ తమ స్వంత స్పేస్లో ఉన్నాయని అనుకుంటాయి, కానీ అసలు నిర్మాణం ఒకే చోట ఉంటుంది. నేను మోడల్ ట్రాఫిక్ను అంతా ఒక లోకల్ ప్రాక్సీ ద్వారా పంపిస్తాను మరియు MCP ద్వారా మెమరీ కోసం ఒక షేర్డ్ SQLite డేటాబేస్ను ఉపయోగిస్తాను.
ఇది రెండు వేర్వేరు పనులను వేరు చేస్తుంది:
- రూటింగ్ (Routing): మోడల్ రిక్వెస్ట్లు ప్రొవైడర్కు చేరుకోవడానికి ముందు ఒక లోకల్ ప్రాక్సీ ద్వారా వెళ్తాయి.
- మెమరీ (Memory): దీర్ఘకాలిక వాస్తవాలు (Long-lived facts) ఒక లోకల్ స్టోర్లో ఉంటాయి.
ఒక మోడల్ వింతగా ప్రవర్తిస్తే, నేను ప్రాక్సీని తనిఖీ చేస్తాను. ఒక ఏజెంట్ ఏదైనా వివరాలను మర్చిపోతే, నేను మెమరీని తనిఖీ చేస్తాను. ఇది డీబగ్గింగ్ను సులభతరం చేస్తుంది.
మళ్ళీ వెతకడం కష్టమైన విషయాలను నా షేర్డ్ మెమరీ నిల్వ చేస్తుంది:
- ప్రాజెక్ట్ నిర్ణయాలు.
- ఆర్కిటెక్చర్ నోట్స్.
- వర్క్ఫ్లో ప్రాధాన్యతలు.
- పదేపదే వచ్చే బగ్స్.
నేను నా సెక్యూరిటీని కూడా కేంద్రీకరించాను. కోడింగ్ ప్రమాణాలు మరియు నిషిద్ధ కమాండ్ల (denied commands) కోసం నేను షేర్డ్ ఫైళ్లను ఉపయోగిస్తాను. దీనివల్ల ఒక ఏజెంట్ నుండి మరొక ఏజెంట్కు మారినప్పుడు ఎన్విరాన్మెంట్ యొక్క భద్రత మారదు.
ఇది ఒక పరిపూర్ణమైన ఏజెంట్ను కనుగొనడం గురించి కాదు. నా ఏజెంట్లు తగినంత సందర్భాన్ని (context) పంచుకునేలా చూడటం గురించి, తద్వారా వాటి మధ్య మారినప్పుడు మళ్ళీ మొదటి నుండి ప్రారంభించినట్లు అనిపించదు.
Source: https://dev.to/sperekrestova/i-built-a-local-control-plane-for-my-coding-agents-1bf7
Optional learning community: https://t.me/GyaanSetuAi