నా ప్రొడక్షన్ ఏజెంట్‌ను దెబ్బతీసిన నల్ ఇన్పుట్

డెమో మూడు వారాల పాటు ఖచ్చితంగా నడిచింది. ప్రతి టెస్ట్ ఇన్పుట్ పనిచేసింది. ప్రతి అవుట్‌పుట్ సరైన చోటుకు చేరింది. సిస్టమ్ నమ్మదగినదని నేను అనుకున్నాను.

అప్పుడు ఒక సప్లయర్ ఖాళీ సబ్జెక్ట్ లైన్‌తో ఒక ఈమెయిల్ పంపారు.

ఆర్డర్ రిఫరెన్స్‌ను సంగ్రహించడానికి ఏజెంట్ ఒక స్ట్రింగ్‌ను ఆశించింది. దానికి బదులుగా, దానికి ఒక నల్ (null) విలువ అందింది. అది క్రాష్ కాలేదు. అది జరిగేదైతే ఇంకా బాగుండేది. అది నిజమైనదిగా కనిపించే ఒక నకిలీ ఆర్డర్ రిఫరెన్స్‌ను సృష్టించింది. డౌన్‌స్ట్రీమ్ సిస్టమ్ దానిని ప్రాసెస్ చేసింది. నాలుగు గంటల వరకు ఎవరూ గమనించలేదు.

డెమోలు మీరు ఆశించే ఇన్పుట్‌లను ఉపయోగిస్తాయి. ప్రొడక్షన్ మీరు ఊహించని ఇన్పుట్‌లను ఉపయోగిస్తుంది.

నేను aienterprise.dk వద్ద ఏజెంట్ ఆపరేషన్‌ను నడుపుతున్నాను. నేను పూర్తి ట్రేస్‌ను చూశాను. సబ్జెక్ట్ లైన్ నుండి ఆర్డర్ రిఫరెన్స్‌ను సంగ్రహించాలని ప్రాంప్ట్ ఏజెంట్‌కు చెప్పింది. సబ్జెక్ట్ లైన్ ఉంటే ఇది పనిచేస్తుంది.

ఒకవేళ సబ్జెక్ట్ లైన్ లేకపోతే, లార్జ్ లాంగ్వేజ్ మోడల్ (LLM) ఆ ఖాళీని పూరిస్తుంది. అది సరిగ్గా కనిపిస్తున్నట్లుగా ఏదో ఒకటి సృష్టిస్తుంది. ఇది యాదృచ్ఛికమైన శబ్దం (random noise) కాదు. ఇది స్ట్రక్చర్డ్ నాయిస్ (structured noise). ఇది సరిగ్గా కనిపిస్తుంది కాబట్టి ప్రమాదకరమైనది. మీరు ఒక ఫెయిలర్‌ను గుర్తించగలరు. కానీ, నమ్మకంగా చెప్పబడిన తప్పుడు సమాధానాన్ని సులభంగా గుర్తించలేరు.

నేను మోడల్‌ను మళ్ళీ ట్రైన్ చేయలేదు. నేను ప్రాంప్ట్‌ను మార్చలేదు. మోడల్ కాల్‌కు ముందు నేను ఒక గార్డ్ (guard)ను జోడించాను.

ఇప్పుడు, మొదట ఒక సాధారణ తనిఖీ జరుగుతుంది. అది ఇలా అడుగుతుంది: సబ్జెక్ట్ ఫీల్డ్ ఉందా మరియు అది ఖాళీగా లేదా? ఒకవేళ సమాధానం 'కాదు' అని వస్తే, ఆ మెసేజ్ మనిషి పరిశీలించడానికి హోల్డ్ క్యూ (hold queue)కు వెళ్తుంది. ఏజెంట్ ఆ తప్పుడు ఇన్పుట్‌ను ఎప్పుడూ చూడదు.

ఈ గార్డ్ కేవలం పన్నెండు లైన్ల కోడ్ మాత్రమే. ఈ సంవత్సరం నేను నిర్మించిన అత్యంత ముఖ్యమైన విషయం ఇదే.

ఈ ప్యాటర్న్ చాలా సరళమైనది. ఒక ఏజెంట్ ఒక నిర్దిష్ట నిర్మాణాన్ని (structure) ఆశిస్తే, ప్రొడక్షన్ ఏదో ఒక సమయంలో అన్‌స్ట్రక్చర్డ్ డేటాను పంపిస్తుంది. దీనికి పరిష్కారం మరింత తెలివైన మోడల్ కాదు. దీనికి పరిష్కారం ఒక సరిహద్దు (boundary). మోడల్‌ను ఊహించనివ్వకుండా, తప్పుడు ఇన్పుట్‌ను మనిషికి పంపేలా చేసే ఒక తనిఖీ మీకు అవసరం.

విశ్వసనీయత (Reliability) అనేది మాత్రమే అసలైన ఫీచర్. డెమో ఒక ఏజెంట్ ఒక పనిని చేయగలదని చూపిస్తుంది. ప్రొడక్షన్ అనేది తప్పుడు ఇన్పుట్ వచ్చినప్పుడు కూడా తెల్లవారుజామున 3 గంటలకు ఏజెంట్ ఆ పనిని చేయగలదని చూపిస్తుంది. మీ కస్టమర్లకు రెండో భాగం మాత్రమే ముఖ్యం.

నా ఏజెంట్ ఇప్పుడు రోజుకు 200 ఆపరేషన్‌లను ఎటువంటి సమస్యలు లేకుండా ప్రాసెస్ చేస్తోంది. వారానికి రెండుసార్లు హోల్డ్ క్యూ ట్రిగ్గర్ అవుతుంది. ఒక మనిషి ఆ వింత డేటాను సమీక్షిస్తారు. ప్రొడక్షన్ ఎలా ఉంటుందో నేను తెలుసుకుంటున్నాను.

మీరు EU AI Act కింద అధిక-రిస్క్ వర్గాల కోసం ఏజెంట్‌లను నిర్మిస్తుంటే, గడువు డిసెంబర్ 2, 2027. ఇందులో ఉపాధి, బయోమెట్రిక్స్ మరియు విద్య వంటివి ఉన్నాయి. తప్పుడు ఇన్పుట్‌పై ఊహించే సిస్టమ్ ఆడిట్‌లో విఫలమవుతుంది. ఈ గార్డ్ అనేది కంప్లయన్స్ (compliance) కోసం కనీస అవసరం.

విశ్వసనీయత అనేది మీరు తర్వాత జోడించే ఫీచర్ కాదు.

నా ప్రొడక్షన్ ఏజెంట్‌ను పాడు చేసిన ఆ 'null' ఇన్‌పుట్ మరియు దాన్ని ఎలా సరిదిద్దాను

నేను ఒక AI ఏజెంట్‌ను నిర్మిస్తున్నాను. డెవలప్‌మెంట్ (development) దశలో అంతా బాగానే ఉంది, కానీ అది ప్రొడక్షన్‌లోకి వెళ్ళగానే అకస్మాత్తుగా విఫలమైంది.

సమస్య

నా ఏజెంట్ అకస్మాత్తుగా ఆగిపోయింది. లాగ్స్ (logs) పరిశీలించగా, ఒక TypeError కనిపించింది: Cannot read properties of null (reading 'length'). అంటే, నా కోడ్ ఒక null విలువపై ఆపరేషన్ చేయడానికి ప్రయత్నిస్తోంది, దీనివల్ల మొత్తం సిస్టమ్ క్రాష్ అయింది.

దానికి కారణం ఏమిటి?

పరిశోధన చేసిన తర్వాత, అసలు సమస్య తెలిసింది. నా ఏజెంట్ ఒక అప్‌స్ట్రీమ్ (upstream) API నుండి డేటాను పొందుతోంది. సాధారణంగా ఆ API ఒక స్ట్రింగ్‌ను ఇస్తుంది, కానీ ఒక ప్రత్యేక సందర్భంలో అది nullను పంపింది. నా కోడ్ ఆ null విలువను ఎదుర్కోవడానికి సిద్ధంగా లేదు, అందుకే అది విఫలమైంది.

పరిష్కారం

దీన్ని సరిచేయడానికి, నేను ఇన్‌పుట్‌ను వాలిడేట్ చేసేలా కోడ్‌ను మార్చాను. ఒకవేళ ఇన్‌పుట్ null లేదా undefined అయితే, దానికి ఒక డిఫాల్ట్ విలువను (empty string) కేటాయించేలా చేశాను.

// పాత కోడ్ (సమస్య ఉన్నది)
function processText(text) {
  return text.length; // ఇక్కడ text null అయితే error వస్తుంది
}

// కొత్త కోడ్ (సరిదిద్దబడినది)
function processText(text) {
  if (!text) {
    return 0; // null లేదా undefined అయితే 0 ని రిటర్న్ చేస్తుంది
  }
  return text.length;
}

నేర్చుకున్న పాఠాలు

ఈ అనుభవం నుండి నేను కొన్ని ముఖ్యమైన విషయాలు నేర్చుకున్నాను:

1. ఇన్‌పుట్‌లను ఎల్లప్పుడూ వాలిడేట్ చేయండి: డేటా ఎక్కడి నుండి వస్తుందో తెలియదు, కాబట్టి అది ఎప్పుడూ సరైన ఫార్మాట్‌లో ఉంటుందని నమ్మకండి.
2. డిఫెన్సివ్ ప్రోగ్రామింగ్ (Defensive Programming): కోడ్ రాసేటప్పుడే తప్పులు జరగకుండా ముందస్తు జాగ్రత్తలు తీసుకోండి.
3. డిఫాల్ట్ విలువలు వాడండి: ఒకవేళ డేటా లేకపోతే, మీ సిస్టమ్ ఆగిపోకుండా ఉండటానికి డిఫాల్ట్ విలువలను ఉపయోగించండి.