langchain-google-genai 1.0.5__tar.gz → 1.0.6__tar.gz

{langchain_google_genai-1.0.5 → langchain_google_genai-1.0.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: langchain-google-genai
-Version: 1.0.5
+Version: 1.0.6
 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
 Provides-Extra: images
 Requires-Dist: google-generativeai (>=0.5.2,<0.6.0)
-Requires-Dist: langchain-core (>=0.2.0,<0.3)
+Requires-Dist: langchain-core (>=0.2.2,<0.3)
 Requires-Dist: pillow (>=10.1.0,<11.0.0) ; extra == "images"
 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-1.0.5 → langchain_google_genai-1.0.6}/langchain_google_genai/chat_models.py

@@ -51,7 +51,7 @@ from langchain_core.callbacks.manager import (
     CallbackManagerForLLMRun,
 )
 from langchain_core.language_models import LanguageModelInput
-from langchain_core.language_models.chat_models import BaseChatModel
+from langchain_core.language_models.chat_models import BaseChatModel, LangSmithParams
 from langchain_core.messages import (
     AIMessage,
     AIMessageChunk,
@@ -64,6 +64,7 @@ from langchain_core.messages import (
     ToolCallChunk,
     ToolMessage,
 )
+from langchain_core.messages.ai import UsageMetadata
 from langchain_core.output_parsers.openai_tools import parse_tool_calls
 from langchain_core.outputs import ChatGeneration, ChatGenerationChunk, ChatResult
 from langchain_core.pydantic_v1 import Field, SecretStr, root_validator
@@ -526,6 +527,22 @@ def _response_to_result(
     """Converts a PaLM API response into a LangChain ChatResult."""
     llm_output = {"prompt_feedback": proto.Message.to_dict(response.prompt_feedback)}
 
+    # 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
+        if input_tokens + output_tokens + total_tokens > 0:
+            lc_usage = UsageMetadata(
+                input_tokens=input_tokens,
+                output_tokens=output_tokens,
+                total_tokens=total_tokens,
+            )
+        else:
+            lc_usage = None
+    except AttributeError:
+        lc_usage = None
+
     generations: List[ChatGeneration] = []
 
     for candidate in response.candidates:
@@ -536,9 +553,11 @@ def _response_to_result(
             proto.Message.to_dict(safety_rating, use_integers_for_enums=False)
             for safety_rating in candidate.safety_ratings
         ]
+        message = _parse_response_candidate(candidate, streaming=stream)
+        message.usage_metadata = lc_usage
         generations.append(
             (ChatGenerationChunk if stream else ChatGeneration)(
-                message=_parse_response_candidate(candidate, streaming=stream),
+                message=message,
                 generation_info=generation_info,
             )
         )
@@ -678,6 +697,23 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
             "safety_settings": self.safety_settings,
         }
 
+    def _get_ls_params(
+        self, stop: Optional[List[str]] = None, **kwargs: Any
+    ) -> LangSmithParams:
+        """Get standard params for tracing."""
+        params = self._get_invocation_params(stop=stop, **kwargs)
+        ls_params = LangSmithParams(
+            ls_provider="google_genai",
+            ls_model_name=self.model,
+            ls_model_type="chat",
+            ls_temperature=params.get("temperature", self.temperature),
+        )
+        if ls_max_tokens := params.get("max_output_tokens", self.max_output_tokens):
+            ls_params["ls_max_tokens"] = ls_max_tokens
+        if ls_stop := stop or params.get("stop", None):
+            ls_params["ls_stop"] = ls_stop
+        return ls_params
+
     def _prepare_params(
         self,
         stop: Optional[List[str]],

{langchain_google_genai-1.0.5 → langchain_google_genai-1.0.6}/langchain_google_genai/embeddings.py

@@ -1,3 +1,5 @@
+import re
+import string
 from typing import Any, Dict, List, Optional
 
 # TODO: remove ignore once the google package is published with types
@@ -15,6 +17,9 @@ from langchain_google_genai._common import (
 )
 from langchain_google_genai._genai_extension import build_generative_service
 
+_MAX_TOKENS_PER_BATCH = 20000
+_DEFAULT_BATCH_SIZE = 100
+
 
 class GoogleGenerativeAIEmbeddings(BaseModel, Embeddings):
     """`Google Generative AI Embeddings`.
@@ -91,6 +96,67 @@ class GoogleGenerativeAIEmbeddings(BaseModel, Embeddings):
         )
         return values
 
+    @staticmethod
+    def _split_by_punctuation(text: str) -> List[str]:
+        """Splits a string by punctuation and whitespace characters."""
+        split_by = string.punctuation + "\t\n "
+        pattern = f"([{split_by}])"
+        # Using re.split to split the text based on the pattern
+        return [segment for segment in re.split(pattern, text) if segment]
+
+    @staticmethod
+    def _prepare_batches(texts: List[str], batch_size: int) -> List[List[str]]:
+        """Splits texts in batches based on current maximum batch size
+        and maximum tokens per request.
+        """
+        text_index = 0
+        texts_len = len(texts)
+        batch_token_len = 0
+        batches: List[List[str]] = []
+        current_batch: List[str] = []
+        if texts_len == 0:
+            return []
+        while text_index < texts_len:
+            current_text = texts[text_index]
+            # Number of tokens per a text is conservatively estimated
+            # as 2 times number of words, punctuation and whitespace characters.
+            # Using `count_tokens` API will make batching too expensive.
+            # Utilizing a tokenizer, would add a dependency that would not
+            # necessarily be reused by the application using this class.
+            current_text_token_cnt = (
+                len(GoogleGenerativeAIEmbeddings._split_by_punctuation(current_text))
+                * 2
+            )
+            end_of_batch = False
+            if current_text_token_cnt > _MAX_TOKENS_PER_BATCH:
+                # Current text is too big even for a single batch.
+                # Such request will fail, but we still make a batch
+                # so that the app can get the error from the API.
+                if len(current_batch) > 0:
+                    # Adding current batch if not empty.
+                    batches.append(current_batch)
+                current_batch = [current_text]
+                text_index += 1
+                end_of_batch = True
+            elif (
+                batch_token_len + current_text_token_cnt > _MAX_TOKENS_PER_BATCH
+                or len(current_batch) == batch_size
+            ):
+                end_of_batch = True
+            else:
+                if text_index == texts_len - 1:
+                    # Last element - even though the batch may be not big,
+                    # we still need to make it.
+                    end_of_batch = True
+                batch_token_len += current_text_token_cnt
+                current_batch.append(current_text)
+                text_index += 1
+            if end_of_batch:
+                batches.append(current_batch)
+                current_batch = []
+                batch_token_len = 0
+        return batches
+
     def _prepare_request(
         self,
         text: str,
@@ -112,12 +178,14 @@ class GoogleGenerativeAIEmbeddings(BaseModel, Embeddings):
     def embed_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. Vertex AI currently
-        sets a max batch size of 5 strings.
+        """Embed a list of strings. Google Generative AI currently
+        sets a max batch size of 100 strings.
 
         Args:
             texts: List[str] The list of strings to embed.
@@ -127,28 +195,38 @@ class GoogleGenerativeAIEmbeddings(BaseModel, Embeddings):
             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
-
         Returns:
             List of embeddings, one for each text.
         """
-        titles = titles if titles else [None] * len(texts)  # 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(texts, titles)
-        ]
+        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]
 
-        try:
-            result = self.client.batch_embed_contents(
-                BatchEmbedContentsRequest(requests=requests, model=self.model)
-            )
-        except Exception as e:
-            raise GoogleGenerativeAIError(f"Error embedding content: {e}") from e
-        return [e.values for e in result.embeddings]
+            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 = self.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
 
     def embed_query(
         self,

{langchain_google_genai-1.0.5 → langchain_google_genai-1.0.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "langchain-google-genai"
-version = "1.0.5"
+version = "1.0.6"
 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.2.0,<0.3"
+langchain-core = ">=0.2.2,<0.3"
 google-generativeai = "^0.5.2"
 pillow = { version = "^10.1.0", optional = true }
 
@@ -32,6 +32,9 @@ pytest-asyncio = "^0.21.1"
 numpy = "^1.26.2"
 langchain-core = { git = "https://github.com/langchain-ai/langchain.git", subdirectory = "libs/core" }
 
+[tool.codespell]
+ignore-words-list = "rouge"
+
 [tool.poetry.group.codespell]
 optional = true