SSEతో AI లాటెన్సీని నియంత్రించడం
నేను ఒక AI ఆటోకంప్లీట్ ఫీచర్ను రూపొందించాను. వినియోగదారులు దానిని అసహ్యించుకున్నారు.
ప్రతి కీస్ట్రోక్ ఒక AI రిక్వెస్ట్ను ట్రిగ్గర్ చేసేది. పూర్తి JSON రెస్పాన్స్ కోసం వినియోగదారులు 2 నుండి 3 సెకన్ల పాటు వేచి ఉండాల్సి వచ్చేది. UI సరిగ్గా పనిచేయడం లేదని అనిపించేది. నేను debouncing మరియు caching ప్రయత్నించాను. కానీ ఏదీ పని చేయలేదు. అసలు సమస్య అలాగే ఉంది: పూర్తి సమాధానం వచ్చే వరకు వినియోగదారులకు ఏమీ కనిపించేది కాదు.
నేను దీనిని Server-Sent Events (SSE) ఉపయోగించి, రెస్పాన్స్లను ముక్కలు ముక్కలుగా స్ట్రీమ్ చేయడం ద్వారా పరిష్కరించాను.
పాత విధానం ఇలా ఉండేది:
- యూజర్ టైప్ చేస్తారు
- 300ms debounce
- HTTP POST రిక్వెస్ట్
- AI ప్రాసెస్ చేస్తుంది (1-2 సెకన్లు)
- సర్వర్ పూర్తి రెస్పాన్స్ను తిరిగి పంపుతుంది
- క్లయింట్ రెండర్ చేస్తుంది
వినియోగదారులు సెకన్ల పాటు ఖాళీ స్క్రీన్ను చూస్తూ ఉండాల్సి వచ్చేది. లోడింగ్ స్పిన్నర్ ఉన్నప్పటికీ, అది చాలా నెమ్మదిగా అనిపించేది.
నేను polling లేదా WebSockets గురించి ఆలోచించాను. Polling వల్ల ఓవర్హెడ్ (overhead) ఎక్కువగా ఉంటుంది. వన్-వే స్ట్రీమింగ్ (one-way stream) కోసం WebSockets చాలా బరువుగా (heavy) అనిపిస్తాయి.
నేను SSEని ఎంచుకోవడానికి కారణాలు:
- ఇది సర్వర్ నుండి క్లయింట్కు వన్-వే (one-way) పద్ధతిలో పనిచేస్తుంది
- ఇది సాధారణ టెక్స్ట్ మరియు JSON చంక్స్ (chunks) ఉపయోగిస్తుంది
- కనెక్షన్ కట్ అయితే ఇది ఆటోమేటిక్గా రీకనెక్ట్ అవుతుంది
- మీ సర్వర్లో ఎటువంటి అదనపు లైబ్రరీల అవసరం లేదు
ఫలితాలు అన్నీ మార్చివేసాయి:
- మొదటి విజువల్ రెస్పాన్స్ సమయం: 2.1s నుండి 0.3s కి తగ్గింది
- యూజర్ ఎంగేజ్మెంట్: 40% పెరిగింది
- యూజర్ ఫిర్యాదులు: సున్నా
స్ట్రీమింగ్ అనేది యూజర్ యొక్క అవగాహన (perception) గురించి. స్టాటిక్ UI కంటే ప్రోగ్రెసివ్ UI వేగంగా అనిపిస్తుంది. ఒకేసారి పెద్ద టెక్స్ట్ బ్లాక్ కోసం వేచి ఉండటం కంటే, పదాలు ఒక్కొక్కటిగా కనిపించడాన్ని వినియోగదారులు ఇష్టపడతారు.
మీ AI రెస్పాన్స్లు చాలా చిన్నవిగా ఉంటే, స్టాండర్డ్ రిక్వెస్ట్లనే వాడండి. మీకు టూ-వే (two-way) కమ్యూనికేషన్ కావాలంటే, WebSockets ఉపయోగించండి. కానీ చాలా వరకు AI స్ట్రీమింగ్ అవసరాలకు, SSE ఉత్తమ ఎంపిక.
మీ యాప్లలో AI లాటెన్సీని మీరు ఎలా హ్యాండిల్ చేస్తున్నారు? మీరు స్ట్రీమ్ చేస్తారా లేదా పూర్తి రెస్పాన్స్ల కోసం వేచి ఉంటారా?