Skip to main content

ChatGoogleGenerativeAI integration

还没翻译译自英文（docs.langchain.com）本页 173 段都还没译

Access Google's Generative AI models, including the Gemini family, via the Gemini Developer API or Gemini Enterprise Agent Platform. The Gemini Developer API offers quick setup with API keys, ideal for individual developers. Gemini Enterprise Agent Platform provides enterprise features and integrates with Google Cloud Platform.

For information on the latest models, model IDs, their features, context windows, etc. head to the Google AI docs.

Note

Gemini Enterprise Agent Platform consolidation & compatibility

As of langchain-google-genai 4.0.0, this package uses the consolidated google-genai SDK instead of the legacy google-ai-generativelanguage SDK.

This migration brings support for Gemini models both via the Gemini Developer API and Gemini API on Gemini Enterprise Agent Platform, superseding certain classes in langchain-google-vertexai, such as ChatVertexAI.

Read the full announcement and migration guide.

Tip

API Reference

For detailed documentation of all features and configuration options, head to the ChatGoogleGenerativeAI API reference.

Overview

Integration details

ClassPackageSerializableJS supportDownloadsVersion
ChatGoogleGenerativeAIlangchain-google-genaibeta✅PyPI - DownloadsPyPI - Version

Model features

Tool callingStructured outputImage inputAudio inputVideo inputToken-level streamingNative asyncToken usageLogprobs
✅✅✅✅✅✅✅✅⚠️

Setup

To access Google AI models you'll need to create a Google Account, get a Google AI API key, and install the langchain-google-genai integration package.

Installation

pip install -U langchain-google-genai

Credentials

This integration supports two backends: Gemini Developer API and Gemini Enterprise Agent Platform. The backend is selected automatically based on your configuration.

Backend selection

The backend is determined as follows:

  1. If GOOGLE_GENAI_USE_VERTEXAI env var is set, uses that value
  2. If credentials parameter is provided, uses Gemini Enterprise Agent Platform
  3. If project parameter is provided, uses Gemini Enterprise Agent Platform
  4. Otherwise, uses Gemini Developer API

You can also explicitly set vertexai=True or vertexai=False to override auto-detection.

Gemini Developer APIGemini Enterprise Agent Platform with API keyGemini Enterprise Agent Platform with credentials

Quick setup with API key

Recommended for individual developers / new users.

Head to Google AI Studio to generate an API key:

import getpass
import os

if "GOOGLE_API_KEY" not in os.environ:
    os.environ["GOOGLE_API_KEY"] = getpass.getpass("Enter your Google AI API key: ")

The integration checks for GOOGLE_API_KEY first, then GEMINI_API_KEY as a fallback.

Environment variables

VariablePurposeBackend
GOOGLE_API_KEYAPI key (primary)Both (see GOOGLE_GENAI_USE_VERTEXAI)
GEMINI_API_KEYAPI key (fallback)Both (see GOOGLE_GENAI_USE_VERTEXAI)
GOOGLE_GENAI_USE_VERTEXAIForce Gemini Enterprise Agent Platform backend (true/false)Gemini Enterprise Agent Platform
GOOGLE_CLOUD_PROJECTGCP project IDGemini Enterprise Agent Platform
GOOGLE_CLOUD_LOCATIONGCP region (default: us-central1)Gemini Enterprise Agent Platform

To enable automated tracing of your model calls, set your LangSmith API key:

os.environ["LANGSMITH_API_KEY"] = getpass.getpass("Enter your LangSmith API key: ")
os.environ["LANGSMITH_TRACING"] = "true"

Instantiation

Now we can instantiate our model object and generate responses:

Gemini Developer APIGemini Enterprise Agent Platform

from langchain_google_genai import ChatGoogleGenerativeAI

model = ChatGoogleGenerativeAI(
    model="gemini-3.7-flash",
    temperature=1.0,  # Gemini 3.0+ defaults to 1.0
    max_tokens=None,
    timeout=None,
    max_retries=2,
    # other params...
)

Note

Temperature for Gemini 3.0+ models

If temperature is not explicitly set and the model is Gemini 3.0 or later, it will be automatically set to 1.0 instead of the default 0.7 per Google GenAI API best practices. Using 0.7 with Gemini 3.0+ can cause infinite loops, degraded reasoning performance, and failure on complex tasks.

See the ChatGoogleGenerativeAI API Reference for the full set of available model parameters.

Proxy configuration

If you need to use a proxy, set these environment variables before initializing:

export HTTPS_PROXY='http://username:password@proxy_uri:port'
export SSL_CERT_FILE='path/to/cert.pem'  # Optional: custom SSL certificate

For SOCKS5 proxies or advanced proxy configuration, use the client_args parameter:

model = ChatGoogleGenerativeAI(
    model="gemini-3.7-flash",
    client_args={"proxy": "socks5://user:pass@host:port"},
)

Custom endpoints and headers

Use base_url and additional_headers for model-level HTTP options, such as routing requests through an internal gateway:

model = ChatGoogleGenerativeAI(
    model="gemini-3.7-flash",
    base_url="https://your-gemini-gateway.example.com",
    additional_headers={"X-Custom-Header": "value"},
)

To pass headers or other HTTP options for a single request, provide http_options when invoking the model:

token = "..."
messages = [("human", "Hello!")]

response = model.invoke(
    messages,
    http_options={
        "headers": {
            "Authorization": f"Bearer {token}",
        }
    },
)

The same call-time options work with async invocation:

response = await model.ainvoke(
    messages,
    http_options={"headers": {"Authorization": f"Bearer {token}"}},
)

The per-request http_options may be a dictionary or a google.genai.types.HttpOptions object. Header dictionaries are merged with model-level additional_headers, and per-request header values take precedence. Model-level timeout and max_retries settings are preserved unless you explicitly override timeout or retry_options in http_options.

from google.genai.types import HttpOptions

response = model.invoke(
    messages,
    http_options=HttpOptions(
        headers={"Authorization": f"Bearer {token}"},
    ),
)

Invocation

messages = [
    (
        "system",
        "You are a helpful assistant that translates English to French. Translate the user sentence.",
    ),
    ("human", "I love programming."),
]
ai_msg = model.invoke(messages)
ai_msg

Gemini 3Gemini 2.5

AIMessage(content=[{'type': 'text', 'text': "J'adore la programmation.", 'extras': {'signature': 'EpoWCpc...'}}], additional_kwargs={}, response_metadata={'prompt_feedback': {'block_reason': 0, 'safety_ratings': []}, 'finish_reason': 'STOP', 'model_name': 'gemini-3.7-flash', 'safety_ratings': [], 'model_provider': 'google_genai'}, id='lc_run--fb732b64-1ab4-4a28-b93b-dcfb2a164a3d-0', usage_metadata={'input_tokens': 21, 'output_tokens': 779, 'total_tokens': 800, 'input_token_details': {'cache_read': 0}, 'output_token_details': {'reasoning': 772}})

Note

Message content shape

Gemini 3 series models return a list of content blocks to capture thought signatures. Use .text to get string content:

response.content  # -> [{"type": "text", "text": "Hello!", "extras": {"signature": "EpQFCp..."}}]
response.text     # -> "Hello!"

Gemini 2.5 and earlier return a plain string for .content.

Multimodal usage

Gemini models accept multimodal inputs (text, images, audio, video, PDFs) and some models can generate multimodal outputs.

Supported input methods

MethodImageVideoAudioPDF
File upload (Files API)✅✅✅✅
Base64 inline data✅✅✅✅
HTTP/HTTPS URLs*✅✅✅✅
GCS URIs (gs://...)✅✅✅✅

*YouTube URLs are supported for video input in preview.

File upload

You can upload files to Google's servers and reference them by URI. This works for PDFs, images, videos, and audio files.

import time
from google import genai
from langchain.messages import HumanMessage
from langchain_google_genai import ChatGoogleGenerativeAI

client = genai.Client()
model = ChatGoogleGenerativeAI(model="gemini-3.7-flash")

# Upload file to Google's servers
myfile = client.files.upload(file="/path/to/your/file.pdf")
while myfile.state.name == "PROCESSING":
    time.sleep(2)
    myfile = client.files.get(name=myfile.name)

# Reference by file_id in FileContentBlock
message = HumanMessage(
    content=[
        {"type": "text", "text": "What is in the document?"},
        {
            "type": "file",
            "file_id": myfile.uri,  # or myfile.name
            "mime_type": "application/pdf",
        },
    ]
)
response = model.invoke([message])

Once uploaded, you can reference the file in any of the media-specific sections below using the file_id pattern.

Image input

Provide image inputs along with text using a HumanMessage with a list content format.

Image URLChat Completions image_url formatBase64 encodedUploaded file

from langchain.messages import HumanMessage
from langchain_google_genai import ChatGoogleGenerativeAI

model = ChatGoogleGenerativeAI(model="gemini-3.7-flash")

message = HumanMessage(
    content=[
        {"type": "text", "text": "Describe the image at the URL."},
        {
            "type": "image",
            "url": "https://picsum.photos/seed/picsum/200/300",
        },
    ]
)
response = model.invoke([message])

Other supported image formats:

  • A Google Cloud Storage URI (gs://...). Ensure the service account has access.

PDF input

Provide PDF file inputs along with text.

URLBase64 encodedUploaded file

from langchain.messages import HumanMessage
from langchain_google_genai import ChatGoogleGenerativeAI

model = ChatGoogleGenerativeAI(model="gemini-3.7-flash")

message = HumanMessage(
    content=[
        {"type": "text", "text": "Describe the document in a sentence."},
        {
            "type": "image_url",  # (PDFs are treated as images)
            "image_url": "https://www.w3.org/WAI/ER/tests/xhtml/testfiles/resources/pdf/dummy.pdf",
        },
    ]
)
response = model.invoke([message])

Audio input

Provide audio file inputs along with text.

URLBase64 encodedUploaded file

from langchain.messages import HumanMessage
from langchain_google_genai import ChatGoogleGenerativeAI

model = ChatGoogleGenerativeAI(model="gemini-3.7-flash")

message = HumanMessage(
    content=[
        {"type": "text", "text": "Summarize this audio in a sentence."},
        {
            "type": "image_url",
            "image_url": "https://example.com/audio.mp3",
        },
    ]
)
response = model.invoke([message])

Video input

Provide video file inputs along with text.

Base64 encodedUploaded fileYouTube URL

import base64
from langchain.messages import HumanMessage
from langchain_google_genai import ChatGoogleGenerativeAI

model = ChatGoogleGenerativeAI(model="gemini-3.7-flash")

video_bytes = open("path/to/your/video.mp4", "rb").read()
video_base64 = base64.b64encode(video_bytes).decode("utf-8")
mime_type = "video/mp4"

message = HumanMessage(
    content=[
        {"type": "text", "text": "Describe what's in this video in a sentence."},
        {
            "type": "video",
            "base64": video_base64,
            "mime_type": mime_type,
        },
    ]
)
response = model.invoke([message])

Note

YouTube video input (preview)

  • Only public videos are supported (not private or unlisted)
  • Free tier: max 8 hours of YouTube video per day

Agentic video understanding

Agentic video understanding lets the model dynamically explore a video to find content relevant to the prompt.

Note

Agentic video understanding requires langchain-google-genai>=4.4.0.

from langchain.chat_models import init_chat_model

model = init_chat_model("google_genai:gemini-3.7-flash")

message = {
    "role": "user",
    "content": [
        {
            "type": "video",
            "url": "https://www.youtube.com/watch?v=GbzEDgcuGJU",
            "mime_type": "video/mp4",
            "media_processing": "AGENTIC",
        },
        {"type": "text", "text": "What is deepagents in one sentence?"},
    ],
}
response = model.invoke([message])
print(response.text)

Inline video data and videos uploaded through the Files API also support agentic processing.

Image generation

Certain models can generate text and images inline. See Gemini API docs for details.

import base64
from IPython.display import Image, display
from langchain.messages import AIMessage
from langchain_google_genai import ChatGoogleGenerativeAI

model = ChatGoogleGenerativeAI(model="gemini-2.5-flash-image") # [!code highlight]

response = model.invoke("Generate a photorealistic image of a cuddly cat wearing a hat.")

def _get_image_base64(response: AIMessage) -> None:
    image_block = next(
        block
        for block in response.content
        if isinstance(block, dict) and block.get("image_url")
    )
    return image_block["image_url"].get("url").split(",")[-1]

image_base64 = _get_image_base64(response)
display(Image(data=base64.b64decode(image_base64), width=300))

Use image_config to control image dimensions and quality (see genai.types.ImageConfig). It can be set at instantiation (applies to all calls) or at invocation (per-call override):

from langchain_google_genai import ChatGoogleGenerativeAI

# Set at instantiation (applies to all calls)
model = ChatGoogleGenerativeAI(
    model="gemini-2.5-flash-image",
    image_config={"aspect_ratio": "16:9"}, # [!code highlight]
)

# Or override per call
response = model.invoke(
    "Generate a photorealistic image of a cuddly cat wearing a hat.",
    image_config={"aspect_ratio": "1:1"}, # [!code highlight]
)

By default, image generation models may return both text and images (e.g. "Ok! Here's an image of a...").

You can request that the model only return images by setting the response_modalities parameter:

InstantiationInvocation

from langchain_google_genai import ChatGoogleGenerativeAI, Modality

model = ChatGoogleGenerativeAI(
    model="gemini-2.5-flash-image",
    response_modalities=[Modality.IMAGE],  # [!code highlight]
)

# All invocations will return only images
response = model.invoke("Generate a photorealistic image of a cuddly cat wearing a hat.")

Audio generation

Certain models can generate audio files. See Gemini API docs for details.

Warning

Gemini Enterprise Agent Platform limitation

Audio generation models are currently in limited preview on Gemini Enterprise Agent Platform and may require allowlist access. If you encounter an INVALID_ARGUMENT error when using TTS models with vertexai=True, your GCP project may need to be allowlisted.

For more details, see this Google AI forum discussion.

from langchain_google_genai import ChatGoogleGenerativeAI

model = ChatGoogleGenerativeAI(model="gemini-2.5-flash-preview-tts") # [!code highlight]

response = model.invoke("Please say The quick brown fox jumps over the lazy dog")

# Base64 encoded binary data of the audio
wav_data = response.additional_kwargs.get("audio")
with open("output.wav", "wb") as f:
    f.write(wav_data)

Tool calling

You can equip the model with tools to call.

from langchain.tools import tool
from langchain.messages import HumanMessage
from langchain_google_genai import ChatGoogleGenerativeAI


# Define the tool
@tool(description="Get the current weather in a given location")
def get_weather(location: str) -> str:
    return "It's sunny."


# Initialize and bind (potentially multiple) tools to the model
model_with_tools = ChatGoogleGenerativeAI(model="gemini-3.7-flash").bind_tools([get_weather])

# Step 1: Model generates tool calls
messages = [HumanMessage("What's the weather in Boston?")]
ai_msg = model_with_tools.invoke(messages)
messages.append(ai_msg)

# Check the tool calls in the response
print(ai_msg.tool_calls)

# Step 2: Execute tools and collect results
for tool_call in ai_msg.tool_calls:
    # Execute the tool with the generated arguments
    tool_result = get_weather.invoke(tool_call)
    messages.append(tool_result)

# Step 3: Pass results back to model for final response
final_response = model_with_tools.invoke(messages)
final_response

[{'name': 'get_weather', 'args': {'location': 'Boston'}, 'id': '879b4233-901b-4bbb-af56-3771ca8d3a75', 'type': 'tool_call'}]

Structured output

Force the model to respond with a specific structure. See the Gemini API docs for more info.

from langchain_google_genai import ChatGoogleGenerativeAI
from pydantic import BaseModel
from typing import Literal


class Feedback(BaseModel):
    sentiment: Literal["positive", "neutral", "negative"]
    summary: str


model = ChatGoogleGenerativeAI(model="gemini-3.7-flash")
structured_model = model.with_structured_output(
    schema=Feedback.model_json_schema(), method="json_schema"
)

response = structured_model.invoke("The new UI is great!")
response["sentiment"]  # "positive"
response["summary"]  # "The user expresses positive..."

For streaming structured output, merge dictionaries instead of using +=:

stream = structured_model.stream("The interface is intuitive and beautiful!")
full = next(stream)
for chunk in stream:
    full.update(chunk)  # Merge dictionaries
print(full)  # Complete structured response
# -> {'sentiment': 'positive', 'summary': 'The user praises...'}

Structured output methods

Two methods are supported for structured output:

  • method="json_schema" (default): Uses Gemini's native structured output. Recommended for better reliability, as it constrains the model's generation process directly rather than relying on post-processing tool calls.
  • method="function_calling": Uses tool calling to extract structured data.

Combining structured output with Google Search

When using with_structured_output(method="function_calling"), do not pass additional tools (like Google Search) in the same call.

To get structured output and search grounding in a single call, use .bind() with response_mime_type and response_schema instead of with_structured_output:

from langchain_google_genai import ChatGoogleGenerativeAI
from pydantic import BaseModel


class MatchResult(BaseModel):
    winner: str
    final_match_score: str
    scorers: list[str]


llm = ChatGoogleGenerativeAI(model="gemini-3.7-flash")

llm_with_search = llm.bind(
    tools=[{"google_search": {}}],
    response_mime_type="application/json",
    response_schema=MatchResult.model_json_schema(),
)

response = llm_with_search.invoke(
    "Search for details of the latest Euro championship final match."
)

This uses Gemini's native JSON schema mode for structuring the output while allowing tools like Google Search for grounding—all in a single LLM call.

Token usage tracking

Access token usage information from the response metadata.

from langchain_google_genai import ChatGoogleGenerativeAI

model = ChatGoogleGenerativeAI(model="gemini-3.7-flash")

result = model.invoke("Explain the concept of prompt engineering in one sentence.")

print(result.content)
print("\nUsage Metadata:")
print(result.usage_metadata)

Prompt engineering is the art and science of crafting effective text prompts to elicit desired and accurate responses from large language models.

Usage Metadata:
{'input_tokens': 10, 'output_tokens': 24, 'total_tokens': 34, 'input_token_details': {'cache_read': 0}}

Choose a service tier

A service tier sets the price and performance class a request is billed against. Use flex to pay less for latency-tolerant work, or priority to pay a premium for lower latency. Requests use the standard tier when the parameter is omitted.

Note

service_tier requires langchain-google-genai>=4.4.0.

Set the tier on the model, or pass it per request:

from langchain_google_genai import ChatGoogleGenerativeAI

model = ChatGoogleGenerativeAI(
    model="gemini-3.7-flash",
    service_tier="flex",  # [!code highlight]
)

# Per request, overriding the model-level value
response = model.invoke("Summarize this transcript.", service_tier="priority")

Accepted values are "standard", "flex", and "priority". The value is the same on both backends, and the integration sends it the way each backend expects: a request body field on the Gemini Developer API, a request header on Gemini Enterprise Agent Platform.

A tier has to be enabled for both the project and the model. An unavailable tier returns a 400 instead of falling back to the standard tier, so the request fails rather than billing at a price you did not ask for:

ClientError: 400 INVALID_ARGUMENT. Flex API is not supported for model: gemini-2.5-flash.

For more information, see the Gemini Developer API guides for Flex and Priority, and the Gemini Enterprise Agent Platform guides for Flex and Priority.

Thinking support

Certain Gemini models support configurable thinking depth. The parameter depends on the model version:

Model familyParameterValues
Gemini 3+thinking_level"minimal", "low", "medium", "high" (default for Pro)
Gemini 2.5thinking_budget0 (off), -1 (dynamic), or a positive integer (token limit)
from langchain_google_genai import ChatGoogleGenerativeAI

# Gemini 3+: use thinking_level
llm = ChatGoogleGenerativeAI(
    model="gemini-3.7-flash",
    thinking_level="low",  # [!code highlight]
)

response = llm.invoke("How many O's are in Google?")

thinking_level is Gemini's native name for the standard reasoning_effort parameter, and the two are interchangeable aliases at both construction and call time. If both are set, thinking_level wins. Check a model's profile for the levels it supports and its default:

llm.profile["reasoning_effort_levels"]  # e.g. ['minimal', 'low', 'medium', 'high']
llm.profile["reasoning_effort_default"]  # e.g. 'medium'

Note

reasoning_effort as a standard parameter requires langchain-google-genai>=4.3.1.

Gemini 2.5 models: thinking_budget

For Gemini 2.5 models, use thinking_budget (an integer token count) instead:

  • Set to 0 to disable thinking (where supported)
  • Set to -1 for dynamic thinking (model decides)
  • Set to a positive integer to constrain token usage
from langchain_google_genai import ChatGoogleGenerativeAI

llm = ChatGoogleGenerativeAI(
    model="gemini-3.7-flash",
    thinking_budget=1024,  # [!code highlight]
)

Warning

Not all models allow disabling thinking. See the Gemini models documentation for details.

Viewing model thoughts

To see a thinking model's reasoning, set include_thoughts=True:

from langchain_google_genai import ChatGoogleGenerativeAI

llm = ChatGoogleGenerativeAI(
    model="gemini-3.7-flash",
    include_thoughts=True,  # [!code highlight]
)

response = llm.invoke("How many O's are in Google? How did you verify your answer?")
reasoning_tokens = response.usage_metadata["output_token_details"]["reasoning"]

print("Response:", response.content)
print("Reasoning tokens used:", reasoning_tokens)

Response: [{'type': 'thinking', 'thinking': '**Analyzing and Cou...'}, {'type': 'text', 'text': 'There a...', 'extras': {'signature': 'EroR...'}}]
Reasoning tokens used: 672

See the Gemini API docs for more information on thinking.

Thought signatures

Thought signatures are encrypted representations of the model's reasoning. They enable Gemini to maintain thought context across multi-turn conversations, since the API is stateless.

Note

Gemini 3 may raise 4xx errors if thought signatures are not passed back with tool call responses. Upgrade to langchain-google-genai >= 3.1.0 to ensure this is handled correctly.

Signatures appear in AIMessage responses:

  • Text blocks: extras.signature within the content block
  • Tool calls: additional_kwargs["__gemini_function_call_thought_signatures__"]

For multi-turn conversations, pass the full AIMessage back to the model so signatures are preserved. This happens automatically when you append the AIMessage to your messages list (as shown in the tool calling example above).

Warning

Don't reconstruct messages manually. If you create a new AIMessage instead of passing the original object, the signatures will be lost and the API may reject the request.

Built-in tools

Google Gemini supports a variety of built-in tools, which can be bound to the model in the usual way.

Google search

See Gemini docs for detail.

Bind to modelUse on invocation

from langchain_google_genai import ChatGoogleGenerativeAI

model = ChatGoogleGenerativeAI(model="gemini-3.7-flash")

model_with_search = model.bind_tools([{"google_search": {}}]) # [!code highlight]
response = model_with_search.invoke("When is the next total solar eclipse in US?")

response.content_blocks

[{'type': 'text',
  'text': 'The next total solar eclipse visible in the contiguous United States will occur on...',
  'annotations': [{'type': 'citation',
    'id': 'abc123',
    'url': '<url for source 1>',
    'title': '<source 1 title>',
    'start_index': 0,
    'end_index': 99,
    'cited_text': 'The next total solar eclipse...',
    'extras': {'google_ai_metadata': {'web_search_queries': ['next total solar eclipse in US'],
       'grounding_chunk_index': 0,
       'confidence_scores': []}}},
   ...

Google maps

Certain models support grounding using Google Maps. Maps grounding connects Gemini's generative capabilities with Google Maps' current, factual location data. This enables location-aware applications that provide accurate, geographically specific responses. See Gemini docs for detail.

Bind to modelUse on invocation

from langchain_google_genai import ChatGoogleGenerativeAI

model = ChatGoogleGenerativeAI(model="gemini-3.1-pro-preview")

model_with_maps = model.bind_tools([{"google_maps": {}}]) # [!code highlight]
response = model_with_maps.invoke(
    "What are some good Italian restaurants near the Eiffel Tower in Paris?"
)

The response will include grounding metadata with location information from Google Maps.

You can optionally provide a specific location context using tool_config with lat_lng. This is useful when you want to ground queries relative to a specific geographic point.

Bind to modelUse on invocation

from langchain_google_genai import ChatGoogleGenerativeAI

model = ChatGoogleGenerativeAI(model="gemini-3.1-pro-preview")

# Provide location context (latitude and longitude)
model_with_maps = model.bind_tools(
    [{"google_maps": {}}], # [!code highlight]
    tool_config={
        "retrieval_config": {  # Eiffel Tower
            "lat_lng": { # [!code highlight]
                "latitude": 48.858844, # [!code highlight]
                "longitude": 2.294351, # [!code highlight]
            } # [!code highlight]
        }
    },
)

response = model_with_maps.invoke(
    "What Italian restaurants are within a 5 minute walk from here?"
)

URL context

The URL context tool enables the model to access and analyze content from URLs you provide in your prompt. This is useful for tasks like summarizing web pages, extracting data from multiple sources, or answering questions about online content. See Gemini docs for detail and limitations.

Bind to modelUse on invocation

from langchain_google_genai import ChatGoogleGenerativeAI

model = ChatGoogleGenerativeAI(model="gemini-3.7-flash")

model_with_url_context = model.bind_tools([{"url_context": {}}]) # [!code highlight]
response = model_with_url_context.invoke(
    "Summarize the content at https://docs.langchain.com"
)

Code execution

See Gemini docs for detail.

Bind to modelUse on invocation

from langchain_google_genai import ChatGoogleGenerativeAI

model = ChatGoogleGenerativeAI(model="gemini-3.7-flash")

model_with_code_interpreter = model.bind_tools([{"code_execution": {}}]) # [!code highlight]
response = model_with_code_interpreter.invoke("Use Python to calculate 3^3.")

response.content_blocks

[{'type': 'server_tool_call',
  'name': 'code_interpreter',
  'args': {'code': 'print(3**3)', 'language': <Language.PYTHON: 1>},
  'id': '...'},
 {'type': 'server_tool_result',
  'tool_call_id': '',
  'status': 'success',
  'output': '27\n',
  'extras': {'block_type': 'code_execution_result',
   'outcome': <Outcome.OUTCOME_OK: 1>}},
 {'type': 'text', 'text': 'The calculation of 3 to the power of 3 is 27.'}]

Computer use

The Gemini 2.5 Computer Use model (gemini-2.5-computer-use-preview-10-2025) can interact with browser environments to automate web tasks like clicking, typing, and scrolling.

Warning

Preview model limitations

The Computer Use model is in preview and may produce unexpected behavior. Always supervise automated tasks and avoid use with sensitive data or critical operations. See the Gemini API docs for safety best practices.

Bind to modelUse on invocation

from langchain_google_genai import ChatGoogleGenerativeAI

model = ChatGoogleGenerativeAI(model="gemini-2.5-computer-use-preview-10-2025") # [!code highlight]
model_with_computer = model.bind_tools([{"computer_use": {}}]) # [!code highlight]

response = model_with_computer.invoke("Please navigate to example.com")

response.content_blocks

[{'type': 'tool_call',
  'id': '08a8b175-16ab-4861-8965-b736d5d4dd7e',
  'name': 'open_web_browser',
  'args': {}}]

You can configure the environment and exclude specific UI actions:

from langchain_google_genai import ChatGoogleGenerativeAI, Environment

model = ChatGoogleGenerativeAI(model="gemini-2.5-computer-use-preview-10-2025") # [!code highlight]

# Specify the environment (browser is default)
model_with_computer = model.bind_tools(
    [{"computer_use": {"environment": Environment.ENVIRONMENT_BROWSER}}] # [!code highlight]
)

# Exclude specific UI actions
model_with_computer = model.bind_tools(
    [
        {
            "computer_use": {
                "environment": Environment.ENVIRONMENT_BROWSER,
                "excludedPredefinedFunctions": [ # [!code highlight]
                    "drag_and_drop", # [!code highlight]
                    "key_combination", # [!code highlight]
                ], # [!code highlight]
            }
        }
    ]
)

response = model_with_computer.invoke("Search for Python tutorials")

The model returns function calls for UI actions (like click_at, type_text_at, scroll) with normalized coordinates. You'll need to implement the actual execution of these actions in your browser automation framework.

Safety settings

Gemini models have default safety settings that can be overridden. If you are receiving lots of 'Safety Warnings' from your models, you can try tweaking the safety_settings attribute of the model. For example, to turn off safety blocking for dangerous content, you can construct your LLM as follows:

from langchain_google_genai import (
    ChatGoogleGenerativeAI,
    HarmBlockThreshold,
    HarmCategory,
)

llm = ChatGoogleGenerativeAI(
        model="gemini-3.7-flash",
        safety_settings={
        HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT: HarmBlockThreshold.BLOCK_NONE,
    },
)

For an enumeration of the categories and thresholds available, see Google's safety settings guide.

Context caching

Context caching allows you to store and reuse content (e.g., PDFs, images) for faster processing. The cached_content parameter accepts a cache name created via the Google Generative AI API.

Single file example

Multiple files example

See the Gemini API docs on context caching for more information.

Response metadata

Access response metadata from the model response.

from langchain_google_genai import ChatGoogleGenerativeAI

llm = ChatGoogleGenerativeAI(model="gemini-3.7-flash")

response = llm.invoke("Hello!")
response.response_metadata

{'prompt_feedback': {'block_reason': 0, 'safety_ratings': []},
 'finish_reason': 'STOP',
 'model_name': 'gemini-3.7-flash',
 'safety_ratings': [],
 'model_provider': 'google_genai'}

API reference

For detailed documentation of all features and configuration options, head to the ChatGoogleGenerativeAI API reference.

AI 翻译查看英文原文