> ## Documentation Index
> Fetch the complete documentation index at: https://docs.pixeltable.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Working with Gemini in Pixeltable
This documentation page is also available as an interactive notebook. You can launch the notebook in
Kaggle or Colab, or download it for use with an IDE or local Jupyter installation, by clicking one of the
above links.
export const quartoRawHtml = [`
input
response
Write a two-sentence story about a magic backpack.
Elara's worn canvas backpack always seemed to hold exactly what she
needed, producing everything from a forgotten umbrella to an entire
picnic lunch. One afternoon, caught unprepared for a sudden pop quiz,
she unzipped it to find a perfectly highlighted textbook waiting
inside.
Tell a one-line science joke.
Why don't scientists trust atoms? Because they make up
everything!
`, `
prompt
generated_image
A friendly dinosaur playing tennis in a cornfield
`, `
prompt
generated_image
A friendly dinosaur playing tennis in a cornfield
`, `
prompt
generated_video
A giant pixel floating over the open ocean in a sea of data
`, `
prompt
generated_video
A friendly dinosaur playing tennis in a cornfield
`];
Pixeltable’s Gemini integration supports two authentication methods:
* Google AI Studio: requires an API key from
[https://aistudio.google.com/app/apikey](https://aistudio.google.com/app/apikey)
* Vertex AI: uses Application Default Credentials via the Google Cloud
SDK
### Prerequisites
For Google AI Studio:
* A Google AI Studio account with an API key
([https://aistudio.google.com/app/apikey](https://aistudio.google.com/app/apikey))
For Vertex AI:
* A Google Cloud project with the Vertex AI API enabled
* The Google Cloud SDK installed and configured
(`gcloud auth application-default login`)
```python theme={"theme":{"light":"light-plus","dark":"dark-plus"}}
%pip install -qU pixeltable google-genai
```
```python theme={"theme":{"light":"light-plus","dark":"dark-plus"}}
import os
vertex_enabled = (
os.environ.get('GOOGLE_GENAI_USE_VERTEXAI', '').lower() == 'true'
)
# Option 1: Google AI Studio (API key)
# Set GEMINI_API_KEY or GOOGLE_API_KEY in your environment,
# or add api_key to the [gemini] section of $PIXELTABLE_HOME/config.toml
if (
not vertex_enabled
and 'GEMINI_API_KEY' not in os.environ
and 'GOOGLE_API_KEY' not in os.environ
):
import getpass
os.environ['GEMINI_API_KEY'] = getpass.getpass(
'Google AI Studio API Key:'
)
# Option 2: Vertex AI (Application Default Credentials)
# Uncomment and set the following environment variables to use Vertex AI instead:
# os.environ['GOOGLE_GENAI_USE_VERTEXAI'] = 'true'
# os.environ['GOOGLE_CLOUD_PROJECT'] = 'your-project-id'
# os.environ['GOOGLE_CLOUD_LOCATION'] = 'us-central1' # optional, defaults to us-central1
# Then authenticate via: gcloud auth application-default login
```
Create a Pixeltable directory for this notebook’s demo tables.
```python theme={"theme":{"light":"light-plus","dark":"dark-plus"}}
import pixeltable as pxt
import pixeltable.functions as pxtf
pxt.create_dir('gemini_demo', if_exists='replace_force')
```
Created directory 'gemini\_demo'.
\
## Generate content
Create a table with an input column, then add a computed column that
calls Gemini on each row.
```python theme={"theme":{"light":"light-plus","dark":"dark-plus"}}
from google.genai.types import GenerateContentConfigDict
# Create a table in Pixeltable and pick a model hosted on Google AI Studio with some parameters
t = pxt.create_table('gemini_demo/text', {'input': pxt.String})
config = GenerateContentConfigDict(
max_output_tokens=500, temperature=1.0, top_p=0.95, top_k=40
)
t.add_computed_column(
output=pxtf.gemini.generate_content(
t.input, model='gemini-2.5-flash', config=config
)
)
```
Created table 'text'.
Added 0 column values with 0 errors in 0.00 s
No rows affected.
```python theme={"theme":{"light":"light-plus","dark":"dark-plus"}}
# Ask Gemini for short responses so results are easy to inspect
t.insert(
[
{'input': 'Write a two-sentence story about a magic backpack.'},
{'input': 'Tell a one-line science joke.'},
]
)
```
Inserted 2 rows with 0 errors in 5.90 s (0.34 rows/s)
2 rows inserted.
```python theme={"theme":{"light":"light-plus","dark":"dark-plus"}}
# Parse the response text into its own column
t.add_computed_column(
response=t.output['candidates'][0]['content']['parts'][0]['text'],
if_exists='replace',
)
```
Added 2 column values with 0 errors in 0.01 s (184.71 rows/s)
2 rows updated.
```python theme={"theme":{"light":"light-plus","dark":"dark-plus"}}
t.select(t.input, t.response).collect()
```
## Generate images with Nano Banana
Use `pxtf.gemini.generate_content` with model `gemini-2.5-flash-image`.
This returns a structured response, so extract the image from
`response['candidates'][0]['content']['parts'][0]['inline_data']['data']`,
as shown below.
```python theme={"theme":{"light":"light-plus","dark":"dark-plus"}}
nano_t = pxt.create_table(
'gemini_demo/nano_banana_images', {'prompt': pxt.String}
)
config = GenerateContentConfigDict(
response_modalities=['IMAGE'], image_config={'aspect_ratio': '16:9'}
)
nano_t.add_computed_column(
response=pxtf.gemini.generate_content(
nano_t.prompt, model='gemini-2.5-flash-image', config=config
)
)
nano_t.add_computed_column(
generated_image=(
nano_t.response.candidates[0]
.content.parts[0]
.inline_data.data.astype(pxt.Image)
)
)
```
Created table 'nano\_banana\_images'.
Added 0 column values with 0 errors in 0.00 s
Added 0 column values with 0 errors in 0.00 s
No rows affected.
```python theme={"theme":{"light":"light-plus","dark":"dark-plus"}}
nano_t.insert(
[{'prompt': 'A friendly dinosaur playing tennis in a cornfield'}]
)
```
Inserted 1 row with 0 errors in 6.61 s (0.15 rows/s)
1 row inserted.
```python theme={"theme":{"light":"light-plus","dark":"dark-plus"}}
nano_t.select(nano_t.prompt, nano_t.generated_image).collect()
```
## Generate images with Imagen
Use `pxtf.gemini.generate_images` with an Imagen model name such as
`imagen-4.0-generate-001`.
This returns a `pxt.Image` directly, so you can use it in computed
columns without JSON subscripting.
```python theme={"theme":{"light":"light-plus","dark":"dark-plus"}}
from google.genai.types import GenerateImagesConfigDict
images_t = pxt.create_table('gemini_demo/images', {'prompt': pxt.String})
config = GenerateImagesConfigDict(aspect_ratio='16:9')
images_t.add_computed_column(
generated_image=pxtf.gemini.generate_images(
images_t.prompt, model='imagen-4.0-generate-001', config=config
)
)
```
Created table 'images'.
Added 0 column values with 0 errors in 0.00 s
No rows affected.
```python theme={"theme":{"light":"light-plus","dark":"dark-plus"}}
images_t.insert(
[{'prompt': 'A friendly dinosaur playing tennis in a cornfield'}]
)
```
Inserted 1 row with 0 errors in 11.87 s (0.08 rows/s)
1 row inserted.
Created table 'videos'.
Added 0 column values with 0 errors in 0.00 s
No rows affected.
```python theme={"theme":{"light":"light-plus","dark":"dark-plus"}}
videos_t.insert(
[
{
'prompt': 'A giant pixel floating over the open ocean in a sea of data'
}
]
)
```
Inserted 1 row with 0 errors in 46.34 s (0.02 rows/s)
1 row inserted.
```python theme={"theme":{"light":"light-plus","dark":"dark-plus"}}
videos_t.select(videos_t.prompt, videos_t.generated_video).collect()
```
## Generate video from an existing image
We’ll add a computed column to our `nano_t` table to animate the
generated image. You can pass `images_t.generated_image` from the Imagen
section above the same way.
```python theme={"theme":{"light":"light-plus","dark":"dark-plus"}}
nano_t.add_computed_column(
generated_video=pxtf.gemini.generate_videos(
image=nano_t.generated_image, model='veo-2.0-generate-001'
)
)
```
```python theme={"theme":{"light":"light-plus","dark":"dark-plus"}}
nano_t.select(nano_t.prompt, nano_t.generated_video).collect()
```
### Learn more
For a deeper end-to-end example, see [RAG Operations in
Pixeltable](/howto/use-cases/rag-operations).
