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.

Practice

1. What is the main purpose of an LLM wrapper in working with language models?

easy

A. To replace the language model with a simpler algorithm

B. To train the language model from scratch

C. To add extra features like logging and formatting around the model

D. To store large datasets for training

Solution

1. Step 1: Understand what an LLM wrapper does

   An LLM wrapper is a tool that surrounds a language model to add helpful features without changing the model itself.

2. Step 2: Identify the main use of wrappers

   Wrappers add things like logging, formatting, or connecting to other systems to make the model easier to use.

3. Final Answer:

   To add extra features like logging and formatting around the model -> Option C

4. Quick Check:

   LLM wrapper purpose = add features [OK]

Hint: Wrappers add helpers around models, not replace or train them [OK]

Common Mistakes:

• Thinking wrappers train the model
• Confusing wrappers with data storage
• Believing wrappers replace the model

2. Which of the following is the correct way to create a simple LLM wrapper function in Python that adds logging before calling the model's generate method?

easy

A. def wrapper(model, prompt): return print('Calling model', model.generate(prompt))

B. def wrapper(model, prompt): model.generate(prompt); print('Calling model')

C. def wrapper(model, prompt): print('Calling model') model.generate(prompt)

D. def wrapper(model, prompt): print('Calling model'); return model.generate(prompt)

Solution

1. Step 1: Check function syntax and order

   The function should print a message before calling model.generate(prompt) and return the result.

2. Step 2: Identify correct syntax and return usage

   def wrapper(model, prompt): print('Calling model'); return model.generate(prompt) prints first, then returns the model output correctly. def wrapper(model, prompt): model.generate(prompt); print('Calling model') prints after calling but does not return the output properly. def wrapper(model, prompt): return print('Calling model', model.generate(prompt)) returns the print result (None). def wrapper(model, prompt): print('Calling model') model.generate(prompt) misses a semicolon or newline between statements.

3. Final Answer:

   def wrapper(model, prompt): print('Calling model'); return model.generate(prompt) -> Option D

4. Quick Check:

   Print then return output = def wrapper(model, prompt): print('Calling model'); return model.generate(prompt) [OK]

Hint: Print before return, and return model output directly [OK]

Common Mistakes:

• Returning print() instead of model output
• Missing return statement
• Incorrect statement order or syntax

3. Given this Python code using an LLM wrapper, what will be printed and returned?

class SimpleModel:
    def generate(self, prompt):
        return f"Response to: {prompt}"

def wrapper(model, prompt):
    print(f"Input prompt: {prompt}")
    result = model.generate(prompt)
    print(f"Model output: {result}")
    return result

model = SimpleModel()
output = wrapper(model, "Hello")
print(f"Final output: {output}")

medium

A. Input prompt: Hello
Model output: Response to: Hello
Final output: Response to: Hello

B. Model output: Response to: Hello
Input prompt: Hello
Final output: Response to: Hello

C. Final output: Response to: Hello
Input prompt: Hello
Model output: Response to: Hello

D. Input prompt: Hello
Final output: Response to: Hello
Model output: Response to: Hello

Solution

1. Step 1: Trace the wrapper function calls

   The wrapper first prints the input prompt, then calls model.generate which returns a string, then prints the model output, and finally returns the result.

2. Step 2: Check the order of prints and final output

   The prints happen in order: input prompt, model output, then outside the wrapper the final output is printed.

3. Final Answer:

   Input prompt: Hello Model output: Response to: Hello Final output: Response to: Hello -> Option A

4. Quick Check:

   Print order matches Input prompt: Hello Model output: Response to: Hello Final output: Response to: Hello [OK]

Hint: Follow print statements in code order to find output [OK]

Common Mistakes:

• Mixing print order
• Confusing return value with print output
• Ignoring the final print outside wrapper

4. This code tries to wrap an LLM call but has an error. What is the error?

def wrapper(model, prompt):
    print('Calling model')
    output = model.generate(prompt)
    print('Output:', output)

model = SomeModel()
result = wrapper(model, 'Test')

medium

A. The wrapper function does not return the model output

B. The model object is not defined

C. The print statements have syntax errors

D. The prompt argument is missing in the wrapper call

Solution

1. Step 1: Check the wrapper function's return behavior

   The wrapper prints messages and calls model.generate but does not return the output, so result will be None.

2. Step 2: Verify other parts of the code

   The model is assumed defined as SomeModel(), print statements are correct, and the prompt is passed correctly.

3. Final Answer:

   The wrapper function does not return the model output -> Option A

4. Quick Check:

   Missing return in wrapper = The wrapper function does not return the model output [OK]

Hint: Always return model output from wrapper to use it outside [OK]

Common Mistakes:

• Forgetting to return output from wrapper
• Assuming print returns value
• Confusing variable names

5. You want to create an LLM wrapper that formats the prompt by adding a prefix, logs the prompt and output, and caches results to avoid repeated calls. Which approach best combines these features?

hard

A. Write separate functions for formatting, logging, and caching and call them outside the wrapper

B. Create a wrapper class with methods to format, log, and cache results internally

C. Modify the original model's generate method to add formatting and logging

D. Use a global variable to store all prompts and outputs without wrapping

Solution

1. Step 1: Understand the need for combining features in one place

   To keep code organized and flexible, a wrapper class can hold formatting, logging, and caching together.

2. Step 2: Evaluate options for maintainability and clarity

   Create a wrapper class with methods to format, log, and cache results internally uses a class to encapsulate all features, making it easy to manage. Write separate functions for formatting, logging, and caching and call them outside the wrapper scatters logic outside, making code messy. Modify the original model's generate method to add formatting and logging changes the model itself, which is not recommended. Use a global variable to store all prompts and outputs without wrapping uses globals, which is error-prone.

3. Final Answer:

   Create a wrapper class with methods to format, log, and cache results internally -> Option B

4. Quick Check:

   Wrapper class for combined features = Create a wrapper class with methods to format, log, and cache results internally [OK]

Hint: Use a class wrapper to keep related features together [OK]

Common Mistakes:

• Changing the original model code
• Scattering logic outside wrapper
• Using global variables for caching