ఒక AI ఏజెంట్ తన స్వంత క్రెడెన్షియల్స్ను (credentials) కలిగి ఉండి, నేరుగా బాహ్య సేవలకు (external services) కనెక్ట్ అయినప్పుడు, అది ఒక ఉద్యోగి సాఫ్ట్వేర్లా కాకుండా, ఎటువంటి పర్యవేక్షకుడు లేని, కార్పొరేట్ కార్డ్ ఉన్న కాంట్రాక్టర్లా వ్యవహరిస్తుంది. అది దేనిని తాకింది, ఆ యాక్సెస్ను ఎవరు ఆమోదించారు, లేదా ఒక సంభాషణ మరొక దానికంటే పది రెట్లు ఎక్కువ ఖర్చు ఎందుకు అయ్యింది అనేది మీరు చూడలేరు. లాగ్లు (logs) డజన్ల కొద్దీ సర్వీసుల మధ్య విడిపోతాయి. ప్రశ్నలు పెరుగుతూనే ఉంటాయి.
ఏజెంట్ నిజంగా ఏ టూల్ను ఉపయోగించింది? ఆ డేటాబేస్ను తాకడానికి దానికి ఎవరు అనుమతి ఇచ్చారు? సోమవారం ఐదు టోకెన్లను ఉపయోగించినప్పుడు, మంగళవారం రన్ నలభై వేల టోకెన్లను ఎందుకు ఖర్చు చేసింది? మనం నిజంగా ఎంత ఖర్చు చేశాము?
వినియోగదారులు, మోడల్స్ మరియు సర్వీసుల మధ్య ఒక సెంట్రల్ కంట్రోల్ లేయర్ (central control layer) లేకపోతే, ఈ ప్రశ్నలకు సమాధానం దొరకదు. ప్రతి కనెక్షన్ను ఒకేసారి రిజిస్టర్ చేసే, ఏజెంట్కు నిజంగా అవసరమైన పరిమిత ఫంక్షన్లను మాత్రమే అనుమతించే మరియు ప్రతి ఎగ్జిక్యూషన్ను పూర్తిగా రికార్డ్ చేసే ఒక సింగిల్ ప్లేన్ (single plane) మీకు అవసరం. ఈ ఆర్టికల్, deco Studioను లోకల్ కంట్రోల్ ప్లేన్గా ఉపయోగిస్తూ ఒక అడ్వాన్స్డ్ ల్యాబ్ గురించి వివరిస్తుంది. మీరు దానిని సెటప్ చేస్తారు, ఒక సురక్షితమైన Model Context Protocol సర్వర్ను కనెక్ట్ చేస్తారు, ఖచ్చితంగా ఒక అనుమతించబడిన ఫంక్షన్ను మాత్రమే ఎక్స్పోజ్ చేస్తారు, మరియు ఏజెంట్ తన పరిధిని దాటి వెళ్లడానికి ప్రయత్నించినప్పుడు ఏం జరుగుతుందో గమనిస్తారు.
చెల్లాచెదురుగా ఉన్న క్రెడెన్షియల్స్తో వచ్చే సమస్య
ఒక సాధారణ టీమ్ సెటప్ను ఊహించుకోండి. ఒక డెవలపర్ తన వ్యక్తిగత కీని ఉపయోగించి ఒక ఏజెంట్ను సెర్చ్ APIకి కనెక్ట్ చేస్తారు. మరొకరు డెమో సురక్షితంగా అనిపించి, అదే ఏజెంట్ను ప్రొడక్షన్ డేటాబేస్కు కనెక్ట్ చేస్తారు. మూడవ వ్యక్తి ఏజెంట్ "ఇన్వాయిస్లకు సహాయపడటానికి" ఒక బిల్లింగ్ లుకప్ టూల్ను జోడిస్తారు. ప్రతి కనెక్షన్ ఇతరులకు కనిపించదు. ఇప్పుడు ఏజెంట్కు సెర్చ్, ప్రొడక్షన్ డేటా మరియు ఆర్థిక రికార్డులకు నేరుగా యాక్సెస్ ఉంది, కానీ ఏవి లైవ్లో ఉన్నాయో అనే ఏకీకృత జాబితా టీమ్ వద్ద లేదు.
క్రెడెన్షియల్స్ ఏజెంట్ లోపలే ఉన్నప్పుడు, గవర్నెన్స్ (governance) దెబ్బతింటుంది. కీ ఏజెంట్ మెమరీలో లేదా దాని లోకల్ ఎన్విరాన్మెంట్ ఫైల్లో ఉండటం వల్ల మీరు సెంట్రల్గా యాక్సెస్ను రద్దు చేయలేరు. బాహ్య సర్వీస్ కేవలం ఒక అనామక ఆటోమేటెడ్ క్లయింట్ నుండి వచ్చిన API కాల్ను మాత్రమే చూస్తుంది కాబట్టి మీరు వినియోగాన్ని ఆడిట్ చేయలేరు. ఖర్చుల షాక్ కొన్ని రోజుల తర్వాత క్లౌడ్ బిల్లులో కనిపిస్తుంది, అప్పటికి ఏ ప్రాంప్ట్ వల్ల ఖర్చు పెరిగిందో ఎవరికీ గుర్తుండదు.
deco Studioలో మీ కంట్రోల్ ప్లేన్ను నిర్మించడం
deco Studio ఒక లోకల్ హబ్గా పనిచేస్తూ దీనిని పరిష్కరిస్తుంది. మీరు దీనిని మీ స్వంత మెషీన్లో రన్ చేస్తారు మరియు ఇది కాన్ఫిగరేషన్లు ఉండే ఏకైక ప్రదేశంగా మారుతుంది. API కీలు మరియు టూల్ డెఫినిషన్లను ఏజెంట్ల మధ్య చెల్లాచెదురుగా ఉంచే బదులు, మీరు స్టూడియోలో ఒకసారి కనెక్షన్ను రిజిస్టర్ చేస్తారు. ఆ తర్వాత ప్రతి ఏజెంట్ ఏ ఫంక్షన్లను చూడగలదో మీరు ఖచ్చితంగా నిర్ణయిస్తారు.
దీనిని ఒక స్విచ్బోర్డ్ను ఇన్స్టాల్ చేసినట్లుగా భావించండి. వైర్లన్నీ ఒకే గదిలోకి వస్తాయి. ఏ లైన్లు ఏ విభాగాలకు కనెక్ట్ అవ్వాలో మీరు ఎంచుకుంటారు మరియు ప్రతి కాల్ యొక్క రికార్డును మీరు ఉంచుతారు.
మొదట deco Studioను లోకల్గా రన్ చేయడం ప్రారంభించండి. అది సిద్ధమైన తర్వాత, మీరు కాన్ఫిగరేషన్ను సెంట్రలైజ్ చేస్తారు. ఒక టూల్ను ఉపయోగించాలనుకునే ప్రతి ఏజెంట్ ఇప్పుడు నేరుగా బాహ్య సర్వీస్ను కాకుండా, కంట్రోల్ ప్లేన్ను అడగాలి. ఇది వెంటనే మీరు గమనించడానికి (observe), ఫిల్టర్ చేయడానికి మరియు లాగ్ చేయడానికి వీలయ్యే ఒక చోట (chokepoint) సృష్టిస్తుంది.
సురక్షితమైన MCP సర్వర్ను కనెక్ట్ చేయడం
ఈ ల్యాబ్లో, మీరు ఒక Model Context Protocol సర్వర్ను కనెక్ట్ చేస్తారు. మోడల్స్ బాహ్య టూల్స్తో ఇంటరాక్ట్ అవ్వడానికి MCP ఒక ఓపెన్ స్టాండర్డ్, కానీ స్టాండర్డ్స్ భద్రతను గ్యారెంటీ ఇవ్వవు. ఇక్కడ కీలకమైన దశ ఎంపిక (selectivity). సర్వర్ అందించే ప్రతి ఎండ్పాయింట్ను మీరు గుడ్డిగా ఎక్స్పోజ్ చేయరు. మీరు సర్వర్ను deco Studioలో రిజిస్టర్ చేస్తారు, ఆపై మీ టెస్ట్ ఏజెంట్కు కేవలం ఒక అనుమతించబడిన ఫంక్షన్ను మాత్రమే ఎక్స్పోజ్ చేస్తారు.
ఉదాహరణకు, మీ MCP సర్వర్ పది ఫంక్షన్లను అందించవచ్చు: ఫైల్ రీడ్, ఫైల్ రైట్, డేటాబేస్ క్వెరీ, నెట్వర్క్ ఫెచ్ మరియు మరికొన్ని. మీరు ఒక హానిలేని ఆపరేషన్ను ఎంచుకుంటారు, బహుశా ఒక సాండ్బాక్స్డ్ కాలిక్యులేటర్ లేదా సింథటిక్ డేటాపై రీడ్-ఓన్లీ లుకప్, మరియు దానిని మాత్రమే ఎక్స్పోజ్ చేస్తారు. మిగిలిన తొమ్మిది ఏజెంట్కు కనిపించవు. ఏజెంట్ వాటిని అడిగితే, కంట్రోల్ ప్లేన్ ఖచ్చితంగా తిరస్కరిస్తుంది.
ఇది 'ప్రిన్సిపల్ ఆఫ్ లీస్ట్ ప్రివిలేజ్' (principle of least privilege) ను యాంత్రికంగా అమలు చేయడం. ఏజెంట్ సామర్థ్యాన్ని ఒక మర్యాదపూర్వక సూచన ద్వారా కాకుండా, ఒక సాఫ్ట్వేర్ బౌండరీ ద్వారా పొందుతుంది.
బౌండరీని పరీక్షించడం
ఒక టెస్ట్ ఏజెంట్ను సృష్టించి, దానిని మీ deco Studio కంట్రోల్ ప్లేన్కు అనుసంధానించండి. అనుమతించబడిన ఏకైక ఫంక్షన్ను అవసరమయ్యే పనిని దానికి ఇవ్వండి. అది విజయవంతం కావడాన్ని గమనించండి. స్టూడియోలోని లాగ్లు మోడల్ రిక్వెస్ట్, కంట్రోల్ ప్లేన్ ద్వారా టూల్ కాల్ రూటింగ్, ఫంక్షన్ ఎగ్జిక్యూషన్ మరియు మోడల్కు తిరిగి వచ్చే ఫలితాన్ని చూపుతాయి. మీరు మొత్తం మార్గాన్ని ఒకే నిరంతర ట్రేస్లో చదవవచ్చు.
ఇప్పుడు ఏజెంట్కు మీరు కావాలనే మినహాయించిన ఫంక్షన్ను అవసరమయ్యేలా రెండవ టాస్క్ను ఇవ్వండి. ఏజెంట్ ఆ పరిమితిని అధిగమించడానికి ప్రయత్నించవచ్చు లేదా ఆ టూల్ ఉందని ఊహించవచ్చు (hallucinate). ఏది ఏమైనా, ఆ కాల్ కంట్రోల్ ప్లేన్కు చేరుతుంది, అలోలిస్ట్ దానిని తిరస్కరిస్తుంది మరియు ఎగ్జిక్యూషన్ విఫలమవుతుంది. ఈ వైఫల్యం మాత్రమే ఆ బౌండరీ సైద్ధాంతికంగా కాకుండా, సాఫ్ట్వేర్ ద్వారా అమలు చేయబడిందని మీకు నిరూపిస్తుంది.
దీనిని మొదట సింథటిక్ టాస్క్లతో చేయండి. జనరేట్ చేయబడిన యూజర్ ప్రొఫైల్లతో నిండిన ఒక నకిలీ డేటాబేస్ను నిర్మించండి. ఏజెంట్ను దానిని క్వెరీ చేయనివ్వండి. అలోలిస్ట్ మరియు తిరస్కరణలను (denials) ధృవీకరించండి. బౌండరీపై మీకు నమ్మకం వచ్చిన తర్వాతే, ఏజెంట్ను ప్రొడక్షన్ సిస్టమ్స్కు అనుసంధానించడం గురించి ఆలోచించండి. గోడను ధృవీకరించకముందే నిజమైన డేటా వైపు వెళ్లడం వల్ల రహస్యాలు లీక్ అయ్యే ప్రమాదం ఉంది.
ఒక రన్ యొక్క పూర్తి మార్గాన్ని (Full Path) చదవడం
deco Studio మీకు ఎగ్జిక్యూషన్ యొక్క ప్రతి పొరను పరిశీలించే అవకాశం ఇస్తుంది. మీరు రా మోడల్ రిక్వెస్ట్ను చూడవచ్చు: ప్రాంప్ట్, కాంటెక్స్ట్ విండో, ఫార్మాటింగ్. మోడల్ చేయాలని నిర్ణయించుకున్న టూల్ కాల్ను మీరు చూడవచ్చు. కంట్రోల్ ప్లేన్ ఆ కాల్ను ఎలా రూట్ చేసింది, ఫంక్షన్ను ఎలా ఎగ్జిక్యూట్ చేసింది మరియు పేలోడ్ను ఎలా రిటర్న్ చేసిందో మీరు చూడవచ్చు. చివరగా, మోడల్ తన సమాధానాన్ని రూపొందించడానికి ఆ ఫలితాన్ని ఎలా ఉపయోగిస్తుందో మీరు చూడవచ్చు.
ఈ విజిబిలిటీ ప్రాథమిక ఆడిట్ ప్రశ్నలకు సమాధానం ఇస్తుంది. కంట్రోల్ ప్లేన్ లాగ్ చేసినందున ఏ టూల్ ఫైర్ అయిందో మీకు తెలుస్తుంది. కాన్ఫిగరేషన్ రికార్డులు ఒక లోకల్ రిజిస్ట్రీలో ఉన్నందున ఎవరికి యాక్సెస్ ఇచ్చారో మీకు తెలుస్తుంది. మీరు టోకెన్లను లెక్కించగలరు కాబట్టి ఆ రన్ ఎందుకు ఖరీదైనదో మీకు తెలుస్తుంది.
ముఖ్యమైన వాటిని లెక్కించడం
ప్రతి రన్ కోసం, నాలుగు నిర్దిష్ట మెట్రిక్స్ను ట్రాక్ చేయండి. మొదటిది, ఇన్పుట్ మరియు అవుట్పుట్ టోకెన్లు. ఇవి మోడల్ ఖర్చులలో ఎక్కువ భాగం 차지 చేస్తాయి, మరియు మీకు ఖచ్చితమైన లెక్కలు కావాలి, అంచనాలు కాదు. రెండవది, మోడల్ లేటెన్సీని టూల్ లేటెన్సీ నుండి వేరు చేయండి. మీ ప్రాంప్ట్ మరియు మోడల్ స్పందన మధ్య సమయం, ఒక టూల్ కాల్కు సమాధానం ఇవ్వడానికి ఎక్స్టర్నల్ సర్వీస్ తీసుకునే సమయానికి భిన్నంగా ఉంటుంది. ఈ రెండింటినీ కన్ఫ్యూజ్ చేయడం వల్ల సమస్యను తప్పుగా నిర్ధారించే అవకాశం ఉంది. మూడవది, ధృవీకరించబడిన ప్రొవైడర్ రేట్ల ఆధారంగా ఖర్చును లెక్కించండి. ఊహించకండి. మీ ప్రొవైడర్ యొక్క ప్రైసింగ్ షీట్ను తనిఖీ చేసి, కొలిచిన టోకెన్లతో సరిపోల్చండి. నాల్గవది, విజయవంతమైన కాల్స్ను తిరస్కరించబడిన అనధికారిక కాల్స్తో పోల్చండి. తిరస్కరణల సంఖ్య ఎక్కువగా ఉంటే, మీ ఏజెంట్ బౌండరీలను పరీక్ష sedang (probing) ఉందని లేదా మీ అలోలిస్ట్ సరైన అవసరాలతో సరిపోలడం లేదని అర్థం.
ఈ సంఖ్యలు ఏజెంట్ ఆపరేషన్లను ఒక బ్లాక్-బాక్స్ సబ్స్క్రిప్షన్ నుండి ఒక అబ్జర్వబుల్ సిస్టమ్గా మారుస్తాయి. మీరు బడ్జెట్ను ప్లాన్ చేయవచ్చు, ఆప్టిమైజ్ చేయవచ్చు మరియు వివరించవచ్చు.
లోకల్ కంట్రోల్ మరియు లోకల్ ఎగ్జిక్యూషన్ మధ్య తేడా
ఇది జాగ్రత్తగా నిర్మించే వారిని కూడా తప్పుదారి పట్టించే పాఠం. మీ మెషీన్పై deco Studioని రన్ చేయడం వల్ల కాన్ఫిగరేషన్పై మీకు లోకల్ కంట్రోల్ లభిస్తుంది, కానీ అది మోడల్ యొక్క లోకల్ ఎగ్జిక్యూషన్ను గ్యారెంటీ చేయదు. మీరు ఏజెంట్ను OpenAI, Anthropic లేదా ఏదైనా హోస్టెడ్ API వంటి ఎక్స్టర్నల్ ప్రొవైడర్ను కాల్ చేసేలా కాన్ఫిగర్ చేస్తే, మీ ప్రాంప్ట్లు మీ మెషీన్ నుండి బయటకు వెళ్తాయి. స్టూడియో గేట్ను నిర్వహిస్తుంది, కానీ డేటా ఇంకా నెట్వర్క్ ద్వారా ప్రయాణిస్తుంది.
ఎల్లప్పుడూ ఈ బౌండరీలను ట్రాక్ చేయండి. పైప్లైన్లోని ఏ భాగాలు లోకల్హాస్ట్పై ఉంటాయి మరియు ఏ భాగాలు వేరొకరి సర్వర్కు వెళ్తాయో తెలుసుకోండి. మీ డేటా సెన్సిటివ్గా ఉంటే, టూల్ లేయర్ యొక్క లోకల్ కంట్రోల్ సరిపోదు. మోడల్ ఇన్ఫరెన్స్ ఎక్కడ జరుగుతుందో కూడా మీరు తెలుసుకోవాలి. లోకల్ డ్యాష్బోర్డ్ సౌకర్యాన్ని రిమోట్ మోడల్ వాస్తవంతో కన్ఫ్యూజ్ చేయకండి.
ఇన్స్ట్రక్షన్స్ అంటే అథరైజేషన్ కాదు
ప్రాంప్టింగ్ ద్వారా ఏజెంట్ను సురక్షితం చేయడానికి ప్రయత్నించడం అనేది ఒక ప్రమాదకరమైన షార్ట్కట్. మోడల్కు, "Never call the delete function" అని చెప్పడం అనేది సెక్యూరిటీ కంట్రోల్ కాదు. అది కేవలం ఒక సూచన మాత్రమే. మోడల్స్ ఇన్స్ట్రక్షన్స్ను తప్పుగా అర్థం చేసుకోవచ్చు, జైల్బ్రేక్ ప్రాంప్ట్లకు గురవ్వచ్చు లేదా కేవలం రీజనింగ్ లోపాలు చేయవచ్చు. నిజమైన సెక్యూరిటీ సాఫ్ట్వేర్ బౌండరీ వద్ద ఉంటుంది.
ఏ ఫంక్షన్లు కాల్ చేయవచ్చో ఖచ్చితంగా నిర్వచించడానికి deco Studioలో అలోలిస్ట్లను ఉపయోగించండి. కంట్రోల్ ప్లేన్ లోపల సర్వర్-సైడ్ చెక్లతో ఆ పరిమితులను అమలు చేయండి. యూజర్ ఫైల్ పర్మిషన్లను ఎలా తెలుసుకుంటారో, ఏజెంట్ కూడా తన సామర్థ్యాలను అలాగే తెలుసుకోవాలి: అంటే ఒక హార్డ్ లిమిట్ను ఎదుర్కోవడం ద్వారా, కాకుండా ఒక స్నేహపూర్వక నోట్ను చదవడం ద్వారా కాదు. సెక్యూరిటీ అనేది ఆర్కిటెక్చర్లో ఉండాలి, నేచురల్ లాంగ్వేజ్లో కాదు.
చిన్నగా ప్రారంభించండి, అనుమానంతో ఉండండి
మీ కంట్రోల్ ప్లేన్ను ఒక్కో దశలో నిర్మించండి. ఒక MCP సర్వర్. ఒక ఎక్స్పోజ్డ్ ఫంక్షన్. ఒక సింథటిక్ టాస్క్. ఏజెంట్ ఎక్కడ విజయవంతం కావాలి మరియు ఎక్కడ విఫలం కావాలి అనేది ధృవీకరించండి. ట్రేస్ను చదవండి. టోకెన్ కౌంట్లను నిర్ధారించండి. ఆ తర్వాత తదుపరి టూల్ను జోడించండి.
కంట్రోల్ అనేది మీరు నొక్కే స్విచ్ కాదు. అది బౌండరీలను నమ్మకముందే వాటిని నిరూపించుకునే ఒక అలవాటు. ఆ అలవాటును ప్రాక్టీస్ చేయడానికి deco Studio మీకు లోకల్ ప్లేన్ను అందిస్తుంది. స్వయంప్రతిపత్తి కలిగిన ఏజెంట్ల సమూహాన్ని ఒక మేనేజ్డ్, అబ్జర్వబుల్ మరియు బౌండెడ్ సిస్టమ్గా మార్చడానికి దానిని ఉపయోగించండి.
Source: Controlling AI Agents in deco Studio: Tools, Permissions, and Cost
ఐచ్ఛిక అభ్యాస సమూహం: Telegramలో GyaanSetu AI