LLM wrappers in Prompt Engineering / GenAI - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

What is the primary purpose of an LLM wrapper?

Large Language Models (LLMs) are powerful but complex. Why do developers use wrappers around LLMs?

A To simplify interaction by providing easy-to-use functions and manage inputs and outputs

B To increase the size of the LLM model for better accuracy

C To replace the LLM with a smaller model for faster responses

D To convert text data into images for visual processing

💡 Hint

Think about how wrappers help users work with complex tools more easily.

LLM wrappers provide a simple interface to interact with complex language models, handling input formatting, output parsing, and sometimes adding extra features like caching or logging.

❓ Predict Output

intermediate

Output of LLM wrapper prompt formatting

Given this Python code using a simple LLM wrapper, what is the printed output?

Prompt Engineering / GenAI

class SimpleLLMWrapper:
    def __init__(self, model_name):
        self.model_name = model_name
    def generate(self, prompt):
        return f"Model {self.model_name} received: {prompt}"  

wrapper = SimpleLLMWrapper('TestModel')
response = wrapper.generate('Hello world')
print(response)

A Hello world

B Model TestModel received: Hello world

C Model received: TestModel Hello world

D Error: generate method missing return

💡 Hint

Look at how the generate method formats the string.

The generate method returns a string combining the model name and the prompt. The print statement outputs this combined string.

❓ Model Choice

advanced

Choosing the best LLM wrapper for caching responses

You want to build an application that calls an LLM many times with repeated prompts. Which wrapper feature is most important to improve speed?

A A wrapper that disables all logging to save disk space

B A wrapper that increases the model size for better accuracy

C A wrapper that converts text prompts into images before sending

D A wrapper that supports caching previous responses to avoid repeated calls

💡 Hint

Think about how to avoid repeating expensive operations.

Caching stores previous outputs so the wrapper can return them instantly for repeated prompts, reducing API calls and speeding up responses.

❓ Hyperparameter

advanced

Effect of temperature parameter in LLM wrappers

In an LLM wrapper, what does increasing the temperature parameter usually do to the generated text?

A Makes the output more random and creative

B Makes the output shorter and more precise

C Always produces the same output for the same prompt

D Causes the model to ignore the prompt

💡 Hint

Think about randomness and creativity in text generation.

Higher temperature increases randomness, making the model generate more diverse and creative responses, while lower temperature makes output more focused and deterministic.

🔧 Debug

expert

Why does this LLM wrapper code raise a TypeError?

Examine the code below. Why does it raise a AttributeError when calling wrapper.generate(123)?

Prompt Engineering / GenAI

class LLMWrapper:
    def generate(self, prompt: str) -> str:
        return f"Response to: {prompt.upper()}"

wrapper = LLMWrapper()
output = wrapper.generate(123)

A Because the class LLMWrapper is not instantiated properly

B Because the generate method is missing a return statement

C Because 123 is an integer and integers do not have the method <code>upper()</code>

D Because the prompt argument must be a list, not a string

💡 Hint

Check the type of the argument and what methods it supports.

The generate method calls upper() on prompt. Since 123 is an integer, it does not have upper(), causing a AttributeError.