Error handling and rate limits in Prompt Engineering / GenAI - Deep Dive

Overview - Error handling and rate limits

What is it?

Error handling and rate limits are ways to manage problems and control how often a system is used. Error handling means catching and fixing mistakes or unexpected issues when using AI or machine learning services. Rate limits set a maximum number of requests or actions allowed in a certain time to keep systems stable and fair. Together, they help keep AI services reliable and responsive.

Why it matters

Without error handling, AI systems can crash or give wrong answers, confusing users and wasting resources. Without rate limits, some users might overload the system, making it slow or unavailable for others. This would make AI tools frustrating or impossible to use in real life. Proper error handling and rate limits ensure smooth, fair, and trustworthy AI experiences for everyone.

Where it fits

Before learning this, you should understand basic AI service usage and API requests. After this, you can explore advanced topics like retry strategies, adaptive rate limiting, and monitoring AI system health. This topic connects beginner AI usage with robust, real-world AI system design.

Mental Model

Core Idea

Error handling catches problems so the system can respond safely, while rate limits control usage to keep the system stable and fair.

Think of it like...

It's like a busy coffee shop: error handling is the barista fixing mistakes in orders, and rate limits are the rules that only let a few customers order at once so everyone gets served quickly.

┌───────────────┐       ┌───────────────┐
│   User/API   │──────▶│   AI System   │
└───────────────┘       └───────────────┘
         │                      │
         │  Requests            │
         │                      │
         ▼                      ▼
┌───────────────┐       ┌───────────────┐
│ Rate Limiter  │──────▶│ Error Handler │
└───────────────┘       └───────────────┘
         │                      │
         │ Limits requests      │
         │                      │
         ▼                      ▼
   Allowed or Blocked      Catches & Fixes
       Requests             Problems

Build-Up - 7 Steps

1

Foundation

What is error handling?

Concept: Error handling means detecting and managing problems when they happen.

When you use AI or machine learning, sometimes things go wrong: the system might not understand your request, or it might be busy. Error handling is the way your program notices these problems and responds without crashing. For example, if the AI service says 'I don't understand,' your program can show a friendly message or try again.

Result

Your AI program can keep running smoothly even if something unexpected happens.

Understanding error handling helps you build AI tools that don’t break when faced with real-world problems.

2

Foundation

What are rate limits?

Concept: Rate limits control how many times you can use a service in a set time.

AI services often limit how many requests you can send per minute or hour. This prevents overload and keeps the system fair for everyone. If you send too many requests too fast, the system will stop answering until you slow down. This is called rate limiting.

Result

You learn to respect usage limits so the AI service stays fast and available.

Knowing about rate limits helps you avoid being blocked and keeps your AI app reliable.

3

Intermediate

Common error types in AI services

🤔Before reading on: do you think all errors mean the AI is broken, or can some be temporary or user-caused? Commit to your answer.

Concept: Errors can be caused by many reasons, not just system failure.

Errors include network problems, invalid inputs, server overload, or hitting rate limits. Some errors are temporary, like a busy server, while others need you to fix your request. Understanding error types helps you decide how to respond: retry, fix input, or alert the user.

Result

You can handle errors more smartly, improving user experience.

Knowing error types prevents unnecessary retries and helps you build smarter AI apps.

4

Intermediate

How to implement basic error handling

🤔Before reading on: do you think catching errors means just ignoring them or responding properly? Commit to your answer.

Concept: Error handling means catching errors and responding appropriately.

In your code, use try-catch blocks or similar methods to catch errors from AI calls. Then decide what to do: show a message, retry after a delay, or log the problem. For example, if the AI service returns a 'rate limit exceeded' error, wait before trying again.

Result

Your AI app can recover from errors without crashing or confusing users.

Proper error handling improves reliability and user trust in AI applications.

5

Intermediate

Strategies for managing rate limits

🤔Before reading on: do you think ignoring rate limits will work long-term or cause problems? Commit to your answer.

Concept: You must respect rate limits and manage request timing.

Common strategies include slowing down requests, queuing them, or spreading them evenly over time. Some systems provide headers telling you how many requests remain. Use this info to avoid hitting limits. If you hit a limit, pause and retry later.

Result

Your AI app stays within limits and avoids being blocked.

Managing rate limits proactively keeps AI services responsive and available.

6

Advanced

Exponential backoff for retries

🤔Before reading on: do you think retrying immediately after an error is best, or waiting longer each time? Commit to your answer.

Concept: Exponential backoff means waiting longer between retries to reduce load.

When retrying after errors like rate limits or server busy, wait a short time, then double the wait each retry (e.g., 1s, 2s, 4s). This reduces pressure on the AI system and increases chances of success. Stop retrying after a limit to avoid infinite loops.

Result

Your app retries smartly, balancing speed and system health.

Exponential backoff prevents overwhelming AI services and improves success rates.

7

Expert

Adaptive rate limiting and error handling in production

🤔Before reading on: do you think fixed limits always work best, or can systems adapt dynamically? Commit to your answer.

Concept: Advanced systems adjust limits and error responses based on real-time conditions.

In production, AI services and clients monitor usage and errors continuously. They adapt rate limits based on traffic, user priority, or system health. Error handling can include circuit breakers that stop requests temporarily if errors spike. These techniques keep AI systems stable under heavy or unpredictable load.

Result

AI services remain reliable and fair even at large scale and high demand.

Adaptive controls are key to building resilient, scalable AI systems in the real world.

Under the Hood

When you send a request to an AI service, it checks if you have exceeded your allowed number of requests (rate limit). If yes, it returns a specific error code. If the request has problems (bad input, server issues), the service returns error messages. Your program must detect these responses and decide how to act. Internally, rate limiting often uses counters and timers per user or API key to track usage.

Why designed this way?

Rate limits protect shared AI resources from overload and abuse, ensuring fair access. Error handling is designed to keep programs running smoothly despite unpredictable network or system issues. Alternatives like no limits or ignoring errors would cause crashes, slowdowns, or unfair service. This design balances usability, fairness, and stability.

┌───────────────┐
│ User Request  │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ Rate Limiter  │───┐
└──────┬────────┘   │
       │ Allowed     │
       ▼            │
┌───────────────┐   │
│ AI Processing │   │
└──────┬────────┘   │
       │ Success     │
       ▼            │
┌───────────────┐   │
│ Response      │◀──┘
└───────────────┘
       │
       ▼
┌───────────────┐
│ Error Handler │
└───────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Do you think hitting a rate limit means your program is broken? Commit to yes or no.

Common Belief: If you hit a rate limit, your program must be broken or doing something wrong.

Reality: Hitting a rate limit is a normal response to protect the system and means you need to slow down or wait.

Why it matters: Treating rate limits as bugs can lead to frustration and wasted effort; proper handling keeps your app working smoothly.

Quick: Do you think all errors from AI services are permanent failures? Commit to yes or no.

Common Belief: All errors mean the AI service is down or unusable.

Reality: Many errors are temporary or caused by input issues and can be fixed or retried.

Why it matters: Assuming all errors are fatal can cause unnecessary app crashes or poor user experience.

Quick: Do you think ignoring rate limits and retrying immediately is a good idea? Commit to yes or no.

Common Belief: If a request fails due to rate limits, just retry immediately as many times as needed.

Reality: Immediate retries can worsen overload; exponential backoff is needed to reduce pressure and improve success.

Why it matters: Ignoring this leads to cascading failures and longer downtime for everyone.

Quick: Do you think error handling is only about fixing bugs in your code? Commit to yes or no.

Common Belief: Error handling is just about fixing programming mistakes.

Reality: Error handling also manages external issues like network problems, service limits, and unexpected inputs.

Why it matters: Limiting error handling to code bugs misses many real-world problems, reducing app reliability.

Expert Zone

1

Rate limits can be user-specific, IP-based, or global, requiring different handling strategies.

2

Some AI services provide headers with detailed rate limit info, which expert apps use to optimize request timing.

3

Circuit breakers in error handling prevent repeated failing requests from overwhelming systems, a subtle but powerful pattern.

When NOT to use

Avoid relying solely on fixed rate limits or simple retries in high-scale or bursty traffic scenarios. Instead, use adaptive rate limiting, queuing systems, or distributed throttling to handle complex loads.

Production Patterns

In production, teams combine error handling with monitoring and alerting to detect issues early. They implement exponential backoff with jitter to avoid synchronized retries. Rate limits are often integrated with user authentication to prioritize important users.

Connections

Circuit Breaker Pattern

Builds-on error handling by stopping repeated failing calls to protect systems.

Understanding error handling helps grasp how circuit breakers prevent cascading failures in distributed AI services.

Traffic Shaping in Networks

Similar to rate limiting, it controls data flow to avoid congestion.

Knowing rate limits in AI APIs connects to how networks manage traffic, showing shared principles of fairness and stability.

Human Attention Management

Opposite concept: humans limit their focus to avoid overload, like rate limits control system load.

Seeing rate limits as a form of managing limited resources helps understand why limits improve overall system health.

Common Pitfalls

#1 Ignoring rate limit errors and retrying immediately causes system overload.

Wrong approach:

while True:
response = call_ai_api()
if response.error == 'rate_limit':
continue # retry immediately without delay

Correct approach:

retry_delay = 1
max_retries = 5
for _ in range(max_retries):
response = call_ai_api()
if response.error == 'rate_limit':
time.sleep(retry_delay)
retry_delay *= 2 # exponential backoff
else:
break

Root cause:

Misunderstanding that immediate retries worsen rate limit issues instead of respecting system capacity.

#2 Treating all errors as fatal and stopping the program abruptly.

Wrong approach:

response = call_ai_api()
if response.error:
raise Exception('AI call failed') # no recovery or user feedback

Correct approach:

response = call_ai_api()
if response.error:
if response.error == 'temporary':
retry_with_backoff()
else:
show_user_message('Please check your input or try later')

Root cause:

Failing to distinguish error types and handle them appropriately.

#3 Not checking rate limit headers and blindly sending requests.

Wrong approach:

for i in range(1000):
call_ai_api() # no rate limit awareness

Correct approach:

remaining = get_rate_limit_remaining()
if remaining > 0:
call_ai_api()
else:
wait_until_reset()

Root cause:

Ignoring available information leads to hitting limits unnecessarily.

Key Takeaways

Error handling and rate limits are essential to keep AI systems reliable and fair.

Proper error handling means detecting problems and responding smartly, not just crashing.

Rate limits protect shared AI resources by controlling how often users can send requests.

Using strategies like exponential backoff helps your app retry safely without overwhelming the system.

Advanced AI systems adapt rate limits and error handling dynamically to stay stable under heavy use.

Practice

1. What is the main purpose of using error handling in AI applications?

easy

A. To keep the app running smoothly even when problems happen

B. To speed up the AI model training process

C. To increase the number of requests sent to the server

D. To reduce the size of the AI model

Solution

1. Step 1: Understand error handling purpose

   Error handling is used to manage unexpected problems during app execution.

2. Step 2: Connect to AI app context

   In AI apps, error handling helps keep the app running smoothly despite issues.

3. Final Answer:

   To keep the app running smoothly even when problems happen -> Option A

4. Quick Check:

   Error handling = keep app running smoothly [OK]

Hint: Error handling means catching problems to avoid crashes [OK]

Common Mistakes:

• Thinking error handling speeds up training
• Confusing error handling with increasing requests
• Believing error handling reduces model size

2. Which Python syntax correctly catches an error when calling an AI API?

easy

A. try:
response = call_api()
except:
print('Error occurred')

B. catch:
response = call_api()
try:
print('Error occurred')

C. if error:
response = call_api()
else:
print('Error occurred')

D. error handling:
response = call_api()
except:
print('Error occurred')

Solution

1. Step 1: Identify correct try-except syntax

   Python uses try: block followed by except: to catch errors.

2. Step 2: Match syntax with options

   try: response = call_api() except: print('Error occurred') uses correct try-except structure; others use invalid keywords.

3. Final Answer:

   try:\n response = call_api()\nexcept:\n print('Error occurred') -> Option A

4. Quick Check:

   try-except syntax = try: response = call_api() except: print('Error occurred') [OK]

Hint: Remember Python uses try: and except: blocks [OK]

Common Mistakes:

• Using catch instead of except
• Using if error instead of try-except
• Writing invalid keywords like error handling:

3. What will the following Python code print if the API returns a rate limit error?

import time

try:
    response = call_api()
except RateLimitError:
    print('Rate limit hit, waiting...')
    time.sleep(10)
    response = call_api()
print('Done')

medium

A. Error: RateLimitError not caught

B. Done

C. Rate limit hit, waiting...

D. Rate limit hit, waiting...\nDone

Solution

1. Step 1: Understand try-except with RateLimitError

   If call_api() raises RateLimitError, except block runs printing message and waits 10 seconds.

2. Step 2: After waiting, call_api() runs again and then prints 'Done'

   So output includes the message and 'Done' on separate lines.

3. Final Answer:

   Rate limit hit, waiting...\nDone -> Option D

4. Quick Check:

   RateLimitError caught, message + Done printed [OK]

Hint: Exception caught prints message then continues [OK]

Common Mistakes:

• Assuming no message prints
• Thinking program crashes on rate limit
• Ignoring the second call_api() after sleep

4. Identify the error in this code snippet handling rate limits:

try:
    response = call_api()
except RateLimitError
    print('Too many requests')
    time.sleep(5)
    response = call_api()

medium

A. call_api() should not be retried

B. time.sleep() cannot be used in except block

C. Missing colon after except RateLimitError

D. print statement syntax is incorrect

Solution

1. Step 1: Check except syntax

   Python requires a colon ':' after except RateLimitError to start the block.

2. Step 2: Verify other parts

   time.sleep() is valid, retrying call_api() is allowed, print syntax is correct.

3. Final Answer:

   Missing colon after except RateLimitError -> Option C

4. Quick Check:

   except needs colon ':' [OK]

Hint: except lines always end with a colon ':' [OK]

Common Mistakes:

• Forgetting colon after except
• Thinking sleep() is invalid in except
• Believing retry is not allowed

5. You want to build an AI app that calls an API but respects rate limits by retrying after waiting. Which code snippet correctly implements this with error handling and exponential backoff?

hard

A. import time
wait = 1
for _ in range(3):
try:
response = call_api()
break
except RateLimitError:
time.sleep(wait)
wait *= 2

B. import time
wait = 1
while True:
try:
response = call_api()
break
except RateLimitError:
time.sleep(wait)
wait *= 2

C. import time
wait = 1
for _ in range(3):
try:
response = call_api()
except RateLimitError:
wait *= 2
time.sleep(wait)
else:
break

D. import time
wait = 1
while True:
try:
response = call_api()
except RateLimitError:
time.sleep(wait)
wait += 1
else:
break

Solution

1. Step 1: Understand exponential backoff with retries

   We want to retry after waiting, doubling wait time each failure, and stop on success.

2. Step 2: Analyze options for correct loop and break

   import time wait = 1 while True: try: response = call_api() break except RateLimitError: time.sleep(wait) wait *= 2 uses while True loop, tries call_api(), breaks on success, and doubles wait after RateLimitError.

3. Step 3: Check other options

   import time wait = 1 for _ in range(3): try: response = call_api() break except RateLimitError: time.sleep(wait) wait *= 2 breaks on success but uses for loop with fixed tries (less flexible). import time wait = 1 while True: try: response = call_api() except RateLimitError: time.sleep(wait) wait += 1 else: break increments wait linearly, not exponential. import time wait = 1 for _ in range(3): try: response = call_api() except RateLimitError: wait *= 2 time.sleep(wait) else: break doubles wait before sleep, but order is less clear.

4. Final Answer:

   import time wait = 1 while True: try: response = call_api() break except RateLimitError: time.sleep(wait) wait *= 2 -> Option B

5. Quick Check:

   Retry loop with exponential backoff = import time wait = 1 while True: try: response = call_api() break except RateLimitError: time.sleep(wait) wait *= 2 [OK]

Hint: Use while True with break and double wait after error [OK]

Common Mistakes:

• Using for loop limits retries too strictly
• Incrementing wait linearly instead of doubling
• Not breaking loop on success