Skip to content
AI Engineering

5. Streaming – ChatGPT Jaisa Word-by-Word Jawab (Express + SSE)

November 20, 2026 5 min read

नमस्ते दोस्तों!

स्वागत है The Easy Master पर!

अब तक हमारी app पूरा जवाब बनने तक इंतज़ार करती थी – 5, 10, कभी 20 seconds तक खाली screen। User को लगता है app अटक गई।

ChatGPT ऐसा नहीं करता – जवाब शब्द-दर-शब्द आता दिखता है। कुल समय उतना ही लगता है, लेकिन पहला शब्द एक second में दिख जाता है। आज हम यही बनाएंगे।

Is LLM streaming in Hindi post mein aap seekhenge:

✅ Streaming kya hai aur क्यों ज़रूरी है
✅ Terminal mein streaming – Node.js से
✅ Adhuri lines ka problem – जिसमें सब फँसते हैं
✅ Express + SSE – server से browser तक
✅ Project: एक छोटा web chat page

1. Streaming Kaise Kaam Karti Hai?

stream: true भेजने पर Ollama एक बार में पूरा जवाब नहीं भेजता। वो हर कुछ tokens बनते ही एक छोटी JSON line भेज देता है (यहाँ कुछ fields हटाकर छोटा दिखाया है):

{"message":{"role":"assistant","content":"Git"},"done":false}
{"message":{"role":"assistant","content":" ek"},"done":false}
{"message":{"role":"assistant","content":" free"},"done":false}
...
{"message":{"role":"assistant","content":""},"done":true}

हर line एक अलग JSON है (इसे NDJSON कहते हैं)। हमें बस हर line पढ़कर उसका content screen पर जोड़ते जाना है।

2. Terminal Mein Streaming

// stream.js — jawab word-by-word terminal mein
const res = await fetch('http://localhost:11434/api/chat', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    model: 'llama3.2',
    messages: [{ role: 'user', content: 'Git kya hai? 3 line mein.' }],
    stream: true,
  }),
});

const decoder = new TextDecoder();
let buffer = '';
for await (const chunk of res.body) {
  buffer += decoder.decode(chunk, { stream: true });
  const lines = buffer.split('n');
  buffer = lines.pop(); // adhuri line agle chunk ke saath judegi
  for (const line of lines) {
    if (!line.trim()) continue;
    const part = JSON.parse(line);
    process.stdout.write(part.message.content);
    if (part.done) console.log('n[done]');
  }
}

node stream.js चलाइए – जवाब typing की तरह आता दिखेगा।

3. Adhuri Lines Ka Problem

Network data को chunks में भेजता है, और chunk की सीमा JSON line की सीमा से मेल नहीं खाती। एक chunk में डेढ़ line आ सकती है। अगर आप हर chunk को सीधे JSON.parse करेंगे, तो किसी दिन अचानक Unexpected end of JSON error आएगा।

इसलिए code में buffer है:

  • आया हुआ data buffer में जोड़ो
  • n पर तोड़ो – पूरी lines मिल जाएंगी
  • आख़िरी टुकड़ा अधूरा हो सकता है – उसे lines.pop() से वापस buffer में रखो, अगले chunk के साथ पूरा होगा

यह छोटी सी चीज़ है, लेकिन streaming code में सबसे आम bug यही है।

4. Express + SSE – Browser Tak Streaming

Browser सीधे Ollama से बात नहीं करेगा – असली app में बीच में आपका server होता है (जहाँ API keys और नियम रहते हैं)। Server से browser तक streaming का आसान तरीका है Server-Sent Events (SSE): server एक ही response में बार-बार data: ... लिखता रहता है।

npm install express कीजिए (Express.js Setup अगर Express पहली बार use कर रहे हैं), फिर:

// server.js — Express se browser tak streaming (Server-Sent Events)
import express from 'express';

const app = express();
app.use(express.json());
app.use(express.static('public'));

app.post('/api/ask', async (req, res) => {
  res.setHeader('Content-Type', 'text/event-stream');
  res.setHeader('Cache-Control', 'no-cache');

  const ai = await fetch('http://localhost:11434/api/chat', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      model: 'llama3.2',
      messages: [{ role: 'user', content: req.body.question }],
      stream: true,
    }),
  });

  const decoder = new TextDecoder();
  let buffer = '';
  for await (const chunk of ai.body) {
    buffer += decoder.decode(chunk, { stream: true });
    const lines = buffer.split('n');
    buffer = lines.pop();
    for (const line of lines) {
      if (!line.trim()) continue;
      const part = JSON.parse(line);
      // har tukda browser ko bhejo
      res.write(`data: ${JSON.stringify({ text: part.message.content })}nn`);
    }
  }
  res.write('data: [DONE]nn');
  res.end();
});

app.listen(3000, () => console.log('http://localhost:3000'));

SSE format

  • Header Content-Type: text/event-stream – browser को बताता है कि यह stream है
  • हर message: data: <text> और उसके बाद एक खाली line (nn)
  • आख़िर में data: [DONE] – ताकि browser को पता चले कि जवाब पूरा हुआ

5. Browser Ka Page

public/index.html बनाइए – express.static('public') इसी folder को serve करता है (Express Static Files में विस्तार से):

<!doctype html>
<meta charset="utf-8">
<title>Mera AI Chat</title>
<form id="f">
  <input id="q" placeholder="Kuch poochiye..." size="40">
  <button>Poochho</button>
</form>
<p id="answer" style="white-space: pre-wrap"></p>
<script>
document.getElementById('f').onsubmit = async (e) => {
  e.preventDefault();
  const answer = document.getElementById('answer');
  answer.textContent = '';

  const res = await fetch('/api/ask', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ question: document.getElementById('q').value }),
  });

  const reader = res.body.getReader();
  const decoder = new TextDecoder();
  let buffer = '';
  while (true) {
    const { done, value } = await reader.read();
    if (done) break;
    buffer += decoder.decode(value, { stream: true });
    const events = buffer.split('nn');
    buffer = events.pop();
    for (const ev of events) {
      const data = ev.replace(/^data: /, '');
      if (data === '[DONE]') return;
      answer.textContent += JSON.parse(data).text;
    }
  }
};
</script>

node server.js चलाइए और browser में http://localhost:3000 खोलिए। कुछ पूछिए – जवाब word-by-word आएगा। ✨

Browser में भी वही buffer वाला तरीका है – फ़र्क सिर्फ़ इतना कि यहाँ events nn से अलग होते हैं।

Note: Browser का अपना EventSource सिर्फ़ GET request करता है। हमें सवाल POST में भेजना था, इसलिए fetch और getReader() use किया।

SSE ya WebSockets? SSE एक तरफ़ा है – server से browser। AI के जवाब के लिए यही काफ़ी और आसान है। दोनों तरफ़ लगातार बातचीत चाहिए (जैसे live chat जिसमें कई users हों), तो WebSockets और Socket.io देखिए।

6. Server Ko curl Se Check Karna

Browser से पहले server को अकेले जाँचना अच्छी आदत है:

curl -N -X POST localhost:3000/api/ask -H "Content-Type: application/json" -d "{"question":"Docker 1 line mein"}"

हमारे यहाँ यह आया – हर token अपना event:

data: {"text":"D"}

data: {"text":"ocker"}

data: {"text":" ek"}

7. Common Mistakes

  • Har chunk ko seedha JSON.parse – अधूरी line पर crash। Buffer रखिए।
  • res.json() use karna – वो पूरा response एक बार में भेजकर बंद कर देता है। Streaming में res.write() और आख़िर में res.end()।
  • nn bhoolna – SSE में हर event के बाद खाली line ज़रूरी है, वरना browser इंतज़ार करता रहेगा।
  • Text ko seedha data: mein likhna – जवाब में newline हो तो event टूट जाता है। इसलिए हम JSON.stringify({ text }) भेजते हैं।
  • Nginx ke peeche stream atakna – production में proxy buffering बंद करनी पड़ सकती है (X-Accel-Buffering: no header)। Server को production में चलाने के लिए Docker से Node.js App Deploy पढ़िए।

📌 Cheat sheets: Series का सारा code एक जगह – AI Engineering Code Cheat Sheet।

Conclusion

Streaming जवाब को तेज़ नहीं बनाती, लेकिन तेज़ महसूस कराती है – और user experience में यही मायने रखता है। आपने सीखा: NDJSON पढ़ना, अधूरी lines संभालना, SSE से browser तक भेजना, और browser में दिखाना।

अगले post से AI Engineering का सबसे मज़ेदार हिस्सा शुरू होता है – embeddings, यानी शब्दों से नहीं, मतलब से search। Part 6 पढ़िए → (21 Nov को आएगा) 🚀

Author at The Easy Master.

Related posts

Prompt Engineering Cheat Sheet in Hindi: Complete Guide

The tutorial teaches it; the cheat sheet is for when you just need reminding.

Leave a Reply

Your email address will not be published. Required fields are marked *