Handling retrieval failures gracefully in Agentic AI

Introduction

Sometimes, when an AI tries to get information, it might fail. Handling these failures nicely helps the AI keep working without crashing or giving wrong answers.

When an AI agent asks a database for information but the data is missing.

When a chatbot tries to fetch user details but the connection is lost.

When a recommendation system cannot find matching items for a user.

When an AI assistant calls an external API that is temporarily down.

When a search engine returns no results for a query.

Syntax

Agentic AI

class RetrievalHandler:
    def __init__(self, data_source):
        self.data_source = data_source

    def get_data(self, key):
        try:
            result = self.data_source.retrieve(key)
            if result is None:
                return self.handle_failure(key)
            return result
        except Exception as error:
            return self.handle_failure(key, error)

    def handle_failure(self, key, error=None):
        if error:
            print(f"Error retrieving {key}: {error}")
        else:
            print(f"No data found for {key}")
        # Return a safe default or message
        return "Data not available"

This class tries to get data and catches errors or missing data.

The handle_failure method manages what happens when retrieval fails.

Examples

Normal case: data exists and is returned.

Agentic AI

class DummyDataSource:
    def retrieve(self, key):
        data = {"name": "Alice", "age": 30}
        return data.get(key)

handler = RetrievalHandler(DummyDataSource())
print(handler.get_data("name"))  # Returns 'Alice'

Missing key: returns 'Data not available' and prints a message.

Agentic AI

print(handler.get_data("address"))  # Key missing, triggers graceful failure

Error case: retrieval raises exception, handled without crash.

Agentic AI

class ErrorDataSource:
    def retrieve(self, key):
        raise RuntimeError("Connection lost")

error_handler = RetrievalHandler(ErrorDataSource())
print(error_handler.get_data("name"))  # Handles exception gracefully

Sample Model

This program shows how to handle missing data and errors when retrieving information from different sources.

Agentic AI

class RetrievalHandler:
    def __init__(self, data_source):
        self.data_source = data_source

    def get_data(self, key):
        try:
            result = self.data_source.retrieve(key)
            if result is None:
                return self.handle_failure(key)
            return result
        except Exception as error:
            return self.handle_failure(key, error)

    def handle_failure(self, key, error=None):
        if error:
            print(f"Error retrieving {key}: {error}")
        else:
            print(f"No data found for {key}")
        return "Data not available"

class DummyDataSource:
    def __init__(self):
        self.data = {"name": "Alice", "age": 30}

    def retrieve(self, key):
        return self.data.get(key)

class ErrorDataSource:
    def retrieve(self, key):
        raise RuntimeError("Connection lost")

print("-- Using DummyDataSource --")
dummy_handler = RetrievalHandler(DummyDataSource())
print("Name:", dummy_handler.get_data("name"))
print("Address:", dummy_handler.get_data("address"))

print("\n-- Using ErrorDataSource --")
error_handler = RetrievalHandler(ErrorDataSource())
print("Name:", error_handler.get_data("name"))

Important Notes

Time complexity depends on the data source retrieval method, usually O(1) for dictionary lookups.

Space complexity is minimal, just storing references to data sources and keys.

Common mistake: not catching exceptions, which can crash the program.

Use graceful failure handling to keep AI systems stable and user-friendly.

Summary

Always prepare for missing or error data when retrieving information.

Use try-except blocks and check for None to handle failures.

Return safe default values to keep your AI working smoothly.

Practice

1. Why is it important to handle retrieval failures gracefully in agentic AI systems?

easy

A. To keep the AI running smoothly without crashing

B. To make the AI run faster

C. To increase the size of the data retrieved

D. To avoid using any default values

Solution

1. Step 1: Understand retrieval failures

   Retrieval failures happen when the AI cannot get the needed data, which can cause errors.

2. Step 2: Importance of graceful handling

   Handling failures gracefully means preventing crashes and keeping the AI working by managing errors properly.

3. Final Answer:

   To keep the AI running smoothly without crashing -> Option A

4. Quick Check:

   Graceful failure handling = prevent crashes [OK]

Hint: Think about avoiding crashes by handling errors safely [OK]

Common Mistakes:

• Assuming failures speed up the AI
• Ignoring the need for default values
• Believing more data is always retrieved

2. Which Python syntax correctly handles a retrieval failure using try-except?

easy

A. try:
data = retrieve_info()
except Exception:
data = None

B. if data == None:
retrieve_info()
else:
pass

C. try:
data = retrieve_info()
finally:
data = None

D. data = retrieve_info() if data else None

Solution

1. Step 1: Identify try-except usage

   try: data = retrieve_info() except Exception: data = None uses try-except to catch errors during retrieval and sets data to None if an error occurs.

2. Step 2: Check other options for correctness

   Options A, B, and C misuse syntax or logic for error handling.

3. Final Answer:

   try: data = retrieve_info() except Exception: data = None -> Option A

4. Quick Check:

   try-except for errors = try: data = retrieve_info() except Exception: data = None [OK]

Hint: Look for try-except blocks catching exceptions [OK]

Common Mistakes:

• Using if without try-except for errors
• Misusing finally block to handle errors
• Incorrect conditional expressions

3. What will be the output of this code snippet?

def get_data():
    try:
        return None
    except:
        return 'Error'

result = get_data() or 'Default'
print(result)

medium

A. None

B. Default

C. Error

D. Exception

Solution

1. Step 1: Analyze get_data function

   The function returns None without raising an exception, so except block is skipped.

2. Step 2: Evaluate result assignment

   Since get_data() returns None (which is falsey), the expression uses 'Default' instead.

3. Final Answer:

   Default -> Option B

4. Quick Check:

   None or 'Default' = 'Default' [OK]

Hint: Remember None is falsey, so 'or' picks the default [OK]

Common Mistakes:

• Thinking None prints as 'None' string
• Assuming except block runs without error
• Confusing return values with exceptions

4. Identify the error in this code that tries to handle retrieval failure:

def fetch_data():
    try:
        data = retrieve()
    except:
        data = None
    return data

result = fetch_data()
print(result)

medium

A. Data variable is not defined

B. Missing parentheses in retrieve call

C. No return statement in function

D. No specific exception caught in except block

Solution

1. Step 1: Check function structure

   The function calls retrieve() correctly and returns data, so no missing parentheses or return issues.

2. Step 2: Analyze except block

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

3. Final Answer:

   No specific exception caught in except block -> Option D

4. Quick Check:

   Use specific exceptions, not bare except [OK]

Hint: Avoid bare except; specify exceptions to catch [OK]

Common Mistakes:

• Thinking missing parentheses cause error
• Ignoring importance of specific exceptions
• Assuming data is undefined

5. You want your AI agent to retrieve user info but return a safe default if retrieval fails. Which approach is best?

def get_user_info(user_id):
    try:
        info = retrieve_user(user_id)
        if info is None:
            return {'name': 'Guest', 'id': 0}
        return info
    except RetrievalError:
        return {'name': 'Guest', 'id': 0}

hard

A. Return None on failure and handle later

B. Raise error immediately without handling

C. Use try-except and return a default dict on failure or missing data

D. Return empty string on failure

Solution

1. Step 1: Understand retrieval and failure cases

   The function tries to get user info, checks if data is missing (None), and handles exceptions.

2. Step 2: Evaluate handling strategy

   Returning a default dictionary for missing or failed retrieval keeps AI stable and predictable.

3. Final Answer:

   Use try-except and return a default dict on failure or missing data -> Option C

4. Quick Check:

   Safe defaults on failure = Use try-except and return a default dict on failure or missing data [OK]

Hint: Return safe defaults inside try-except for smooth AI [OK]

Common Mistakes:

• Returning None and not handling later
• Raising errors without fallback
• Returning empty strings instead of structured defaults