Retry and fallback logic in Agentic AI - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to retry a function call once if it fails.

Agentic AI

try:
    result = perform_task()
except Exception:
    result = [1]()

Drag options to blanks, or click blank then click option'

Aretry_task

Bperform_task

Cfallback_task

Dhandle_error

Attempts:

3 left

💡 Hint

Common Mistakes

Calling a fallback function instead of retrying the main task.

Not retrying the function at all.

The code retries the same function 'perform_task' once after catching an exception.

2fill in blank

medium

Complete the code to fallback to an alternative function if the main task fails.

Agentic AI

try:
    result = main_task()
except Exception:
    result = [1]()

Drag options to blanks, or click blank then click option'

Aalternative_task

Bmain_task

Cretry_task

Dlog_error

Attempts:

3 left

💡 Hint

Common Mistakes

Retrying the main task instead of falling back.

Logging error instead of handling fallback.

On failure, the code falls back to 'alternative_task' as a backup.

3fill in blank

hard

Fix the error in the retry loop to stop after 3 attempts.

Agentic AI

attempts = 0
while attempts < 3:
    try:
        result = task()
        break
    except Exception:
        attempts [1] 1

Drag options to blanks, or click blank then click option'

A+=

B-=

C*=

D/=

Attempts:

3 left

💡 Hint

Common Mistakes

Decreasing the attempts counter causing infinite loop.

Using multiplication or division operators incorrectly.

The attempts counter should increase by 1 each time to limit retries.

4fill in blank

hard

Fill both blanks to implement retry with fallback after 3 failed attempts.

Agentic AI

attempts = 0
while attempts < 3:
    try:
        result = [1]()
        break
    except Exception:
        attempts [2] 1
else:
    result = fallback()

Drag options to blanks, or click blank then click option'

Amain_task

Balternative_task

C+=

D-=

Attempts:

3 left

💡 Hint

Common Mistakes

Using fallback function inside the retry loop.

Decreasing attempts counter causing infinite retries.

The code retries 'main_task' increasing attempts by 1, then falls back after 3 failures.

5fill in blank

hard

Fill all three blanks to log errors, retry twice, then fallback.

Agentic AI

import logging
attempts = 0
while attempts < [1]:
    try:
        result = [2]()
        break
    except Exception as e:
        logging.error(str(e))
        attempts [3] 1
else:
    result = fallback()

Drag options to blanks, or click blank then click option'

A1

B2

C+=

Dmain_task

Attempts:

3 left

💡 Hint

Common Mistakes

Setting retry count to 1 causing only one attempt.

Not logging errors properly.

Using wrong operator to update attempts.

The code retries 'main_task' twice, logs errors, increments attempts, then falls back.

Practice

1.

What is the main purpose of retry logic in an AI system?

easy

A. To replace the task with a different unrelated task

B. To permanently stop a task after the first failure

C. To ignore errors and continue without any checks

D. To try a task multiple times to handle temporary failures

Solution

1. Step 1: Understand retry logic concept

   Retry logic means trying the same task again if it fails temporarily, like retrying a phone call if the line is busy.

2. Step 2: Match retry logic to options

   Only To try a task multiple times to handle temporary failures describes trying multiple times to handle temporary failures, which fits retry logic.

3. Final Answer:

   To try a task multiple times to handle temporary failures -> Option D

4. Quick Check:

   Retry logic = multiple attempts [OK]

Hint: Retry means try again after failure [OK]

Common Mistakes:

• Confusing retry with fallback
• Thinking retry stops after one failure
• Assuming retry changes the task

2.

Which of the following is the correct Python syntax to retry a function fetch_data() up to 3 times?

for _ in range(3):
    try:
        fetch_data()
        break
    except Exception:
        pass

easy

A. for _ in range(3): try: fetch_data() break except Exception: pass

B. for _ in range(3): fetch_data() break except Exception: pass

C. while True: fetch_data() break except Exception: pass

D. for i in range(3): fetch_data() except: break

Solution

1. Step 1: Check syntax for retry loop

   The code uses a for loop to try 3 times, with try-except to catch errors and break if successful.

2. Step 2: Identify correct syntax

   for _ in range(3): try: fetch_data() break except Exception: pass matches the correct Python syntax with try-except inside the loop and break on success.

3. Final Answer:

   for _ in range(3): try: fetch_data() break except Exception: pass -> Option A

4. Quick Check:

   Correct retry loop syntax = for _ in range(3): try: fetch_data() break except Exception: pass [OK]

Hint: Look for try-except inside a for loop with break [OK]

Common Mistakes:

• Missing try-except block
• Incorrect loop syntax
• Using 'except' without 'try'

3.

Consider this code snippet implementing retry and fallback logic:

def get_data():
    for _ in range(2):
        try:
            return fetch_from_primary()
        except Exception:
            pass
    return fetch_from_backup()

If fetch_from_primary() fails both times, what will get_data() return?

medium

A. The result of fetch_from_primary()

B. The result of fetch_from_backup()

C. None

D. An exception is raised

Solution

1. Step 1: Analyze retry attempts

   The function tries fetch_from_primary() twice inside the loop, catching exceptions and continuing if it fails.

2. Step 2: Understand fallback behavior

   If both retries fail, the function calls and returns fetch_from_backup() as a fallback.

3. Final Answer:

   The result of fetch_from_backup() -> Option B

4. Quick Check:

   Retries fail -> fallback used = The result of fetch_from_backup() [OK]

Hint: If retries fail, fallback result is returned [OK]

Common Mistakes:

• Assuming primary always returns result
• Ignoring fallback call
• Thinking exception propagates

4.

Identify the bug in this retry and fallback code snippet:

def get_info():
    for i in range(3):
        try:
            return fetch_data()
        except:
            continue
    return fallback_data()

medium

A. The except block catches all exceptions without specifying type

B. The function returns fallback_data() even if fetch_data() succeeds

C. The except block should raise the exception instead of continue

D. The loop variable i is unused and should be removed

Solution

1. Step 1: Review exception handling

   The except block catches all exceptions without specifying the exception type, which is bad practice and can hide bugs.

2. Step 2: Identify best practice

   It's better to catch specific exceptions to avoid masking unexpected errors.

3. Final Answer:

   The except block catches all exceptions without specifying type -> Option A

4. Quick Check:

   Catch specific exceptions, not all [OK]

Hint: Avoid bare except; specify exception type [OK]

Common Mistakes:

• Using bare except blocks
• Ignoring exception types
• Assuming unused variables cause bugs

5.

You want to design an AI agent that tries to fetch user data from a primary server up to 3 times. If all retries fail, it should fetch from a backup server. Which code snippet correctly implements this retry and fallback logic?

Option A:
for _ in range(3):
    try:
        data = fetch_primary()
    except:
        data = fetch_backup()
        break
Option B:
for _ in range(3):
    try:
        data = fetch_primary()
        break
    except:
        pass
else:
    data = fetch_backup()
Option C:
try:
    data = fetch_primary()
except:
    data = fetch_backup()
Option D:
while True:
    try:
        data = fetch_primary()
        break
    except:
        data = fetch_backup()
        break

hard

A. Retries primary, but fallback runs immediately on first failure

B. No retries, fallback runs immediately on first failure

C. Retries primary 3 times, then fallback if all fail

D. Retries once, fallback runs immediately after first failure

Solution

1. Step 1: Understand retry and fallback requirements

   The agent must retry fetching from primary 3 times, then fallback only if all retries fail.

2. Step 2: Analyze each option's behavior

   Retries primary 3 times, then fallback if all fail uses a for loop with try-except and an else clause that runs fallback only if loop completes without break (all retries failed). This matches requirements.

3. Final Answer:

   Retries primary 3 times, then fallback if all fail -> Option C

4. Quick Check:

   Retry 3 times + fallback after = Retries primary 3 times, then fallback if all fail [OK]

Hint: Use for-else to run fallback after retries fail [OK]

Common Mistakes:

• Running fallback too early
• Not retrying enough times
• Missing else clause for fallback