Lab 3: APIs and prompt engineering¶

What an API is, how the Google Gemini Python SDK works (client, generate_content, contents), and how prompt engineering shapes what you get back.

Goals:

• Use the Gemini Python SDK (client, generate_content) to send prompts from Python

• Explore how contents (strings and lists of strings) shapes what the model returns

• Practice prompt engineering (with context vs. without context) for tasks like generating datascience plotting code

Setup: You will need a Google Gemini API key from Google AI Studio that Professor Lisa emailed to you this morning! Do not share your key or commit it to git.

Part 1 - APIs and the Gemini SDK¶

An Application Programming Interface (API) lets programmers use services that other people have written. You often don’t need to know how something is implemented, but only what it does and how to call it.

For example, with NumPy, when you call np.average, you trust that it returns the mean of the values you pass in—you don’t need the implementation details.

So far in this course, students have already used RESTful APIs (Genius, Wikipedia): you request a URL and get structured data back. Gemini can be used that way too; here we use Google’s Python SDK (Software Development Kit) (google-genai): you build a client object and call methods like generate_content. That pattern is convenient when inputs and outputs are flexible text, and when you make many calls from Python.

Resources:

• Gemini API Quickstart

• Google Gen AI Python SDK

• Gemini API: Prompting Strategies

• Ziem et al., Table 1: LLM prompting guidelines (Data 6 Final Project)

[Tutorial] Chat interface to API¶

Consider the chat prompt shown in the screenshot, as well as (the start of) the model’s response.

An AI chatbot (shown in the screenshot) is an application on top of a large language model (LLM). The LLM is what takes in user prompts and returns text responses. The chatbot is what filters input, perhaps converting and loading files with additional prompts, and returns filtered LLM responses back, perhaps with some HTML or Markdown formatting.

Let’s break down what is happening in the above screenshot:

• The user prompt: “Explain how AI works in a few words.”

• The model response: “AI works by using algorithms to analyze...”

• The specified model: Here, it is “Fast” (note the dropdown in the bottom right). The other option is “Thinking.” We’ll discuss model choice more below when we call the API.

Gemini: Import¶

We can also access Google’s Gemini model directly from Jupyter Notebook. Run the cell below to import the genai module from Google (Gemini).

Gemini API key¶

To use an LLM model via an API (e.g., service), we need an API key (e.g., service key). This is usually a pseudorandom string of letters and numbers. Please set GOOGLE_API_KEY key to the API Key in your email that Professor Lisa emailed to you this morning.

Do not share your key or commit it to git.

What is a string?¶

A string is a sequence of text characters in Python, written in quotes.

For example "Explain how AI works" or 'Write one sentence.'. Strings are how you represent words, sentences, and other text in code.

Strings in Python are enclosed in single-quotes ('like this') or double-quotes ("like this"). To build Python strings that span multiple lines, we can use the triple quote ("""). Example:

[Tutorial] Create Client & Make Request¶

Run the cell below to make a request and get an LLM response. The structure of making a request:

1. API client — genai.Client(api_key=...) is your gateway; its methods expose different API calls.

2. API request — client.models.generate_content takes named arguments:

   • (i) model: which LLM (here Gemini 2.5 Flash, like the Fast option in the web app).

   • (ii) contents: the prompt string.

3. Response — response is a Gemini-specific object; for this course we mainly use response.text, the model’s answer as a string.

[Tutorial] Run the same request again¶

LLMs are stochastic (i.e. LLMs involve probabilistic randomness), so the wording may change with each and every response.

Run the cell below to call generate_content again with the same prompt. Notice that you do NOT need to recreate the client.

Question 1: Restaurant Suggestions¶

Replace ... in contents to prompt the LLM to give a restaurant suggestion in Auburn, Alabama (or your favorite city). Then try editing the prompt (different city, budget, cuisine, etc.) to see the difference.

NOTE: Since contents take in string data type or list of strings, please make sure to wrap your text in a Python string (" " or ' '), e.g., "Find the best restaurant in Auburn, AL.".

[Optional Tutorial] Different Gemini models¶

• gemini-2.5-flash — fast; use this while iterating on prompts.

• gemini-2.5-pro — often richer answers; slower and costlier.

Discuss: If you try both on the same prompt, what differs in length, tone, or specificity?

Tip: Prefer Gemini 2.5 Flash while iterating on prompts since it is usually quicker and more cost efficient.

Part 2 - Prompt Engineering¶

[Tutorial] Prompt Contexts¶

In client.models.generate_content, there are several arguments:

• model argument is a string,

• contents argument is a string or a list of strings.

• response.text is a string

From Wikipedia: Prompt engineering is the process of structuring or crafting a prompt (natural language instruction) in order to produce better outputs from a generative AI model.

Prompt Format¶

As one structure, we can provide a multi-line string context. Notice the contents part of the API call is now has a multi-line structure. specifying the “character”, “format”, and the “question” itself. The “format” generally follows the question/task to reiterate/stress how important format is to the reply.

client = genai.Client(api_key=GOOGLE_API_KEY) #creating a client

response = client.models.generate_content (
    model="gemini-2.5-flash", #model
    contents= """
    <persona>
    <question/task>
    <format>
    """         #strings containing contexts and question
)
print(response.text)

Run the two cells below:

1. Build the contents string.

2. Then, make an API request passing in the contents string.

How long was Gemini’s response?

As a further exercise, try removing or adjusting the word limit, then rerun all three cells.

Prompt Engineering: Check your understanding¶

Recalling Workshop 2¶

In Workshop 2: Visualization, you created an admit_by_dept_rate table that compute admit_f_by_dept_rate and admit_m_by_dept_rate to the admission percentages (between 0 and 100) of female and males to each department, respectively, using the dataset from the 'UCBerkeley1973_Admission.csv'. Then you used admit_by_dept_rate to create a bar chart visualization in Question 6, which is shown below using admit_by_dept_rate.barh("Major").

Converting Table Contents Into Strings¶

Although we have loaded in cal_data in the previous section, remember that contents in the API call takes in strings data types and cal_data has a data type of a datascience table.

In order to pass in cal_data into contents argument of the API call, we will need to convert the contents in the cal_data table into strings in the next cell.

Run the three cells below which create

• table_contents: string of all the contents in cal_data

• table_info: definition of the structure cal_data table, without its contents

• table_preview: a preview of the first 20 rows of cal_data

[Tutorial] num_applicants¶

In the code cell below, we created an API call that will give the number of total applicants in cal_data using the variables table_contents and table_info that we have defined above.

Notice that now contents is a list of strings. It is okay if some strings in the list are multi-line and others are single-line, as long as they are all strings.

Is the LLM right?

Note: Without context, LLMs will do worse than you expect.

Try running the below cell, which only uses the table structure in table_info and tries to compute the number of rows.

When we ran the above request, the model gave us (SQL) code for getting the number (count) of rows. But it was not able to give us the count itself because the model context did not have the data values.

Question 2: num_admitted¶

Replace ... below in q2_contents that will give the number of admitted students from the table cal_data.

HINT: Remember what the contents argument must be. You may find either table_contents or table_info that we have defined earlier helpful.

[Tutorial] LLM writes plotting code (without contexts)¶

Note: It is okay if code pasted from an LLM raises an error.

LLMs do not have full context about your notebook state, installed packages, variable names, or file paths unless you provide that context explicitly. Treat generated code as a draft: run it, inspect errors, and revise prompts or code iteratively.

Press the three dots on the left side of the outputted cell above, select “Copy Cell Output”, and paste the code below:**

Hallucination¶

Hallucination is when the model generates plausible-looking output that is not faithful to the task requirements.

In this activity, hallucination can look like:

• using libraries other than datascience

• making up random data

• returning the wrong function name/signature

• using different column labels

• making a stacked chart instead of an overlaid chart

• adding extra explanation text instead of only code

Why Context Matters¶

After adding explicit context in the prompt (dataset schema, allowed library, exact function name, exact relabel strings, chart type, and output format constraints), Gemini is much less likely to hallucinate because the solution space is tightly bounded.

So the key lesson is: We did not “make the model smarter”. we made the task specification precise enough that the model can follow it reliably.

Question 3: LLM writes plotting code (with contexts)¶

Now you will be asking Gemini to write a complete Python function called paradox_barh(cal_data) that reproduces the bar chart above from Simpson’s paradox style admissions data in Workshop 2.

Question: Make sure your question variable includes the following:

• Clearly state the function name and its input parameter(s).

• Specify what the function should display or return regarding the number of applicants (e.g., an overlaid bar chart).

• Mention the dataset columns relevant for the plot (e.g., gender, major).

• Indicate the use of overlaid bars (not stacked) with a bar chart.

Model: Please use gemini-2.5-flash

TASK: Please replace ... with your prompt string and model string. Feel free to use table_contents, table_info, or table_preview in contents as additional contexts.

Test the model’s code: paste the function into the cell below (or edit that cell until it runs), then run it.

Compare the model’s code with your code from Workshop 2 below:

Prompt engineering resources¶

• Gemini API: Prompting Strategies

• Ziem et al., Table 1