उत्पादन में LLM अनुप्रयोग (RAG + वेक्टर DB + कैशिंग) · पाठ

त्रुटि प्रबंधन और सुदृढ़ता के प्रतिरूप

अपने LLM ऐप्लिकेशन को त्रुटियों के प्रति अधिक सहनशील बनाने के लिए सुदृढ़ त्रुटि प्रबंधन, पुनःप्रयास तंत्र और सर्किट ब्रेकर डिज़ाइन कीजिए।

पाठ 3, कुल 4 में से11 चरण

त्रुटि प्रबंधन और सुदृढ़ता के प्रतिरूप, CoddyKit पर उत्पादन में LLM अनुप्रयोग (RAG + वेक्टर DB + कैशिंग) का एक निःशुल्क पाठ है। यह 4 में से 3वाँ पाठ है। आप नीचे पूरा पाठ निःशुल्क पढ़ सकते हैं—फिर अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर के साथ ब्राउज़र में इसका व्यावहारिक अभ्यास कर सकते हैं। यह उत्पादन में LLM अनुप्रयोग (RAG + वेक्टर DB + कैशिंग) सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। उत्पादन में LLM अनुप्रयोग (RAG + वेक्टर DB + कैशिंग) पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

मजबूत LLM अनुप्रयोग बनाएँ

LLM अनुप्रयोगों, विशेषकर बाहरी APIs के साथ काम करने वाले अनुप्रयोगों को मजबूत होना आवश्यक है!

लचीलापन ऐसे systems बनाने के बारे में है जो crash हुए बिना या उपयोगकर्ता को खराब अनुभव दिए बिना failures से व्यवस्थित रूप से उबर सकें।

इस lesson में हम आपके LLM apps को failures के प्रति अधिक सहनशील बनाने वाले patterns सीखेंगे।

सामान्य विफलताएँ

LLM अनुप्रयोग को किस प्रकार की errors का सामना करना पड़ सकता है?

API की दर सीमाएँ: एक साथ बहुत अधिक requests।
Network समस्याएँ: connection का अस्थायी टूटना।
LLM service की अनुपलब्धता: LLM provider की service बंद है।
खराब LLM responses: model अमान्य JSON लौटाता है या मनगढ़ंत जानकारी देता है।
निर्भरता की विफलताएँ: Vector DB या अन्य services विफल हो जाती हैं।

मानक Try-Catch

बचाव की पहली पंक्ति try-catch blocks का उपयोग करके की जाने वाली मानक error handling है। अपेक्षित error होने पर यह आपके पूरे application को crash होने से रोकती है।

इससे आप error को log कर सकते हैं, उपयोगकर्ता को सूचित कर सकते हैं या fallback का प्रयास कर सकते हैं।

public class Main {
  public static void main(String[] args) {
    try {
      // Simulate an LLM API call that might fail
      callLlmApi();
      System.out.println("API call successful.");
    } catch (Exception e) {
      System.out.println("Error: " + e.getMessage());
      // Log the error, notify user, etc.
    }
  }

  public static void callLlmApi() throws Exception {
    // In a real app, this would make an actual API call
    if (Math.random() < 0.5) { // 50% chance of failure
      throw new RuntimeException("LLM service unavailable.");
    }
  }
}

केवल Catch करना पर्याप्त क्यों नहीं है

कुछ errors अस्थायी होती हैं, अर्थात वे थोड़े समय के लिए होती हैं और दोबारा प्रयास करने पर ठीक हो सकती हैं। थोड़े समय की network समस्या या कुछ क्षणों की rate limit की कल्पना करें।

साधारण try-catch तुरंत विफल हो जाता है। अस्थायी errors के लिए दोबारा प्रयास की व्यवस्था उपयोगकर्ता के हस्तक्षेप के बिना विश्वसनीयता में काफी सुधार कर सकती है।

सरल दोबारा-प्रयास logic

हम दोबारा प्रयास करने वाला एक मूल loop लागू कर सकते हैं। यदि कोई error होती है, तो हम कुछ समय प्रतीक्षा करके फिर प्रयास करते हैं—अधिकतम प्रयासों की संख्या तक।

public class Main {
  public static void main(String[] args) {
    int maxRetries = 3;
    int currentRetry = 0;
    boolean success = false;

    while (currentRetry < maxRetries && !success) {
      try {
        System.out.println("Attempt " + (currentRetry + 1));
        callLlmApi();
        System.out.println("API call successful.");
        success = true;
      } catch (Exception e) {
        System.out.println("Error: " + e.getMessage());
        currentRetry++;
        if (currentRetry < maxRetries) {
          System.out.println("Retrying in 1 second...");
          try { Thread.sleep(1000); } catch (InterruptedException ie) {}
        }
      }
    }
    if (!success) {
      System.out.println("All retries failed.");
    }
  }

  public static void callLlmApi() throws Exception {
    // Simulate an LLM API call with 70% chance of failure
    if (Math.random() < 0.7) {
      throw new RuntimeException("Transient network error.");
    }
  }
}

स्मार्ट दोबारा प्रयास: घातीय विलंब

लगातार समान retry delays किसी संघर्ष कर रही service पर अत्यधिक भार डाल सकते हैं। घातीय विलंब ऐसी रणनीति है जिसमें दोबारा प्रयासों के बीच का विलंब घातीय रूप से बढ़ता है।

इससे दूरस्थ service को recover होने के लिए अधिक समय मिलता है और आपका app requests भेजकर उस पर लगातार भार नहीं डालता।

प्रारंभिक विलंब: 1s
दूसरा विलंब: 2s
तीसरा विलंब: 4s
और इसी तरह...

सर्किट ब्रेकर pattern

यदि कोई service अस्थायी errors का सामना करने के बजाय वास्तव में बंद हो, तो क्या होगा? बार-बार retry करने से केवल resources व्यर्थ होते हैं और failure का पता चलने में देरी होती है।

सर्किट ब्रेकर pattern किसी ऐसी service को बार-बार invoke करने से application को रोकता है जिसके विफल होने की संभावना है। इससे resources बचते हैं और service को recover होने का समय मिलता है।

सर्किट ब्रेकर की अवस्थाएँ

सर्किट ब्रेकर की तीन मुख्य अवस्थाएँ होती हैं:

बंद: संचालन सामान्य रूप से जारी रहता है। यदि त्रुटियाँ एक निश्चित सीमा से अधिक हो जाएँ, तो यह खुली अवस्था में चला जाता है।
खुली: सेवा को आज़माए बिना सभी अनुरोध तुरंत विफल हो जाते हैं। एक समय-सीमा के बाद यह अर्ध-खुली अवस्था में चला जाता है।
अर्ध-खुली: यह जाँचने के लिए कि सेवा ठीक हो गई है या नहीं, सीमित संख्या में अनुरोधों को आगे जाने दिया जाता है। सफल होने पर यह फिर बंद अवस्था में लौट जाता है; अन्यथा वापस खुली अवस्था में चला जाता है।

अटकने वाले अनुरोधों को समय-सीमा से रोकना

LLM API कॉल कभी-कभी अनिश्चित समय तक अटकी रह सकती हैं और ऐसे उत्तर की प्रतीक्षा कर सकती हैं जो कभी आता ही नहीं। इससे संसाधन समाप्त हो सकते हैं और उपयोगकर्ता अनुभव खराब हो सकता है।

अपनी API कॉल के लिए हमेशा समय-सीमाएँ कॉन्फ़िगर करें। इससे यह अधिकतम अवधि निर्धारित होती है, जितनी देर तक आपका अनुप्रयोग हार मानने और त्रुटि उत्पन्न करने से पहले उत्तर की प्रतीक्षा करेगा।

import java.util.concurrent.TimeUnit;

public class Main {
  public static void main(String[] args) {
    long startTime = System.nanoTime();
    long timeoutMillis = 2000; // 2 seconds timeout

    try {
      System.out.println("Calling LLM API with a timeout...");
      callLlmApiWithTimeout(timeoutMillis);
      System.out.println("API call completed successfully.");
    } catch (Exception e) {
      System.out.println("API call failed: " + e.getMessage());
    }

    long endTime = System.nanoTime();
    long duration = TimeUnit.NANOSECONDS.toMillis(endTime - startTime);
    System.out.println("Total duration: " + duration + "ms");
  }

  public static void callLlmApiWithTimeout(long timeoutMillis) throws Exception {
    // Simulate a long-running/hung API call
    long processingTime = 2500; // 2.5 seconds
    if (processingTime > timeoutMillis) {
      throw new RuntimeException("Operation timed out after " + timeoutMillis + "ms");
    }
    try {
      Thread.sleep(processingTime);
    } catch (InterruptedException e) {
      Thread.currentThread().interrupt();
      throw new RuntimeException("API call interrupted.", e);
    }
  }
}

लचीलेपन की जाँच

सिर्फ पुनःप्रयास तंत्र का उपयोग करने के बजाय आपको सर्किट ब्रेकर पैटर्न का उपयोग कब करना चाहिए?

इंटरैक्टिव पाठ में इसका उत्तर दें

पुनरावलोकन: लचीले LLM अनुप्रयोग बनाना

हमने आपके LLM अनुप्रयोगों को त्रुटि-सहिष्णु बनाने के लिए महत्वपूर्ण पैटर्न देखे हैं:

बुनियादी त्रुटि प्रबंधन: तुरंत विफलता को संभालने के लिए try-catch का उपयोग।
पुनःप्रयास तंत्र: अस्थायी त्रुटियों को संभालने के लिए, अक्सर क्रमिक रूप से बढ़ते अंतराल के साथ।
सर्किट ब्रेकर: लगातार विफल हो रही सेवाओं पर अत्यधिक भार पड़ने से रोकने के लिए।
समय-सीमाएँ: अटकी हुई API कॉल और संसाधनों के समाप्त होने से रोकने के लिए आवश्यक।

उत्पादन में उपयोग होने वाली मजबूत LLM प्रणालियों के लिए ये पैटर्न अत्यंत महत्वपूर्ण हैं!

शुरुआत निःशुल्क

एआई शिक्षक के साथ उत्पादन में LLM अनुप्रयोग (RAG + वेक्टर DB + कैशिंग) सीखें — निःशुल्क

अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।

पाठ्यक्रम: 12
पाठ: 48

निःशुल्क सीखना शुरू करें पूरा पाठ्यक्रम देखें

अक्सर पूछे जाने वाले प्रश्न

क्या “त्रुटि प्रबंधन और सुदृढ़ता के प्रतिरूप” पाठ निःशुल्क है?

हाँ—“त्रुटि प्रबंधन और सुदृढ़ता के प्रतिरूप” का पूरा पाठ यहाँ वेब पर निःशुल्क पढ़ा जा सकता है। इंटरैक्टिव अभ्यास (अंतर्निहित कोड संपादक और 24/7 एआई ट्यूटर) करने और उत्पादन में LLM अनुप्रयोग (RAG + वेक्टर DB + कैशिंग) पाठ्यक्रम का बाकी हिस्सा अनलॉक करने के लिए CoddyKit PRO लें। उत्पादन में LLM अनुप्रयोग (RAG + वेक्टर DB + कैशिंग) पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

“त्रुटि प्रबंधन और सुदृढ़ता के प्रतिरूप” में मैं क्या सीखूँगा?

अपने LLM ऐप्लिकेशन को त्रुटियों के प्रति अधिक सहनशील बनाने के लिए सुदृढ़ त्रुटि प्रबंधन, पुनःप्रयास तंत्र और सर्किट ब्रेकर डिज़ाइन कीजिए। आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ उत्पादन में LLM अनुप्रयोग (RAG + वेक्टर DB + कैशिंग) का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।

क्या उत्पादन में LLM अनुप्रयोग (RAG + वेक्टर DB + कैशिंग) शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?

पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर उत्पादन में LLM अनुप्रयोग (RAG + वेक्टर DB + कैशिंग) शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 3वाँ पाठ है।

“त्रुटि प्रबंधन और सुदृढ़ता के प्रतिरूप” पाठ पूरा करने में कितना समय लगता है?

CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।

क्या मैं इस उत्पादन में LLM अनुप्रयोग (RAG + वेक्टर DB + कैशिंग) पाठ में कोड लिख और चला सकता हूँ?

हाँ। हर उत्पादन में LLM अनुप्रयोग (RAG + वेक्टर DB + कैशिंग) पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।

इस पाठ्यक्रम के सभी पाठ

LLM API कुंजियों और संवेदनशील डेटा की सुरक्षा
दर सीमित करना और दुरुपयोग की रोकथाम
त्रुटि प्रबंधन और सुदृढ़ता के प्रतिरूप
प्रॉम्प्ट इंजेक्शन से सुरक्षा

← उत्पादन में LLM अनुप्रयोग (RAG + वेक्टर DB + कैशिंग) पर वापस जाएँ