The Google GenAI SDK: A guide with a Python tutorial

pip install google-genai

pip install weave 

from google import genai
client = genai.Client(api_key='YOUR_GEMINI_API_KEY')

export GOOGLE_API_KEY='your-api-key'

import os
os.environ['GOOGLE_API_KEY'] = 'your-api-key'
from google import genai
client = genai.Client()

gcloud components update
gcloud components install beta

export GOOGLE_GENAI_USE_VERTEXAI=true
export GOOGLE_CLOUD_PROJECT='your-project-id'
export GOOGLE_CLOUD_LOCATION='us-central1'

import os
from google import genai

os.environ['GOOGLE_GENAI_USE_VERTEXAI'] = 'true'
os.environ['GOOGLE_CLOUD_PROJECT'] = 'your-project-id'
os.environ['GOOGLE_CLOUD_LOCATION'] = 'us-central1'

client = genai.Client()

import requests
from io import BytesIO
from typing import Optional, Union
from PIL import Image
from google import genai
from google.genai import types

import weave; weave.init("google_genai")

@weave.op 
def gemini_infer(
    prompt: str,
    api_key: str,
    image: Image = None,
    model: str = "gemini-2.0-flash-001"
) -> str:
    """
    Run Gemini inference with an optional PIL image.

    :param prompt: The user prompt/question/command
    :param api_key: Your Gemini API key
    :param image: An optional PIL Image object
    :param model: Model string (default: "gemini-2.0-flash-001")
    :return: Model's text response
    """
    
    
    
    client = genai.Client(api_key=api_key)  # <-- Replace with your key
    # Assemble contents
    if image is not None:
        # Save image to buffer as JPEG
        buf = BytesIO()
        image.save(buf, format="JPEG")
        image_bytes = buf.getvalue()
        contents = [
            types.Part.from_bytes(data=image_bytes, mime_type="image/jpeg"),
            prompt,
        ]
    else:
        contents = [prompt]
    # Run inference
    response = client.models.generate_content(
        model=model,
        contents=contents,
    )
    return response.text

# ---- Example usage ----

if __name__ == "__main__":
    API_KEY = " "  # <-- put your key here
    # Download example image to PIL
    img_url = "https://upload.wikimedia.org/wikipedia/commons/thumb/3/3f/Fronalpstock_big.jpg/800px-Fronalpstock_big.jpg"
    headers = {"User-Agent": "Mozilla/5.0 (compatible; GeminiScript/1.0)"}
    response = requests.get(img_url, headers=headers)
    response.raise_for_status()
    pil_img = Image.open(BytesIO(response.content))

    # With image
    r1 = gemini_infer(
        prompt="Describe this alpine scenery in detail.",
        api_key=API_KEY,
        image=pil_img,
    )
    print("\nGemini vision response:")
    print(r1)

    # Text-only
    r2 = gemini_infer(
        prompt="Write a haiku about mountains.",
        api_key=API_KEY
    )
    print("\nGemini text-only response:")
    print(r2)


import time
import weave
import moviepy.editor as mpy
from google import genai
from google.genai import types


API_KEY = "your_api_key"  # <-- your Gemini key
weave.init("gemini-genai")


@weave.op
def gemini_generate_video(prompt: str, api_key: str, fname: str = "video0.mp4") -> mpy.VideoFileClip:
    client = genai.Client(api_key=api_key)
    op = client.models.generate_videos(
        model="veo-2.0-generate-001",
        prompt=prompt,
        config=types.GenerateVideosConfig(
            person_generation="dont_allow",
            aspect_ratio="16:9",
        ),
    )
    while not op.done:
        time.sleep(10)
        op = client.operations.get(op)

        
    vid = op.response.generated_videos[0]
    client.files.download(file=vid.video)
    vid.video.save(fname)
    return mpy.VideoFileClip(fname)

# --- Example usage ---

clip = gemini_generate_video("rotating red cube in front of stars", API_KEY)


from moviepy.editor import VideoFileClip
from google import genai
from google.genai import types
import weave

weave.init("gemini-video-analysis")

API_KEY = "your_api_key"  # <- Replace with your key

client = genai.Client(api_key=API_KEY)

# Only for videos of size <20Mb
video_file_name = "./video0.mp4"
video_bytes = open(video_file_name, 'rb').read()

@weave.op
def gemini_summarize_video(video_bytes: bytes, prompt: str, api_key: str):
    client = genai.Client(api_key=api_key)
    response = client.models.generate_content(
        model='models/gemini-2.0-flash',
        contents=types.Content(
            parts=[
                types.Part(
                    inline_data=types.Blob(data=video_bytes, mime_type='video/mp4')
                ),
                types.Part(text=prompt)
            ]
        )
    )
    return response.text

# Logging and inference via Weave
summary = gemini_summarize_video(video_bytes, "Please summarize the video in 3 sentences.", API_KEY)
print(summary)


import os
from google import genai
from google.genai import types
import weave 

# --- CONFIG: Toggle here ---
USE_VERTEX = True             # Set to False for Gemini consumer API
STREAMING = True              # Set to False for normal responses

PROJECT = "your-google-cloud-project"
LOCATION = "us-central1"
API_KEY = "your-api-key"   # Only used if USE_VERTEX=False


weave.init("gemini-genai")

# --- SETUP ENV VARIABLES ---
if USE_VERTEX:
    os.environ["GOOGLE_CLOUD_PROJECT"] = PROJECT
    os.environ["GOOGLE_CLOUD_LOCATION"] = LOCATION
    os.environ["GOOGLE_GENAI_USE_VERTEXAI"] = "True"
else:
    os.environ["GOOGLE_GENAI_USE_VERTEXAI"] = "False"

# --- Initialize client ---
if USE_VERTEX:
    client = genai.Client()
    MODEL = "gemini-2.5-pro-preview-06-05"
else:
    client = genai.Client(api_key=API_KEY)
    MODEL = "gemini-2.5-pro-preview-06-05"


@weave.op 
def run_gemini(
    prompt,
    streaming=STREAMING,
    model=MODEL,
    thinking_budget=1024,
    include_thoughts=True
):
    """
    Run a prompt through Gemini (Vertex or consumer API),
    optionally using streaming, and configurable 'thinking_budget'
    and 'include_thoughts'.

    Returns (thoughts, answer) as strings.
    """
    thoughts = ""
    answer = ""
    if streaming:
        method = client.models.generate_content_stream
        response = method(
            model=model,
            contents=prompt,
            config=types.GenerateContentConfig(
                thinking_config=types.ThinkingConfig(
                    include_thoughts=include_thoughts,
                    thinking_budget=thinking_budget
                )
            )
        )
        for chunk in response:
            for part in chunk.candidates[0].content.parts:
                if not part.text:
                    continue
                if part.thought:
                    if not thoughts:
                        print("Thoughts summary:")
                    print(part.text)
                    thoughts += part.text
                else:
                    if not answer:
                        print("Answer:")
                    print(part.text)
                    answer += part.text
    else:
        method = client.models.generate_content
        response = method(
            model=model,
            contents=prompt,
            config=types.GenerateContentConfig(
                thinking_config=types.ThinkingConfig(
                    include_thoughts=include_thoughts,
                    thinking_budget=thinking_budget
                )
            )
        )
        for part in response.candidates[0].content.parts:
            if not part.text:
                continue
            if part.thought:
                if not thoughts:
                    print("Thoughts summary:")
                print(part.text)
                thoughts += part.text
            else:
                if not answer:
                    print("Answer:")
                print(part.text)
                answer += part.text
    return thoughts, answer

# -------- EXAMPLES ---------
if __name__ == "__main__":
    # Algebra example
    prompt1 = "Solve x^2 + 4x + 4 = 0"
    print("\nAlgebra Example:")
    run_gemini(
        prompt1,
        streaming=True,
        thinking_budget=512,       # You can override per-call
        include_thoughts=True      # You can override per-call
    )

    # Primes example, with less thinking budget and thoughts off
    prompt2 = "What is the sum of the first 50 prime numbers?"
    print("\nPrimes Example:")
    run_gemini(
        prompt2,
        streaming=False,
        thinking_budget=32,
        include_thoughts=False
    )

    # Logic puzzle example -- use default thinking_budget/streaming
    prompt3 = """
    Alice, Bob, and Carol each live in a different house on the same street: red, green, and blue.
    The person who lives in the red house owns a cat.
    Bob does not live in the green house.
    Carol owns a dog.
    The green house is to the left of the red house.
    Alice does not own a cat.
    Who lives in each house, and what pet do they own?
    """
    print("\nLogic Puzzle Example:")
    run_gemini(
        prompt3, 
        thinking_budget=1024,
        include_thoughts=True
    )