NodeJS SDK ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ GoogleGenerativeAI "ਸਰੋਤ ਖਤਮ" ਗਲਤੀ ਨੂੰ ਕਿਵੇਂ ਡੀਬੱਗ ਕਰਨਾ ਹੈ

GoogleGenerativeAI ਬੇਨਤੀਆਂ ਲਈ "ਸਰੋਤ ਖਤਮ" ਗਲਤੀ ਦਾ ਨਿਪਟਾਰਾ ਕਿਵੇਂ ਕਰੀਏ

Google Generative AI SDK ਨਾਲ Node.js ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਬੈਕਐਂਡ ਸਕ੍ਰਿਪਟ

// Import the Google Generative AI client library
const { GoogleAuth } = require('google-auth-library');
const { GoogleGenerativeAI } = require('google-generative-ai');
// Initialize client with API key and set authentication
const googleAiClient = new GoogleGenerativeAI();
googleAiClient.apiKey = 'YOUR_API_KEY';
// Function to generate content with error handling
async function generateContent(prompt) {
  try {
    // Retrieve model and execute completion request
    const model = googleAiClient.getGenerativeModel({ model: 'gemini-1.5-flash' });
    const result = await model.generateContent(prompt);
    return result.data;  // Return response on success
  } catch (error) {
    if (error.response && error.response.status === 429) {
      console.error("Quota limit reached, retry after some time.");
    } else {
      console.error("Error generating content:", error.message);
    }
  }
}
// Example prompt and function call
generateContent('Your AI prompt here').then(console.log).catch(console.error);

ਵਿਕਲਪਕ ਹੱਲ: ਐਕਸਪੋਨੈਂਸ਼ੀਅਲ ਬੈਕਆਫ ਨਾਲ ਬੇਨਤੀਆਂ ਦੀ ਮੁੜ ਕੋਸ਼ਿਸ਼ ਕਰਨਾ

ਮੁੜ ਕੋਸ਼ਿਸ਼ ਤਰਕ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਐਨਹਾਂਸਡ Node.js ਸਕ੍ਰਿਪਟ

// Import required libraries and set up Google Generative AI client
const { GoogleGenerativeAI } = require('google-generative-ai');
const googleAiClient = new GoogleGenerativeAI();
googleAiClient.apiKey = 'YOUR_API_KEY';
// Function to handle exponential backoff for retrying requests
async function generateContentWithRetry(prompt, retries = 5) {
  let delay = 1000;  // Initial delay of 1 second
  for (let i = 0; i < retries; i++) {
    try {
      const model = googleAiClient.getGenerativeModel({ model: 'gemini-1.5-flash' });
      const result = await model.generateContent(prompt);
      return result.data;
    } catch (error) {
      if (error.response && error.response.status === 429) {
        console.warn(\`Attempt \${i + 1} failed due to quota limits. Retrying in \${delay} ms...\`);
        await new Promise(resolve => setTimeout(resolve, delay));
        delay *= 2;  // Exponentially increase delay
      } else {
        console.error("Unhandled error:", error.message);
        break;
      }
    }
  }
  throw new Error("All retries failed due to quota limitations.");
}
// Call the function and handle output or errors
generateContentWithRetry('Your AI prompt here').then(console.log).catch(console.error);

ਮੌਕ ਕੋਟਾ ਥਕਾਵਟ ਗਲਤੀ ਦੇ ਨਾਲ ਟੈਸਟਿੰਗ ਕੋਡ

ਜੈਸਟ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਮੁੜ ਕੋਸ਼ਿਸ਼ ਵਿਧੀ ਲਈ ਯੂਨਿਟ ਟੈਸਟ

// Import required modules and mock response
const { generateContentWithRetry } = require('./yourModule');
const axios = require('axios');
jest.mock('axios');
describe("generateContentWithRetry", () => {
  it("should retry on 429 errors and eventually succeed", async () => {
    axios.get.mockRejectedValueOnce({ response: { status: 429 } });
    axios.get.mockResolvedValue({ data: "Success after retries!" });
    const result = await generateContentWithRetry('Test Prompt');
    expect(result).toBe("Success after retries!");
  });
  it("should throw an error after max retries", async () => {
    axios.get.mockRejectedValue({ response: { status: 429 } });
    await expect(generateContentWithRetry('Test Prompt')).rejects.toThrow("All retries failed due to quota limitations.");
  });
});

ਗੂਗਲ ਜਨਰੇਟਿਵ AI ਕੋਟਾ ਮੁੱਦਿਆਂ ਨੂੰ ਡੀਬੱਗ ਕਰਨ 'ਤੇ ਅਕਸਰ ਪੁੱਛੇ ਜਾਂਦੇ ਸਵਾਲ

1. ਗੂਗਲ ਜਨਰੇਟਿਵ ਏਆਈ ਵਿੱਚ "ਸਰੋਤ ਖਤਮ" ਗਲਤੀ ਦਾ ਕੀ ਅਰਥ ਹੈ?
2. ਇਹ ਤਰੁੱਟੀ ਆਮ ਤੌਰ 'ਤੇ ਇਹ ਦਰਸਾਉਂਦੀ ਹੈ ਕਿ ਤੁਹਾਡੀਆਂ API ਬੇਨਤੀਆਂ ਵੱਧ ਗਈਆਂ ਹਨ quota Google ਦੁਆਰਾ ਨਿਰਧਾਰਤ ਸੀਮਾਵਾਂ। ਇਹ ਹੋ ਸਕਦਾ ਹੈ ਭਾਵੇਂ ਬਿਲਿੰਗ ਸਮਰੱਥ ਹੋਵੇ।
3. ਮੈਂ Google Generative AI ਲਈ ਆਪਣੇ API ਕੋਟੇ ਦੀ ਜਾਂਚ ਕਿਵੇਂ ਕਰ ਸਕਦਾ ਹਾਂ?
4. Google Cloud Console 'ਤੇ ਜਾਓ ਅਤੇ "APIs ਅਤੇ ਸੇਵਾਵਾਂ" ਸੈਕਸ਼ਨ 'ਤੇ ਜਾਓ, ਜਿੱਥੇ ਤੁਸੀਂ Google Generative AI ਸਮੇਤ ਹਰੇਕ API ਲਈ ਆਪਣੀ ਵਰਤੋਂ ਅਤੇ ਕੋਟੇ ਤੱਕ ਪਹੁੰਚ ਕਰ ਸਕਦੇ ਹੋ।
5. ਮੈਨੂੰ ਇੱਕ ਅਦਾਇਗੀ ਯੋਜਨਾ ਦੇ ਨਾਲ ਇੱਕ 429 ਗਲਤੀ ਕਿਉਂ ਮਿਲ ਰਹੀ ਹੈ?
6. 429 HTTP ਸਥਿਤੀ ਕੋਡ ਦਾ ਮਤਲਬ ਹੈ "ਬਹੁਤ ਜ਼ਿਆਦਾ ਬੇਨਤੀਆਂ।" ਇਹ ਉਦੋਂ ਹੋ ਸਕਦਾ ਹੈ ਜਦੋਂ ਖਾਸ ਪ੍ਰਤੀ-ਮਿੰਟ ਜਾਂ ਪ੍ਰਤੀ-ਦਿਨ ਕੋਟਾ ਪੂਰਾ ਹੋ ਜਾਂਦਾ ਹੈ, ਭਾਵੇਂ ਅਦਾਇਗੀ ਯੋਜਨਾਵਾਂ 'ਤੇ ਵੀ। ਕੋਟਾ ਪੰਨੇ ਦੀ ਜਾਂਚ ਕਰਨ ਅਤੇ ਜੇ ਲੋੜ ਹੋਵੇ ਤਾਂ ਸੈਟਿੰਗਾਂ ਨੂੰ ਵਿਵਸਥਿਤ ਕਰਨ 'ਤੇ ਵਿਚਾਰ ਕਰੋ।
7. ਮੈਂ ਗੂਗਲ ਜਨਰੇਟਿਵ ਏਆਈ ਬੇਨਤੀਆਂ ਲਈ ਘਾਤਕ ਬੈਕਆਫ ਕਿਵੇਂ ਲਾਗੂ ਕਰਾਂ?
8. ਤੁਸੀਂ ਇੱਕ ਮੁੜ-ਕੋਸ਼ਿਸ਼ ਰਣਨੀਤੀ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ ਜੋ ਹਰੇਕ ਕੋਸ਼ਿਸ਼ ਦੇ ਵਿਚਕਾਰ ਦੇਰੀ ਨੂੰ ਵਧਾਉਂਦੀ ਹੈ, ਜਿਵੇਂ ਕਿ ਹਰੇਕ ਕੋਸ਼ਿਸ਼ ਤੋਂ ਪਹਿਲਾਂ ਸਮਾਂ ਦੁੱਗਣਾ ਕਰਨਾ। ਉਦਾਹਰਨ ਲਈ, 1-ਸਕਿੰਟ ਦੀ ਦੇਰੀ ਨਾਲ ਸ਼ੁਰੂ ਕਰੋ, ਅਤੇ ਫਿਰ ਹਰੇਕ ਅਗਲੀ ਮੁੜ ਕੋਸ਼ਿਸ਼ ਲਈ 2, 4, ਅਤੇ 8 ਸਕਿੰਟ ਉਡੀਕ ਕਰੋ।
9. ਜੇਕਰ ਮੇਰੀ ਅਰਜ਼ੀ ਨੂੰ ਉੱਚ ਕੋਟੇ ਦੀ ਲੋੜ ਹੈ ਤਾਂ ਮੈਨੂੰ ਕੀ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ?
10. Google ਕਲਾਉਡ ਕੰਸੋਲ ਵਿੱਚ, ਤੁਸੀਂ ਇੱਕ ਫਾਰਮ ਸਪੁਰਦ ਕਰਕੇ ਜਾਂ ਸਿੱਧੇ Google ਸਹਾਇਤਾ ਨਾਲ ਸੰਪਰਕ ਕਰਕੇ ਆਪਣੇ ਕੋਟੇ ਵਿੱਚ ਵਾਧੇ ਦੀ ਬੇਨਤੀ ਕਰ ਸਕਦੇ ਹੋ, ਖਾਸ ਤੌਰ 'ਤੇ ਜੇਕਰ ਤੁਹਾਡੇ ਪ੍ਰੋਜੈਕਟ ਦੀਆਂ ਉੱਚ ਵਰਤੋਂ ਦੀਆਂ ਮੰਗਾਂ ਹਨ।
11. ਕੀ ਮੈਂ ਅਸਲ ਸਮੇਂ ਵਿੱਚ ਕੋਟੇ ਦੀ ਵਰਤੋਂ ਦੀ ਨਿਗਰਾਨੀ ਕਰ ਸਕਦਾ ਹਾਂ?
12. ਹਾਂ, ਗੂਗਲ ਕਲਾਉਡ ਦੇ ਨਿਗਰਾਨੀ ਸਾਧਨ ਤੁਹਾਨੂੰ ਅਲਰਟ ਸੈਟ ਅਪ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦੇ ਹਨ ਜੋ ਤੁਹਾਨੂੰ ਸੂਚਿਤ ਕਰਦੇ ਹਨ ਜਦੋਂ ਕੋਟਾ ਵਰਤੋਂ ਇੱਕ ਨਿਸ਼ਚਿਤ ਥ੍ਰੈਸ਼ਹੋਲਡ ਤੱਕ ਪਹੁੰਚ ਜਾਂਦੀ ਹੈ।
13. ਗੂਗਲ ਜਨਰੇਟਿਵ ਏਆਈ ਨਾਲ ਕੈਚ ਕਰਨ ਦਾ ਕੀ ਮਕਸਦ ਹੈ?
14. ਕੈਚਿੰਗ ਤੁਹਾਨੂੰ ਅਕਸਰ ਬੇਨਤੀ ਕੀਤੇ ਜਵਾਬਾਂ ਨੂੰ ਅਸਥਾਈ ਤੌਰ 'ਤੇ ਸਟੋਰ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦੀ ਹੈ, API ਕਾਲਾਂ ਦੀ ਗਿਣਤੀ ਨੂੰ ਘਟਾਉਂਦੀ ਹੈ ਅਤੇ ਇਸਲਈ ਕੋਟੇ ਦੀ ਖਪਤ ਨੂੰ ਘੱਟ ਕਰਦੀ ਹੈ।
15. ਕੀ ਬੈਚਿੰਗ ਲਾਗੂ ਕਰਨ ਨਾਲ ਕੋਟੇ ਦੀ ਵਰਤੋਂ ਘਟਦੀ ਹੈ?
16. ਹਾਂ, ਬੈਚਿੰਗ ਬੇਨਤੀਆਂ ਇੱਕ API ਕਾਲ ਵਿੱਚ ਮਲਟੀਪਲ ਪ੍ਰੋਂਪਟਾਂ ਨੂੰ ਸਮੂਹਿਕ ਕਰਕੇ ਸਰੋਤ ਵਰਤੋਂ ਨੂੰ ਅਨੁਕੂਲਿਤ ਕਰ ਸਕਦੀਆਂ ਹਨ, ਖਾਸ ਕਰਕੇ ਜੇਕਰ ਇੱਕੋ ਜਿਹੀਆਂ ਪੁੱਛਗਿੱਛਾਂ ਅਕਸਰ ਕੀਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ।
17. ਮੈਂ ਔਫ-ਪੀਕ ਸਮਿਆਂ ਲਈ ਆਪਣੀ API ਵਰਤੋਂ ਨੂੰ ਕਿਵੇਂ ਅਨੁਕੂਲ ਬਣਾ ਸਕਦਾ ਹਾਂ?
18. ਆਫ-ਪੀਕ ਘੰਟਿਆਂ ਦੌਰਾਨ ਗੈਰ-ਜ਼ਰੂਰੀ ਬੇਨਤੀਆਂ ਨੂੰ ਤਹਿ ਕਰਕੇ, ਤੁਸੀਂ ਲੋਡ ਨੂੰ ਬਰਾਬਰ ਵੰਡ ਸਕਦੇ ਹੋ ਅਤੇ ਪੀਕ ਸਮੇਂ ਦੌਰਾਨ ਵਰਤੋਂ ਦੀਆਂ ਸੀਮਾਵਾਂ ਨੂੰ ਦਬਾਉਣ ਤੋਂ ਬਚ ਸਕਦੇ ਹੋ।
19. ਜੇਕਰ ਮੈਂ ਕੋਟਾ ਸੀਮਾਵਾਂ ਤੋਂ ਵੱਧ ਜਾਂਦਾ ਹਾਂ ਤਾਂ ਕਿਹੜੇ ਵਿਕਲਪ ਉਪਲਬਧ ਹਨ?
20. ਜੇਕਰ ਤੁਹਾਡੇ ਪ੍ਰੋਜੈਕਟ ਨੂੰ ਅਜੇ ਵੀ ਹੋਰ ਸਰੋਤਾਂ ਦੀ ਲੋੜ ਹੈ, ਤਾਂ ਤੁਸੀਂ ਵੱਖ-ਵੱਖ ਮਾਡਲਾਂ ਜਾਂ API ਅੰਤਮ ਬਿੰਦੂਆਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਪੜਚੋਲ ਕਰ ਸਕਦੇ ਹੋ ਜਿਨ੍ਹਾਂ ਕੋਲ Google Generative AI ਦੇ ਅੰਦਰ ਉੱਚ ਸਮਰੱਥਾ ਵਾਲੇ ਵਿਕਲਪ ਹਨ।

ਗੂਗਲ ਜਨਰੇਟਿਵ AI ਕੋਟਾ ਗਲਤੀਆਂ ਦੇ ਪ੍ਰਬੰਧਨ ਲਈ ਮੁੱਖ ਉਪਾਅ

ਭਰੋਸੇਯੋਗ API ਪਰਸਪਰ ਕ੍ਰਿਆਵਾਂ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਕੋਟਾ ਥਕਾਵਟ ਦੀਆਂ ਗਲਤੀਆਂ ਨੂੰ ਡੀਬੱਗ ਕਰਨਾ ਜ਼ਰੂਰੀ ਹੈ। Google ਕਲਾਉਡ ਕੰਸੋਲ ਵਿੱਚ ਕੋਟਾ ਸੀਮਾਵਾਂ ਦੀ ਨਿਗਰਾਨੀ ਕਰਨ, ਚੇਤਾਵਨੀਆਂ ਨੂੰ ਸੈੱਟ ਕਰਨ ਅਤੇ ਬੇਨਤੀਆਂ ਨੂੰ ਅਨੁਕੂਲ ਬਣਾਉਣ ਦੁਆਰਾ, ਡਿਵੈਲਪਰ ਸਰਗਰਮੀ ਨਾਲ "ਸਰੋਤ ਥੱਕੇ" ਮੁੱਦਿਆਂ ਨੂੰ ਹੱਲ ਕਰ ਸਕਦੇ ਹਨ ਅਤੇ ਆਪਣੀ ਐਪਲੀਕੇਸ਼ਨ ਦੀ ਕਾਰਗੁਜ਼ਾਰੀ ਨੂੰ ਵਧਾ ਸਕਦੇ ਹਨ।

ਵਾਧੂ ਅਭਿਆਸਾਂ ਜਿਵੇਂ ਕਿ ਤਰਕ ਦੀ ਮੁੜ ਕੋਸ਼ਿਸ਼ ਕਰੋ, ਬੈਚਿੰਗ ਦੀ ਬੇਨਤੀ ਕਰੋ, ਅਤੇ ਅਕਸਰ ਵਰਤੇ ਜਾਂਦੇ ਕੈਚਿੰਗ ਸਰੋਤ ਵਰਤੋਂ ਨੂੰ ਹੋਰ ਅਨੁਕੂਲ ਬਣਾਉਂਦੇ ਹਨ। ਇਕੱਠੇ ਮਿਲ ਕੇ, ਇਹ ਰਣਨੀਤੀਆਂ ਡਿਵੈਲਪਰਾਂ ਨੂੰ ਕੋਟਾ-ਸੰਬੰਧੀ ਤਰੁੱਟੀਆਂ ਨੂੰ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਢੰਗ ਨਾਲ ਦੂਰ ਕਰਨ, ਐਪਲੀਕੇਸ਼ਨਾਂ ਨੂੰ ਸਥਿਰ ਰੱਖਣ ਅਤੇ ਬਿਨਾਂ ਕਿਸੇ ਰੁਕਾਵਟ ਦੇ ਚੱਲਣ ਲਈ ਸਮਰੱਥ ਬਣਾਉਂਦੀਆਂ ਹਨ। 🚀