langchain-google-genai 2.1.6__tar.gz → 2.1.8__tar.gz

{langchain_google_genai-2.1.6 → langchain_google_genai-2.1.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: langchain-google-genai
-Version: 2.1.6
+Version: 2.1.8
 Summary: An integration package connecting Google's genai package and LangChain
 Home-page: https://github.com/langchain-ai/langchain-google
 License: MIT
@@ -13,7 +13,7 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Requires-Dist: filetype (>=1.2.0,<2.0.0)
 Requires-Dist: google-ai-generativelanguage (>=0.6.18,<0.7.0)
-Requires-Dist: langchain-core (>=0.3.66,<0.4.0)
+Requires-Dist: langchain-core (>=0.3.68,<0.4.0)
 Requires-Dist: pydantic (>=2,<3)
 Project-URL: Repository, https://github.com/langchain-ai/langchain-google
 Project-URL: Source Code, https://github.com/langchain-ai/langchain-google/tree/main/libs/genai

{langchain_google_genai-2.1.6 → langchain_google_genai-2.1.8}/langchain_google_genai/__init__.py

@@ -4,55 +4,57 @@ This module integrates Google's Generative AI models, specifically the Gemini se
 
 **Chat Models**
 
-The `ChatGoogleGenerativeAI` class is the primary interface for interacting with Google's Gemini chat models. It allows users to send and receive messages using a specified Gemini model, suitable for various conversational AI applications.
+The ``ChatGoogleGenerativeAI`` class is the primary interface for interacting with Google's Gemini chat models. It allows users to send and receive messages using a specified Gemini model, suitable for various conversational AI applications.
 
 **LLMs**
 
-The `GoogleGenerativeAI` class is the primary interface for interacting with Google's Gemini LLMs. It allows users to generate text using a specified Gemini model.
+The ``GoogleGenerativeAI`` class is the primary interface for interacting with Google's Gemini LLMs. It allows users to generate text using a specified Gemini model.
 
 **Embeddings**
 
-The `GoogleGenerativeAIEmbeddings` class provides functionalities to generate embeddings using Google's models.
+The ``GoogleGenerativeAIEmbeddings`` class provides functionalities to generate embeddings using Google's models.
 These embeddings can be used for a range of NLP tasks, including semantic analysis, similarity comparisons, and more.
+
 **Installation**
 
 To install the package, use pip:
 
-```python
-pip install -U langchain-google-genai
-```
-## Using Chat Models
+.. code-block:: python
+    pip install -U langchain-google-genai
+
+**Using Chat Models**
 
 After setting up your environment with the required API key, you can interact with the Google Gemini models.
 
-```python
-from langchain_google_genai import ChatGoogleGenerativeAI
+.. code-block:: python
+
+    from langchain_google_genai import ChatGoogleGenerativeAI
 
-llm = ChatGoogleGenerativeAI(model="gemini-pro")
-llm.invoke("Sing a ballad of LangChain.")
-```
+    llm = ChatGoogleGenerativeAI(model="gemini-pro")
+    llm.invoke("Sing a ballad of LangChain.")
 
-## Using LLMs
+**Using LLMs**
 
 The package also supports generating text with Google's models.
 
-```python
-from langchain_google_genai import GoogleGenerativeAI
+.. code-block:: python
 
-llm = GoogleGenerativeAI(model="gemini-pro")
-llm.invoke("Once upon a time, a library called LangChain")
-```
+    from langchain_google_genai import GoogleGenerativeAI
 
-## Embedding Generation
+    llm = GoogleGenerativeAI(model="gemini-pro")
+    llm.invoke("Once upon a time, a library called LangChain")
+
+**Embedding Generation**
 
 The package also supports creating embeddings with Google's models, useful for textual similarity and other NLP applications.
 
-```python
-from langchain_google_genai import GoogleGenerativeAIEmbeddings
+.. code-block:: python
+
+    from langchain_google_genai import GoogleGenerativeAIEmbeddings
+
+    embeddings = GoogleGenerativeAIEmbeddings(model="models/embedding-001")
+    embeddings.embed_query("hello, world!")
 
-embeddings = GoogleGenerativeAIEmbeddings(model="models/embedding-001")
-embeddings.embed_query("hello, world!")
-```
 """  # noqa: E501
 
 from langchain_google_genai._enums import HarmBlockThreshold, HarmCategory, Modality

{langchain_google_genai-2.1.6 → langchain_google_genai-2.1.8}/langchain_google_genai/_common.py

@@ -39,20 +39,19 @@ Supported examples:
     "when making API calls. If not provided, credentials will be ascertained from "
     "the GOOGLE_API_KEY envvar"
     temperature: float = 0.7
-    """Run inference with this temperature. Must by in the closed interval
-       [0.0, 2.0]."""
+    """Run inference with this temperature. Must be within ``[0.0, 2.0]``."""
     top_p: Optional[float] = None
     """Decode using nucleus sampling: consider the smallest set of tokens whose
-       probability sum is at least top_p. Must be in the closed interval [0.0, 1.0]."""
+       probability sum is at least ``top_p``. Must be within ``[0.0, 1.0]``."""
     top_k: Optional[int] = None
-    """Decode using top-k sampling: consider the set of top_k most probable tokens.
+    """Decode using top-k sampling: consider the set of ``top_k`` most probable tokens.
        Must be positive."""
     max_output_tokens: Optional[int] = Field(default=None, alias="max_tokens")
     """Maximum number of tokens to include in a candidate. Must be greater than zero.
-       If unset, will default to 64."""
+       If unset, will default to ``64``."""
     n: int = 1
     """Number of chat completions to generate for each prompt. Note that the API may
-       not return the full n completions if duplicates are generated."""
+       not return the full ``n`` completions if duplicates are generated."""
     max_retries: int = 6
     """The maximum number of retries to make when generating."""
 
@@ -94,6 +93,7 @@ Supported examples:
     
         For example: 
 
+        .. code-block:: python
             from google.generativeai.types.safety_types import HarmBlockThreshold, HarmCategory
 
             safety_settings = {
@@ -102,7 +102,7 @@ Supported examples:
                 HarmCategory.HARM_CATEGORY_HARASSMENT: HarmBlockThreshold.BLOCK_LOW_AND_ABOVE,
                 HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT: HarmBlockThreshold.BLOCK_NONE,
             }
-            """  # noqa: E501
+    """  # noqa: E501
 
     @property
     def lc_secrets(self) -> Dict[str, str]:
@@ -149,7 +149,7 @@ def get_client_info(module: Optional[str] = None) -> "ClientInfo":
         module (Optional[str]):
             Optional. The module for a custom user agent header.
     Returns:
-        google.api_core.gapic_v1.client_info.ClientInfo
+        ``google.api_core.gapic_v1.client_info.ClientInfo``
     """
     client_library_version, user_agent = get_user_agent(module)
     return ClientInfo(

{langchain_google_genai-2.1.6 → langchain_google_genai-2.1.8}/langchain_google_genai/_genai_extension.py

@@ -174,12 +174,12 @@ class TestCredentials(credentials.Credentials):
 
     @property
     def expired(self) -> bool:
-        """Returns `False`, test credentials never expire."""
+        """Returns ``False``, test credentials never expire."""
         return False
 
     @property
     def valid(self) -> bool:
-        """Returns `True`, test credentials are always valid."""
+        """Returns ``True``, test credentials are always valid."""
         return True
 
     def refresh(self, request: Any) -> None:
@@ -206,11 +206,11 @@ class TestCredentials(credentials.Credentials):
 def _get_credentials() -> Optional[credentials.Credentials]:
     """Returns credential from config if set or fake credentials for unit testing.
 
-    If _config.testing is True, a fake credential is returned.
+    If ``_config.testing`` is ``True``, a fake credential is returned.
     Otherwise, we are in a real environment and will use credentials if provided
-    or None is returned.
+    or ``None`` is returned.
 
-    If None is passed to the clients later on, the actual credentials will be
+    If ``None`` is passed to the clients later on, the actual credentials will be
     inferred by the rules specified in google.auth package.
     """
     if _config.testing:

{langchain_google_genai-2.1.6 → langchain_google_genai-2.1.8}/langchain_google_genai/_image_utils.py

@@ -30,7 +30,7 @@ class ImageBytesLoader:
     """
 
     def load_bytes(self, image_string: str) -> bytes:
-        """Routes to the correct loader based on the image_string.
+        """Routes to the correct loader based on the ``'image_string'``.
 
         Args:
             image_string: Can be either:
@@ -178,8 +178,8 @@ def image_bytes_to_b64_string(
 
     Args:
         image_bytes: Bytes of the image.
-        encoding: Type of encoding in the string. 'ascii' by default.
-        image_format: Format of the image. 'png' by default.
+        encoding: Type of encoding in the string. ``'ascii'`` by default.
+        image_format: Format of the image. ``'png'`` by default.
 
     Returns:
         B64 image encoded string.

{langchain_google_genai-2.1.6 → langchain_google_genai-2.1.8}/langchain_google_genai/chat_models.py

@@ -31,7 +31,7 @@ from typing import (
 import filetype  # type: ignore[import]
 import google.api_core
 
-# TODO: remove ignore once the google package is published with types
+# TODO: remove ignore once the Google package is published with types
 import proto  # type: ignore[import]
 from google.ai.generativelanguage_v1beta import (
     GenerativeServiceAsyncClient as v1betaGenerativeServiceAsyncClient,
@@ -72,7 +72,7 @@ from langchain_core.messages import (
     ToolMessage,
     is_data_content_block,
 )
-from langchain_core.messages.ai import UsageMetadata
+from langchain_core.messages.ai import UsageMetadata, add_usage, subtract_usage
 from langchain_core.messages.tool import invalid_tool_call, tool_call, tool_call_chunk
 from langchain_core.output_parsers import JsonOutputParser, PydanticOutputParser
 from langchain_core.output_parsers.base import OutputParserLike
@@ -295,7 +295,7 @@ def _is_openai_image_block(block: dict) -> bool:
 def _convert_to_parts(
     raw_content: Union[str, Sequence[Union[str, dict]]],
 ) -> List[Part]:
-    """Converts a list of LangChain messages into a google parts."""
+    """Converts a list of LangChain messages into a Google parts."""
     parts = []
     content = [raw_content] if isinstance(raw_content, str) else raw_content
     image_loader = ImageBytesLoader()
@@ -413,7 +413,7 @@ def _convert_to_parts(
 def _convert_tool_message_to_parts(
     message: ToolMessage | FunctionMessage, name: Optional[str] = None
 ) -> list[Part]:
-    """Converts a tool or function message to a google part."""
+    """Converts a tool or function message to a Google part."""
     # Legacy agent stores tool name in message.additional_kwargs instead of message.name
     name = message.name or name or message.additional_kwargs.get("name")
     response: Any
@@ -716,35 +716,43 @@ def _response_to_result(
     """Converts a PaLM API response into a LangChain ChatResult."""
     llm_output = {"prompt_feedback": proto.Message.to_dict(response.prompt_feedback)}
 
-    # previous usage metadata needs to be subtracted because gemini api returns
-    # already-accumulated token counts with each chunk
-    prev_input_tokens = prev_usage["input_tokens"] if prev_usage else 0
-    prev_output_tokens = prev_usage["output_tokens"] if prev_usage else 0
-    prev_total_tokens = prev_usage["total_tokens"] if prev_usage else 0
-
     # Get usage metadata
     try:
         input_tokens = response.usage_metadata.prompt_token_count
-        output_tokens = response.usage_metadata.candidates_token_count
-        total_tokens = response.usage_metadata.total_token_count
         thought_tokens = response.usage_metadata.thoughts_token_count
+        output_tokens = response.usage_metadata.candidates_token_count + thought_tokens
+        total_tokens = response.usage_metadata.total_token_count
         cache_read_tokens = response.usage_metadata.cached_content_token_count
         if input_tokens + output_tokens + cache_read_tokens + total_tokens > 0:
             if thought_tokens > 0:
-                lc_usage = UsageMetadata(
-                    input_tokens=input_tokens - prev_input_tokens,
-                    output_tokens=output_tokens - prev_output_tokens,
-                    total_tokens=total_tokens - prev_total_tokens,
+                cumulative_usage = UsageMetadata(
+                    input_tokens=input_tokens,
+                    output_tokens=output_tokens,
+                    total_tokens=total_tokens,
                     input_token_details={"cache_read": cache_read_tokens},
                     output_token_details={"reasoning": thought_tokens},
                 )
             else:
-                lc_usage = UsageMetadata(
-                    input_tokens=input_tokens - prev_input_tokens,
-                    output_tokens=output_tokens - prev_output_tokens,
-                    total_tokens=total_tokens - prev_total_tokens,
+                cumulative_usage = UsageMetadata(
+                    input_tokens=input_tokens,
+                    output_tokens=output_tokens,
+                    total_tokens=total_tokens,
                     input_token_details={"cache_read": cache_read_tokens},
                 )
+            # previous usage metadata needs to be subtracted because gemini api returns
+            # already-accumulated token counts with each chunk
+            lc_usage = subtract_usage(cumulative_usage, prev_usage)
+            if prev_usage and cumulative_usage["input_tokens"] < prev_usage.get(
+                "input_tokens", 0
+            ):
+                # Gemini 1.5 and 2.0 return a lower cumulative count of prompt tokens
+                # in the final chunk. We take this count to be ground truth because
+                # it's consistent with the reported total tokens. So we need to
+                # ensure this chunk compensates (the subtract_usage funcction floors
+                # at zero).
+                lc_usage["input_tokens"] = cumulative_usage[
+                    "input_tokens"
+                ] - prev_usage.get("input_tokens", 0)
         else:
             lc_usage = None
     except AttributeError:
@@ -816,8 +824,7 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
         To use, you must have either:
 
             1. The ``GOOGLE_API_KEY`` environment variable set with your API key, or
-            2. Pass your API key using the google_api_key kwarg
-            to the ChatGoogleGenerativeAI constructor.
+            2. Pass your API key using the ``google_api_key`` kwarg to the ChatGoogleGenerativeAI constructor.
 
         .. code-block:: python
 
@@ -885,8 +892,8 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
 
     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.
-        Below are two examples: caching a single file directly and caching multiple files using `Part`.
+        The ``cached_content`` parameter accepts a cache name created via the Google Generative AI API.
+        Below are two examples: caching a single file directly and caching multiple files using ``Part``.
 
         Single File Example:
         This caches a single file and queries it.
@@ -1132,12 +1139,15 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
 
     response_mime_type: Optional[str] = None
     """Optional. Output response mimetype of the generated candidate text. Only
-        supported in Gemini 1.5 and later models. Supported mimetype:
-            * "text/plain": (default) Text output.
-            * "application/json": JSON response in the candidates.
-            * "text/x.enum": Enum in plain text.
-       The model also needs to be prompted to output the appropriate response
-       type, otherwise the behavior is undefined. This is a preview feature.
+    supported in Gemini 1.5 and later models.
+    
+    Supported mimetype:
+        * ``'text/plain'``: (default) Text output.
+        * ``'application/json'``: JSON response in the candidates.
+        * ``'text/x.enum'``: Enum in plain text.
+    
+    The model also needs to be prompted to output the appropriate response
+    type, otherwise the behavior is undefined. This is a preview feature.
     """
 
     response_schema: Optional[Dict[str, Any]] = None
@@ -1222,9 +1232,7 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
         if self.top_k is not None and self.top_k <= 0:
             raise ValueError("top_k must be positive")
 
-        if not any(
-            self.model.startswith(prefix) for prefix in ("models/", "tunedModels/")
-        ):
+        if not any(self.model.startswith(prefix) for prefix in ("models/",)):
             self.model = f"models/{self.model}"
 
         additional_headers = self.additional_headers or {}
@@ -1320,7 +1328,7 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
 
             else:
                 raise ValueError(
-                    "Tools are already defined." "code_execution tool can't be defined"
+                    "Tools are already defined.code_execution tool can't be defined"
                 )
 
         return super().invoke(input, config, stop=stop, **kwargs)
@@ -1522,7 +1530,7 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
             metadata=self.default_metadata,
         )
 
-        prev_usage_metadata: UsageMetadata | None = None
+        prev_usage_metadata: UsageMetadata | None = None  # cumulative usage
         for chunk in response:
             _chat_result = _response_to_result(
                 chunk, stream=True, prev_usage=prev_usage_metadata
@@ -1530,21 +1538,10 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
             gen = cast(ChatGenerationChunk, _chat_result.generations[0])
             message = cast(AIMessageChunk, gen.message)
 
-            curr_usage_metadata: UsageMetadata | dict[str, int] = (
-                message.usage_metadata or {}
-            )
-
             prev_usage_metadata = (
                 message.usage_metadata
                 if prev_usage_metadata is None
-                else UsageMetadata(
-                    input_tokens=prev_usage_metadata.get("input_tokens", 0)
-                    + curr_usage_metadata.get("input_tokens", 0),
-                    output_tokens=prev_usage_metadata.get("output_tokens", 0)
-                    + curr_usage_metadata.get("output_tokens", 0),
-                    total_tokens=prev_usage_metadata.get("total_tokens", 0)
-                    + curr_usage_metadata.get("total_tokens", 0),
-                )
+                else add_usage(prev_usage_metadata, message.usage_metadata)
             )
 
             if run_manager:
@@ -1594,7 +1591,7 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
                 tool_choice=tool_choice,
                 **kwargs,
             )
-            prev_usage_metadata: UsageMetadata | None = None
+            prev_usage_metadata: UsageMetadata | None = None  # cumulative usage
             async for chunk in await _achat_with_retry(
                 request=request,
                 generation_method=self.async_client.stream_generate_content,
@@ -1607,21 +1604,10 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
                 gen = cast(ChatGenerationChunk, _chat_result.generations[0])
                 message = cast(AIMessageChunk, gen.message)
 
-                curr_usage_metadata: UsageMetadata | dict[str, int] = (
-                    message.usage_metadata or {}
-                )
-
                 prev_usage_metadata = (
                     message.usage_metadata
                     if prev_usage_metadata is None
-                    else UsageMetadata(
-                        input_tokens=prev_usage_metadata.get("input_tokens", 0)
-                        + curr_usage_metadata.get("input_tokens", 0),
-                        output_tokens=prev_usage_metadata.get("output_tokens", 0)
-                        + curr_usage_metadata.get("output_tokens", 0),
-                        total_tokens=prev_usage_metadata.get("total_tokens", 0)
-                        + curr_usage_metadata.get("total_tokens", 0),
-                    )
+                    else add_usage(prev_usage_metadata, message.usage_metadata)
                 )
 
                 if run_manager:

{langchain_google_genai-2.1.6 → langchain_google_genai-2.1.8}/langchain_google_genai/embeddings.py

@@ -17,7 +17,10 @@ from langchain_google_genai._common import (
     GoogleGenerativeAIError,
     get_client_info,
 )
-from langchain_google_genai._genai_extension import build_generative_service
+from langchain_google_genai._genai_extension import (
+    build_generative_async_service,
+    build_generative_service,
+)
 
 _MAX_TOKENS_PER_BATCH = 20000
 _DEFAULT_BATCH_SIZE = 100
@@ -29,8 +32,8 @@ class GoogleGenerativeAIEmbeddings(BaseModel, Embeddings):
     To use, you must have either:
 
         1. The ``GOOGLE_API_KEY`` environment variable set with your API key, or
-        2. Pass your API key using the google_api_key kwarg
-        to the GoogleGenerativeAIEmbeddings constructor.
+        2. Pass your API key using the google_api_key kwarg to the
+        GoogleGenerativeAIEmbeddings constructor.
 
     Example:
         .. code-block:: python
@@ -42,16 +45,17 @@ class GoogleGenerativeAIEmbeddings(BaseModel, Embeddings):
     """
 
     client: Any = None  #: :meta private:
+    async_client: Any = None  #: :meta private:
     model: str = Field(
         ...,
         description="The name of the embedding model to use. "
-        "Example: models/embedding-001",
+        "Example: ``'models/embedding-001'``",
     )
     task_type: Optional[str] = Field(
         default=None,
         description="The task type. Valid options include: "
-        "task_type_unspecified, retrieval_query, retrieval_document, "
-        "semantic_similarity, classification, and clustering",
+        "``'task_type_unspecified'``, ``'retrieval_query'``, ``'retrieval_document'``, "
+        "``'semantic_similarity'``, ``'classification'``, and ``'clustering'``",
     )
     google_api_key: Optional[SecretStr] = Field(
         default_factory=secret_from_env("GOOGLE_API_KEY", default=None),
@@ -76,7 +80,7 @@ class GoogleGenerativeAIEmbeddings(BaseModel, Embeddings):
     )
     transport: Optional[str] = Field(
         default=None,
-        description="A string, one of: [`rest`, `grpc`, `grpc_asyncio`].",
+        description="A string, one of: [``'rest'``, ``'grpc'``, ``'grpc_asyncio'``].",
     )
     request_options: Optional[Dict] = Field(
         default=None,
@@ -93,6 +97,9 @@ class GoogleGenerativeAIEmbeddings(BaseModel, Embeddings):
             google_api_key = self.google_api_key
         client_info = get_client_info("GoogleGenerativeAIEmbeddings")
 
+        if not any(self.model.startswith(prefix) for prefix in ("models/",)):
+            self.model = f"models/{self.model}"
+
         self.client = build_generative_service(
             credentials=self.credentials,
             api_key=google_api_key,
@@ -100,6 +107,13 @@ class GoogleGenerativeAIEmbeddings(BaseModel, Embeddings):
             client_options=self.client_options,
             transport=self.transport,
         )
+        self.async_client = build_generative_async_service(
+            credentials=self.credentials,
+            api_key=google_api_key,
+            client_info=client_info,
+            client_options=self.client_options,
+            transport=self.transport,
+        )
         return self
 
     @staticmethod
@@ -166,12 +180,12 @@ class GoogleGenerativeAIEmbeddings(BaseModel, Embeddings):
     def _prepare_request(
         self,
         text: str,
+        *,
         task_type: Optional[str] = None,
         title: Optional[str] = None,
         output_dimensionality: Optional[int] = None,
     ) -> EmbedContentRequest:
         task_type = self.task_type or task_type or "RETRIEVAL_DOCUMENT"
-        # https://ai.google.dev/api/rest/v1/models/batchEmbedContents#EmbedContentRequest
         request = EmbedContentRequest(
             content={"parts": [{"text": text}]},
             model=self.model,
@@ -190,17 +204,17 @@ class GoogleGenerativeAIEmbeddings(BaseModel, Embeddings):
         titles: Optional[List[str]] = None,
         output_dimensionality: Optional[int] = None,
     ) -> List[List[float]]:
-        """Embed a list of strings. Google Generative AI currently
-        sets a max batch size of 100 strings.
+        """Embed a list of strings using the `batch endpoint <https://ai.google.dev/api/embeddings#method:-models.batchembedcontents>`__.
+
+        Google Generative AI currently sets a max batch size of 100 strings.
 
         Args:
             texts: List[str] The list of strings to embed.
             batch_size: [int] The batch size of embeddings to send to the model
-            task_type: task_type (https://ai.google.dev/api/rest/v1/TaskType)
+            task_type: `task_type <https://ai.google.dev/api/embeddings#tasktype>`__
             titles: An optional list of titles for texts provided.
-            Only applicable when TaskType is RETRIEVAL_DOCUMENT.
-            output_dimensionality: Optional reduced dimension for the output embedding.
-            https://ai.google.dev/api/rest/v1/models/batchEmbedContents#EmbedContentRequest
+              Only applicable when TaskType is ``'RETRIEVAL_DOCUMENT'``.
+            output_dimensionality: Optional `reduced dimension for the output embedding <https://ai.google.dev/api/embeddings#EmbedContentRequest>`__.
         Returns:
             List of embeddings, one for each text.
         """
@@ -237,26 +251,26 @@ class GoogleGenerativeAIEmbeddings(BaseModel, Embeddings):
     def embed_query(
         self,
         text: str,
+        *,
         task_type: Optional[str] = None,
         title: Optional[str] = None,
         output_dimensionality: Optional[int] = None,
     ) -> List[float]:
-        """Embed a text, using the non-batch endpoint:
-        https://ai.google.dev/api/rest/v1/models/embedContent#EmbedContentRequest
+        """Embed a text, using the `non-batch endpoint <https://ai.google.dev/api/embeddings#method:-models.embedcontent>`__.
 
         Args:
             text: The text to embed.
-            task_type: task_type (https://ai.google.dev/api/rest/v1/TaskType)
+            task_type: `task_type <https://ai.google.dev/api/embeddings#tasktype>`__
             title: An optional title for the text.
-            Only applicable when TaskType is RETRIEVAL_DOCUMENT.
-            output_dimensionality: Optional reduced dimension for the output embedding.
+              Only applicable when TaskType is ``'RETRIEVAL_DOCUMENT'``.
+            output_dimensionality: Optional `reduced dimension for the output embedding <https://ai.google.dev/api/embeddings#EmbedContentRequest>`__.
 
         Returns:
             Embedding for the text.
         """
         task_type_to_use = task_type if task_type else self.task_type
         if task_type_to_use is None:
-            task_type_to_use = "RETRIEVAL_QUERY"  # Default to RETRIEVAL_QUERY
+            task_type_to_use = "RETRIEVAL_QUERY"
         try:
             request: EmbedContentRequest = self._prepare_request(
                 text=text,
@@ -268,3 +282,93 @@ class GoogleGenerativeAIEmbeddings(BaseModel, Embeddings):
         except Exception as e:
             raise GoogleGenerativeAIError(f"Error embedding content: {e}") from e
         return list(result.embedding.values)
+
+    async def aembed_documents(
+        self,
+        texts: List[str],
+        *,
+        batch_size: int = _DEFAULT_BATCH_SIZE,
+        task_type: Optional[str] = None,
+        titles: Optional[List[str]] = None,
+        output_dimensionality: Optional[int] = None,
+    ) -> List[List[float]]:
+        """Embed a list of strings using the `batch endpoint <https://ai.google.dev/api/embeddings#method:-models.batchembedcontents>`__.
+
+        Google Generative AI currently sets a max batch size of 100 strings.
+
+        Args:
+            texts: List[str] The list of strings to embed.
+            batch_size: [int] The batch size of embeddings to send to the model
+            task_type: `task_type <https://ai.google.dev/api/embeddings#tasktype>`__
+            titles: An optional list of titles for texts provided.
+                Only applicable when TaskType is ``'RETRIEVAL_DOCUMENT'``.
+            output_dimensionality: Optional `reduced dimension for the output embedding <https://ai.google.dev/api/embeddings#EmbedContentRequest>`__.
+        Returns:
+            List of embeddings, one for each text.
+        """
+        embeddings: List[List[float]] = []
+        batch_start_index = 0
+        for batch in GoogleGenerativeAIEmbeddings._prepare_batches(texts, batch_size):
+            if titles:
+                titles_batch = titles[
+                    batch_start_index : batch_start_index + len(batch)
+                ]
+                batch_start_index += len(batch)
+            else:
+                titles_batch = [None] * len(batch)  # type: ignore[list-item]
+
+            requests = [
+                self._prepare_request(
+                    text=text,
+                    task_type=task_type,
+                    title=title,
+                    output_dimensionality=output_dimensionality,
+                )
+                for text, title in zip(batch, titles_batch)
+            ]
+
+            try:
+                result = await self.async_client.batch_embed_contents(
+                    BatchEmbedContentsRequest(requests=requests, model=self.model)
+                )
+            except Exception as e:
+                raise GoogleGenerativeAIError(f"Error embedding content: {e}") from e
+            embeddings.extend([list(e.values) for e in result.embeddings])
+        return embeddings
+
+    async def aembed_query(
+        self,
+        text: str,
+        *,
+        task_type: Optional[str] = None,
+        title: Optional[str] = None,
+        output_dimensionality: Optional[int] = None,
+    ) -> List[float]:
+        """Embed a text, using the `non-batch endpoint <https://ai.google.dev/api/embeddings#method:-models.embedcontent>`__.
+
+        Args:
+            text: The text to embed.
+            task_type: `task_type <https://ai.google.dev/api/embeddings#tasktype>`__
+            title: An optional title for the text.
+                Only applicable when TaskType is ``'RETRIEVAL_DOCUMENT'``.
+            output_dimensionality: Optional `reduced dimension for the output embedding <https://ai.google.dev/api/embeddings#EmbedContentRequest>`__.
+
+        Returns:
+            Embedding for the text.
+        """
+        task_type_to_use = task_type if task_type else self.task_type
+        if task_type_to_use is None:
+            task_type_to_use = "RETRIEVAL_QUERY"
+        try:
+            request: EmbedContentRequest = self._prepare_request(
+                text=text,
+                task_type=task_type,
+                title=title,
+                output_dimensionality=output_dimensionality,
+            )
+            result: EmbedContentResponse = await self.async_client.embed_content(
+                request
+            )
+        except Exception as e:
+            raise GoogleGenerativeAIError(f"Error embedding content: {e}") from e
+        return list(result.embedding.values)

{langchain_google_genai-2.1.6 → langchain_google_genai-2.1.8}/langchain_google_genai/llms.py

@@ -63,6 +63,9 @@ class GoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseLLM):
     def validate_environment(self) -> Self:
         """Validates params and passes them to google-generativeai package."""
 
+        if not any(self.model.startswith(prefix) for prefix in ("models/",)):
+            self.model = f"models/{self.model}"
+
         self.client = ChatGoogleGenerativeAI(
             api_key=self.google_api_key,
             credentials=self.credentials,
@@ -86,6 +89,15 @@ class GoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseLLM):
         """Get standard params for tracing."""
         ls_params = super()._get_ls_params(stop=stop, **kwargs)
         ls_params["ls_provider"] = "google_genai"
+
+        models_prefix = "models/"
+        ls_model_name = (
+            self.model[len(models_prefix) :]
+            if self.model and self.model.startswith(models_prefix)
+            else self.model
+        )
+        ls_params["ls_model_name"] = ls_model_name
+
         if ls_max_tokens := kwargs.get("max_output_tokens", self.max_output_tokens):
             ls_params["ls_max_tokens"] = ls_max_tokens
         return ls_params

{langchain_google_genai-2.1.6 → langchain_google_genai-2.1.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "langchain-google-genai"
-version = "2.1.6"
+version = "2.1.8"
 description = "An integration package connecting Google's genai package and LangChain"
 authors = []
 readme = "README.md"
@@ -12,7 +12,7 @@ license = "MIT"
 
 [tool.poetry.dependencies]
 python = ">=3.9,<4.0"
-langchain-core = "^0.3.66"
+langchain-core = "^0.3.68"
 google-ai-generativelanguage = "^0.6.18"
 pydantic = ">=2,<3"
 filetype = "^1.2.0"
@@ -29,7 +29,7 @@ pytest-watcher = "^0.3.4"
 pytest-asyncio = "^0.21.1"
 pytest-retry = "^1.7.0"
 numpy = ">=1.26.2"
-langchain-tests = "0.3.19"
+langchain-tests = "0.3.20"
 
 [tool.codespell]
 ignore-words-list = "rouge"
@@ -58,7 +58,7 @@ ruff = "^0.1.5"
 
 [tool.poetry.group.typing.dependencies]
 mypy = "^1.10"
-types-requests = "^2.28.11.5"
+types-requests = "^2.31.0"
 types-google-cloud-ndb = "^2.2.0.1"
 types-protobuf = "^4.24.0.20240302"
 numpy = ">=1.26.2"
@@ -68,7 +68,7 @@ numpy = ">=1.26.2"
 optional = true
 
 [tool.poetry.group.dev.dependencies]
-types-requests = "^2.31.0.10"
+types-requests = "^2.31.0"
 types-google-cloud-ndb = "^2.2.0.1"
 
 [tool.ruff.lint]