import google.generativeai as genai

genai.configure(api_key="YOUR_API_KEY")

# Send result back
response = model.generate_content([
    {"role": "model", "parts": [response.parts[0]]},
    {"role": "user", "parts": [genai.protos.Part(
        function_response=genai.protos.FunctionResponse(
            name=fc.name,
            response=result
        )
    )]}
])

---

import google.generativeai as genai
from datetime import datetime

genai.configure(api_key="YOUR_API_KEY")

response = chat.send_message(genai.protos.Part(
    function_response=genai.protos.FunctionResponse(
        name=fc.name,
        response={"result": result}
    )
))

**See:** `references/function-calling.md` for comprehensive guide

---

undefined

**Code Execution:**

```python

**See:** `references/built-in-tools.md` for all tools

---

import google.generativeai as genai
from pydantic import BaseModel
from typing import List

genai.configure(api_key="YOUR_API_KEY")

**TypeScript with Zod:**

```typescript
import { GoogleGenerativeAI } from "@google/generative-ai";
import { z } from "zod";

const MovieSchema = z.object({
  title: z.string(),
  director: z.string(),
  year: z.number(),
  genre: z.array(z.string()),
  rating: z.number()
});

const MovieListSchema = z.object({
  movies: z.array(MovieSchema)
});

const genAI = new GoogleGenerativeAI(process.env.GEMINI_API_KEY!);

const model = genAI.getGenerativeModel({
  model: "gemini-3-pro-preview",
  generationConfig: {
    responseMimeType: "application/json",
    responseSchema: MovieListSchema
  }
});

const result = await model.generateContent("List 3 classic science fiction movies");
const movies = MovieListSchema.parse(JSON.parse(result.response.text()));

console.log(movies);

import google.generativeai as genai
from pathlib import Path

genai.configure(api_key="YOUR_API_KEY")

**Cost Comparison:**

| Context Size | Without Cache | With Cache | Savings |
|-------------|---------------|------------|---------|
| 100k tokens × 10 queries | $2.00 | $0.22 | 89% |
| 500k tokens × 50 queries | $50.00 | $5.50 | 89% |

**See:** `references/context-caching.md` for comprehensive guide

---

import google.generativeai as genai

genai.configure(api_key="YOUR_API_KEY")
model = genai.GenerativeModel("gemini-3-pro-preview")

**See:** `references/batch-processing.md` for advanced patterns

---

undefined

**Bypass Validation (when needed):**

```python

**See:** `references/thought-signatures.md` for complete guide

---

from langchain_google_genai import ChatGoogleGenerativeAI

llm = ChatGoogleGenerativeAI(
    model="gemini-3-pro-preview",
    google_api_key="YOUR_API_KEY"
)

response = llm.invoke("Explain neural networks")
print(response.content)

import { createGoogleGenerativeAI } from '@ai-sdk/google';
import { generateText } from 'ai';

const google = createGoogleGenerativeAI({
  apiKey: process.env.GEMINI_API_KEY
});

const { text } = await generateText({
  model: google('gemini-3-pro-preview'),
  prompt: 'Explain neural networks'
});

console.log(text);

from pydantic_ai import Agent

agent = Agent(
    'google-genai:gemini-3-pro-preview',
    system_prompt='You are a helpful AI assistant'
)

result = agent.run_sync('Explain neural networks')
print(result.data)

from google.api_core import exceptions, retry

@retry.Retry(
    predicate=retry.if_exception_type(
        exceptions.ResourceExhausted,
        exceptions.ServiceUnavailable
    )
)
def safe_generate(prompt):
    try:
        return model.generate_content(prompt)
    except exceptions.InvalidArgument as e:
        logger.error(f"Invalid argument: {e}")
        raise
    except Exception as e:
        logger.error(f"Unexpected error: {e}")
        raise

import time
from collections import deque

class RateLimiter:
    def __init__(self, max_rpm=60):
        self.max_rpm = max_rpm
        self.requests = deque()

    def wait_if_needed(self):
        now = time.time()
        self.requests = deque([t for t in self.requests if t > now - 60])

        if len(self.requests) >= self.max_rpm:
            sleep_time = 60 - (now - self.requests[0])
            time.sleep(max(0, sleep_time))

        self.requests.append(now)

class CostTracker:
    def __init__(self):
        self.total_cost = 0

    def track(self, response):
        usage = response.usage_metadata
        input_cost = (usage.prompt_token_count / 1_000_000) * 2.00
        output_cost = (usage.candidates_token_count / 1_000_000) * 12.00

        cost = input_cost + output_cost
        self.total_cost += cost

        return {
            "input_tokens": usage.prompt_token_count,
            "output_tokens": usage.candidates_token_count,
            "cost": cost,
            "total_cost": self.total_cost
        }