Skip to content
Cloudflare Docs
DirectoryAPISDKsChangelog
Google logo

Gemini 2.5 Flash

Text Generation • Google

Google's fast multimodal Gemini 2.5 model with strong reasoning and a 1M token context window.

Model Info
Context Window ↗1,000,000 tokens
Terms and Licenselink ↗
More informationlink ↗
PricingView pricing in the Cloudflare dashboard ↗

Usage

TypeScript
const response = await env.AI.run(
  'google/gemini-2.5-flash',
  { contents: [{ parts: [{ text: 'What are the three laws of thermodynamics?' }], role: 'user' }] },
)
console.log(response)
 
The three laws of thermodynamics are fundamental principles that govern how energy is transferred and transformed in physical systems. They are:

1.  **The First Law of Thermodynamics (Law of Conservation of Energy)**
    *   **Statement:** Energy cannot be created or destroyed in an isolated system; it can only be transformed from one form to another.
    *   **Explanation:** This law means that the total amount of energy in the universe remains constant. When energy appears to be "lost," it has merely changed into a different form (e.g., chemical energy into heat, electrical energy into light and heat). Mathematically, for a closed system, it's often expressed as: $\Delta U = Q - W$, where $\Delta U$ is the change in the internal energy of the system, $Q$ is the heat added to the system, and $W$ is the work done *by* the system.

2.  **The Second Law of Thermodynamics (Law of Entropy Increase)**
    *   **Statement:** The total entropy of an isolated system can only increase over time, or remain constant in ideal cases; it never decreases.
    *   **Explanation:** Entropy is a measure of disorder or randomness within a system. This law essentially states that natural processes tend to move towards a state of greater disorder or randomness. For example, a broken glass won't spontaneously reassemble, and heat naturally flows from a hotter object to a colder one, not the other way around. This law also implies that no heat engine can be 100% efficient because some energy will always be lost to increasing the entropy of the surroundings (often as waste heat).

3.  **The Third Law of Thermodynamics**
    *   **Statement:** As a system approaches absolute zero, its entropy approaches a constant minimum value. For a perfect crystal at absolute zero (0 Kelvin or -273.15 °C), the entropy is exactly zero.
    *   **Explanation:** This law provides a fundamental reference point for the measurement of entropy. It means that at absolute zero, all molecular motion would cease, and the system would be in its most ordered possible state (a perfect crystal with no defects). In practice, reaching absolute zero is impossible, as doing so would require an infinite number of steps, each becoming progressively harder.

These three laws are cornerstones of physics and chemistry, explaining a vast range of phenomena from the operation of engines to the direction of chemical reactions and the very evolution of the universe.

Examples

With System Instruction — Using a system instruction to set context
TypeScript
const response = await env.AI.run(
  'google/gemini-2.5-flash',
  {
    contents: [{ parts: [{ text: 'How do I read a JSON file in Python?' }], role: 'user' }],
    generationConfig: { temperature: 0.3 },
    systemInstruction: {
      parts: [{ text: 'You are a helpful coding assistant specializing in Python.' }],
    },
  },
)
console.log(response)
 
Reading a JSON (JavaScript Object Notation) file in Python is straightforward, thanks to the built-in `json` module.

Here's a step-by-step guide with examples:

---

### 1. The `json` Module

Python's `json` module provides methods for working with JSON data. The two primary methods you'll use for reading are:

*   **`json.load()`**: Reads JSON data from a file-like object (e.g., a file opened with `open()`).
*   **`json.loads()`**: Reads JSON data from a string.

---

### 2. Example: Reading a JSON File (`json.load()`)

This is the most common way to read a JSON file.

**Step 1: Create a sample JSON file**

Let's create a file named `data.json` with the following content:

```json
{
  "name": "Alice",
  "age": 30,
  "isStudent": false,
  "courses": [
    {"title": "Math", "credits": 3},
    {"title": "Science", "credits": 4}
  ],
  "address": null
}
```

**Step 2: Python code to read the file**

```python
import json

file_path = 'data.json'

try:
    # Open the JSON file in read mode ('r')
    # The 'with' statement ensures the file is properly closed even if errors occur.
    with open(file_path, 'r', encoding='utf-8') as file:
        # Use json.load() to parse the JSON data from the file
        data = json.load(file)

    print("JSON data successfully loaded:")
    print(data)
    print(f"\nType of loaded data: {type(data)}")

    # You can now access the data like a Python dictionary or list
    print(f"Name: {data['name']}")
    print(f"Age: {data['age']}")
    print(f"First course title: {data['courses'][0]['title']}")

except FileNotFoundError:
    print(f"Error: The file '{file_path}' was not found.")
except json.JSONDecodeError:
    print(f"Error: Could not decode JSON from '{file_path}'. Check its format.")
except Exception as e:
    print(f"An unexpected error occurred: {e}")

```

**Explanation:**

1.  **`import json`**: Imports the necessary module.
2.  **`with open(file_path, 'r', encoding='utf-8') as file:`**:
    *   Opens the file specified by `file_path`.
    *   `'r'` indicates read mode.
    *   `encoding='utf-8'` is a good practice, especially if your JSON might contain non-ASCII characters.
    *   The `with` statement is a context manager that ensures the file is automatically closed when the block is exited, even if errors occur.
3.  **`data = json.load(file)`**: This is the core line. It reads the entire content of the `file` object, parses it as JSON, and converts it into a corresponding Python object (usually a dictionary or a list).
4.  **Error Handling**: The `try...except` block is crucial for robust code:
    *   `FileNotFoundError`: Catches the error if the specified file doesn't exist.
    *   `json.JSONDecodeError`: Catches errors if the file content is not valid JSON.
    *   `Exception as e`: Catches any other unexpected errors.

---

### 3. Example: Reading JSON from a String (`json.loads()`)

Sometimes, you might receive JSON data as a string (e.g., from a web API response). In such cases, you use `json.loads()`.

```python
import json

json_string_data = '''
{
  "product": "Laptop",
  "price": 1200.50,
  "inStock": true,
  "features": ["lightweight", "fast processor"]
}
'''

try:
    # Use json.loads() to parse the JSON data from a string
    data_from_string = json.loads(json_string_data)

    print("\nJSON data from string successfully loaded:")
    print(data_from_string)
    print(f"Type of loaded data: {type(data_from_string)}")

    print(f"Product: {data_from_string['product']}")
    print(f"Price: ${data_from_string['price']}")

except json.JSONDecodeError:
    print("Error: Could not decode JSON from the string. Check its format.")
except Exception as e:
    print(f"An unexpected error occurred: {e}")
```

---

### 4. JSON to Python Type Conversion

When `json.load()` or `json.loads()` parses JSON, it converts JSON data types to their corresponding Python types:

| JSON Type     | Python Type     |
| :------------ | :-------------- |
| object        | `dict`          |
| array         | `list`          |
| string        | `str`           |
| number        | `int` or `float` |
| boolean       | `bool`          |
| null          | `None`          |

---

### Best Practices:

*   **Always use `with open(...)`**: It's safer and handles file closing automatically.
*   **Include `encoding='utf-8'`**: This prevents issues with character encoding, especially for international data.
*   **Implement Error Handling**: Use `try...except` blocks to gracefully handle `FileNotFoundError` and `json.JSONDecodeError`.
*   **Understand `load` vs. `loads`**: Use `load` for file objects and `loads` for strings.
Multi-turn Conversation — Continuing a conversation with context
TypeScript
const response = await env.AI.run(
  'google/gemini-2.5-flash',
  {
    contents: [
      {
        parts: [{ text: 'I need help planning a road trip from San Francisco to Los Angeles.' }],
        role: 'user',
      },
      {
        parts: [
          {
            text: "I'd be happy to help! The drive is about 380 miles and takes roughly 5-6 hours. Would you like suggestions for scenic routes or interesting stops along the way?",
          },
        ],
        role: 'model',
      },
      { parts: [{ text: 'Yes, what are some good places to stop?' }], role: 'user' },
    ],
    generationConfig: { maxOutputTokens: 2048 },
  },
)
console.log(response)
 
Okay, you've got two main routes, each with its own character and fantastic stops
Creative Writing — Higher temperature for creative output
TypeScript
const response = await env.AI.run(
  'google/gemini-2.5-flash',
  {
    contents: [
      {
        parts: [{ text: 'Write a short story opening about a detective finding an unusual clue.' }],
        role: 'user',
      },
    ],
    generationConfig: { maxOutputTokens: 1500, temperature: 0.8 },
  },
)
console.log(response)
 
The rain had been a relentless drumbeat against

Parameters

toolConfig

API Schemas (Raw)

Input
Output