langchain-google-genai 1.0.3__py3-none-any.whl → 1.0.4__py3-none-any.whl

langchain_google_genai/__init__.py

@@ -35,7 +35,7 @@ llm.invoke("Sing a ballad of LangChain.")
 ## Using LLMs
 
 The package also supports generating text with Google's models.
-    
+
 ```python
 from langchain_google_genai import GoogleGenerativeAI
 

langchain_google_genai/_common.py

@@ -1,4 +1,52 @@
+from importlib import metadata
+from typing import Optional, Tuple, TypedDict
+
+from google.api_core.gapic_v1.client_info import ClientInfo
+
+from langchain_google_genai._enums import HarmBlockThreshold, HarmCategory
+
+
 class GoogleGenerativeAIError(Exception):
     """
     Custom exception class for errors associated with the `Google GenAI` API.
     """
+
+
+def get_user_agent(module: Optional[str] = None) -> Tuple[str, str]:
+    r"""Returns a custom user agent header.
+
+    Args:
+        module (Optional[str]):
+            Optional. The module for a custom user agent header.
+    Returns:
+        Tuple[str, str]
+    """
+    try:
+        langchain_version = metadata.version("langchain-google-genai")
+    except metadata.PackageNotFoundError:
+        langchain_version = "0.0.0"
+    client_library_version = (
+        f"{langchain_version}-{module}" if module else langchain_version
+    )
+    return client_library_version, f"langchain-google-genai/{client_library_version}"
+
+
+def get_client_info(module: Optional[str] = None) -> "ClientInfo":
+    r"""Returns a client info object with a custom user agent header.
+
+    Args:
+        module (Optional[str]):
+            Optional. The module for a custom user agent header.
+    Returns:
+        google.api_core.gapic_v1.client_info.ClientInfo
+    """
+    client_library_version, user_agent = get_user_agent(module)
+    return ClientInfo(
+        client_library_version=client_library_version,
+        user_agent=user_agent,
+    )
+
+
+class SafetySettingDict(TypedDict):
+    category: HarmCategory
+    threshold: HarmBlockThreshold

langchain_google_genai/_enums.py

@@ -1,6 +1,6 @@
-from google.generativeai.types.safety_types import (  # type: ignore
-    HarmBlockThreshold,
-    HarmCategory,
-)
+import google.ai.generativelanguage_v1beta as genai
+
+HarmBlockThreshold = genai.SafetySetting.HarmBlockThreshold
+HarmCategory = genai.HarmCategory
 
 __all__ = ["HarmBlockThreshold", "HarmCategory"]

langchain_google_genai/_function_utils.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 from typing import (
     Any,
+    Callable,
     Dict,
     List,
     Literal,
@@ -10,15 +11,16 @@ from typing import (
     Type,
     TypedDict,
     Union,
+    cast,
 )
 
 import google.ai.generativelanguage as glm
-from google.generativeai.types import Tool as GoogleTool  # type: ignore[import]
-from google.generativeai.types.content_types import (  # type: ignore[import]
-    FunctionCallingConfigType,
-    FunctionDeclarationType,
-    ToolDict,
-    ToolType,
+from google.ai.generativelanguage import (
+    FunctionCallingConfig,
+    FunctionDeclaration,
+)
+from google.ai.generativelanguage import (
+    Tool as GoogleTool,
 )
 from langchain_core.pydantic_v1 import BaseModel
 from langchain_core.tools import BaseTool
@@ -36,51 +38,41 @@ TYPE_ENUM = {
 
 TYPE_ENUM_REVERSE = {v: k for k, v in TYPE_ENUM.items()}
 
+_FunctionDeclarationLike = Union[
+    BaseTool, Type[BaseModel], dict, Callable, FunctionDeclaration
+]
+
+
+class _ToolDict(TypedDict):
+    function_declarations: Sequence[_FunctionDeclarationLike]
+
 
 def convert_to_genai_function_declarations(
     tool: Union[
-        GoogleTool, ToolDict, FunctionDeclarationType, Sequence[FunctionDeclarationType]
+        GoogleTool,
+        _ToolDict,
+        _FunctionDeclarationLike,
+        Sequence[_FunctionDeclarationLike],
     ],
-) -> ToolType:
-    """Convert any tool-like object to a ToolType.
-
-    https://github.com/google-gemini/generative-ai-python/blob/668695ebe3e9de496a36eeb95cb2ed2faba9b939/google/generativeai/types/content_types.py#L574
-    """
+) -> GoogleTool:
     if isinstance(tool, GoogleTool):
-        return tool
-    # check whether a dict is supported by glm, otherwise we parse it explicitly
-    if isinstance(tool, dict):
-        first_function_declaration = tool.get("function_declarations", [None])[0]
-        if isinstance(first_function_declaration, glm.FunctionDeclaration):
-            return tool
-        schema = None
-        try:
-            schema = first_function_declaration.parameters
-        except AttributeError:
-            pass
-        if schema is None:
-            schema = first_function_declaration.get("parameters")
-        if schema is None or isinstance(schema, glm.Schema):
-            return tool
-        return glm.Tool(
+        return cast(GoogleTool, tool)
+    if isinstance(tool, type) and issubclass(tool, BaseModel):
+        return GoogleTool(function_declarations=[_convert_to_genai_function(tool)])
+    if callable(tool):
+        return _convert_tool_to_genai_function(callable_as_lc_tool()(tool))
+    if isinstance(tool, list):
+        return convert_to_genai_function_declarations({"function_declarations": tool})
+    if isinstance(tool, dict) and "function_declarations" in tool:
+        return GoogleTool(
             function_declarations=[
                 _convert_to_genai_function(fc) for fc in tool["function_declarations"]
             ],
         )
-    elif isinstance(tool, type) and issubclass(tool, BaseModel):
-        return glm.Tool(function_declarations=[_convert_to_genai_function(tool)])
-    elif callable(tool):
-        return _convert_tool_to_genai_function(callable_as_lc_tool()(tool))
-    elif isinstance(tool, list):
-        return glm.Tool(
-            function_declarations=[_convert_to_genai_function(fc) for fc in tool]
-        )
-    return glm.Tool(function_declarations=[_convert_to_genai_function(tool)])
+    return GoogleTool(function_declarations=[_convert_to_genai_function(tool)])  # type: ignore[arg-type]
 
 
-def tool_to_dict(tool: Union[glm.Tool, GoogleTool]) -> ToolDict:
-    if isinstance(tool, GoogleTool):
-        tool = tool._proto
+def tool_to_dict(tool: GoogleTool) -> _ToolDict:
     function_declarations = []
     for function_declaration_proto in tool.function_declarations:
         properties: Dict[str, Any] = {}
@@ -108,7 +100,7 @@ def tool_to_dict(tool: Union[glm.Tool, GoogleTool]) -> ToolDict:
     return {"function_declarations": function_declarations}
 
 
-def _convert_to_genai_function(fc: FunctionDeclarationType) -> glm.FunctionDeclaration:
+def _convert_to_genai_function(fc: _FunctionDeclarationLike) -> FunctionDeclaration:
     if isinstance(fc, BaseTool):
         return _convert_tool_to_genai_function(fc)
     elif isinstance(fc, type) and issubclass(fc, BaseModel):
@@ -116,10 +108,9 @@ def _convert_to_genai_function(fc: FunctionDeclarationType) -> glm.FunctionDecla
     elif callable(fc):
         return _convert_tool_to_genai_function(callable_as_lc_tool()(fc))
     elif isinstance(fc, dict):
-        return glm.FunctionDeclaration(
-            name=fc["name"],
-            description=fc.get("description"),
-            parameters={
+        formatted_fc = {"name": fc["name"], "description": fc.get("description")}
+        if "parameters" in fc:
+            formatted_fc["parameters"] = {
                 "properties": {
                     k: {
                         "type_": TYPE_ENUM[v["type"]],
@@ -127,19 +118,19 @@ def _convert_to_genai_function(fc: FunctionDeclarationType) -> glm.FunctionDecla
                     }
                     for k, v in fc["parameters"]["properties"].items()
                 },
-                "required": fc["parameters"].get("required", []),
+                "required": fc.get("parameters", []).get("required", []),
                 "type_": TYPE_ENUM[fc["parameters"]["type"]],
-            },
-        )
+            }
+        return FunctionDeclaration(**formatted_fc)
     else:
         raise ValueError(f"Unsupported function call type {fc}")
 
 
-def _convert_tool_to_genai_function(tool: BaseTool) -> glm.FunctionDeclaration:
+def _convert_tool_to_genai_function(tool: BaseTool) -> FunctionDeclaration:
     if tool.args_schema:
         schema = dereference_refs(tool.args_schema.schema())
         schema.pop("definitions", None)
-        return glm.FunctionDeclaration(
+        return FunctionDeclaration(
             name=tool.name or schema["title"],
             description=tool.description or schema["description"],
             parameters={
@@ -155,7 +146,7 @@ def _convert_tool_to_genai_function(tool: BaseTool) -> glm.FunctionDeclaration:
             },
         )
     else:
-        return glm.FunctionDeclaration(
+        return FunctionDeclaration(
             name=tool.name,
             description=tool.description,
             parameters={
@@ -170,10 +161,10 @@ def _convert_tool_to_genai_function(tool: BaseTool) -> glm.FunctionDeclaration:
 
 def _convert_pydantic_to_genai_function(
     pydantic_model: Type[BaseModel],
-) -> glm.FunctionDeclaration:
+) -> FunctionDeclaration:
     schema = dereference_refs(pydantic_model.schema())
     schema.pop("definitions", None)
-    return glm.FunctionDeclaration(
+    return FunctionDeclaration(
         name=schema["title"],
         description=schema.get("description", ""),
         parameters={
@@ -195,8 +186,13 @@ _ToolChoiceType = Union[
 ]
 
 
+class _FunctionCallingConfigDict(TypedDict):
+    mode: Union[FunctionCallingConfig.Mode, str]
+    allowed_function_names: Optional[List[str]]
+
+
 class _ToolConfigDict(TypedDict):
-    function_calling_config: FunctionCallingConfigType
+    function_calling_config: _FunctionCallingConfigDict
 
 
 def _tool_choice_to_tool_config(

langchain_google_genai/_genai_extension.py

@@ -12,6 +12,12 @@ from typing import Any, Dict, Iterator, List, MutableSequence, Optional
 
 import google.ai.generativelanguage as genai
 import langchain_core
+from google.ai.generativelanguage_v1beta import (
+    GenerativeServiceAsyncClient as v1betaGenerativeServiceAsyncClient,
+)
+from google.ai.generativelanguage_v1beta import (
+    GenerativeServiceClient as v1betaGenerativeServiceClient,
+)
 from google.api_core import client_options as client_options_lib
 from google.api_core import exceptions as gapi_exception
 from google.api_core import gapic_v1
@@ -225,15 +231,66 @@ def build_semantic_retriever() -> genai.RetrieverServiceClient:
     )
 
 
-def build_generative_service() -> genai.GenerativeServiceClient:
-    credentials = _get_credentials()
-    return genai.GenerativeServiceClient(
+def _prepare_config(
+    credentials: Optional[credentials.Credentials] = None,
+    api_key: Optional[str] = None,
+    client_options: Optional[Dict[str, Any]] = None,
+    client_info: Optional[gapic_v1.client_info.ClientInfo] = None,
+    transport: Optional[str] = None,
+) -> Dict[str, Any]:
+    formatted_client_options = {"api_endpoint": _config.api_endpoint}
+    if client_options:
+        formatted_client_options.update(**client_options)
+    if not credentials and api_key:
+        formatted_client_options["api_key"] = api_key
+    elif not credentials and not api_key:
+        credentials = _get_credentials()
+    client_info = (
+        client_info
+        if client_info
+        else gapic_v1.client_info.ClientInfo(user_agent=_USER_AGENT)
+    )
+    config = {
+        "credentials": credentials,
+        "client_info": client_info,
+        "client_options": client_options_lib.ClientOptions(**formatted_client_options),
+        "transport": transport,
+    }
+    return {k: v for k, v in config.items() if v is not None}
+
+
+def build_generative_service(
+    credentials: Optional[credentials.Credentials] = None,
+    api_key: Optional[str] = None,
+    client_options: Optional[Dict[str, Any]] = None,
+    client_info: Optional[gapic_v1.client_info.ClientInfo] = None,
+    transport: Optional[str] = None,
+) -> v1betaGenerativeServiceClient:
+    config = _prepare_config(
         credentials=credentials,
-        client_info=gapic_v1.client_info.ClientInfo(user_agent=_USER_AGENT),
-        client_options=client_options_lib.ClientOptions(
-            api_endpoint=_config.api_endpoint
-        ),
+        api_key=api_key,
+        client_options=client_options,
+        transport=transport,
+        client_info=client_info,
+    )
+    return v1betaGenerativeServiceClient(**config)
+
+
+def build_generative_async_service(
+    credentials: Optional[credentials.Credentials],
+    api_key: Optional[str] = None,
+    client_options: Optional[Dict[str, Any]] = None,
+    client_info: Optional[gapic_v1.client_info.ClientInfo] = None,
+    transport: Optional[str] = None,
+) -> v1betaGenerativeServiceAsyncClient:
+    config = _prepare_config(
+        credentials=credentials,
+        api_key=api_key,
+        client_options=client_options,
+        transport=transport,
+        client_info=client_info,
     )
+    return v1betaGenerativeServiceAsyncClient(**config)
 
 
 def list_corpora(

langchain_google_genai/_image_utils.py

@@ -0,0 +1,187 @@
+from __future__ import annotations
+
+import base64
+import mimetypes
+import os
+import re
+from enum import Enum
+from typing import Any, Dict
+from urllib.parse import urlparse
+
+import requests
+from google.ai.generativelanguage_v1beta.types import Part
+
+
+class Route(Enum):
+    """Image Loading Route"""
+
+    BASE64 = 1
+    LOCAL_FILE = 2
+    URL = 3
+
+
+class ImageBytesLoader:
+    """Loads image bytes from multiple sources given a string.
+
+    Currently supported:
+        - B64 Encoded image string
+        - Local file path
+        - URL
+    """
+
+    def load_bytes(self, image_string: str) -> bytes:
+        """Routes to the correct loader based on the image_string.
+
+        Args:
+            image_string: Can be either:
+                    - B64 Encoded image string
+                    - Local file path
+                    - URL
+
+        Returns:
+            Image bytes.
+        """
+
+        route = self._route(image_string)
+
+        if route == Route.BASE64:
+            return self._bytes_from_b64(image_string)
+
+        if route == Route.URL:
+            return self._bytes_from_url(image_string)
+
+        if route == Route.LOCAL_FILE:
+            return self._bytes_from_file(image_string)
+
+        raise ValueError(
+            "Image string must be one of: Google Cloud Storage URI, "
+            "b64 encoded image string (data:image/...), valid image url, "
+            f"or existing local image file. Instead got '{image_string}'."
+        )
+
+    def load_part(self, image_string: str) -> Part:
+        """Gets Part for loading from Gemini.
+
+        Args:
+            image_string: Can be either:
+                    - B64 Encoded image string
+                    - Local file path
+                    - URL
+        """
+        route = self._route(image_string)
+
+        if route == Route.BASE64:
+            bytes_ = self._bytes_from_b64(image_string)
+
+        if route == Route.URL:
+            bytes_ = self._bytes_from_url(image_string)
+
+        if route == Route.LOCAL_FILE:
+            bytes_ = self._bytes_from_file(image_string)
+
+        inline_data: Dict[str, Any] = {"data": bytes_}
+        mime_type, _ = mimetypes.guess_type(image_string)
+        if mime_type:
+            inline_data["mime_type"] = mime_type
+
+        return Part(inline_data=inline_data)
+
+    def _route(self, image_string: str) -> Route:
+        if image_string.startswith("data:image/"):
+            return Route.BASE64
+
+        if self._is_url(image_string):
+            return Route.URL
+
+        if os.path.exists(image_string):
+            return Route.LOCAL_FILE
+
+        raise ValueError(
+            "Image string must be one of: "
+            "b64 encoded image string (data:image/...), valid image url, "
+            f"or existing local image file. Instead got '{image_string}'."
+        )
+
+    def _bytes_from_b64(self, base64_image: str) -> bytes:
+        """Gets image bytes from a base64 encoded string.
+
+        Args:
+            base64_image: Encoded image in b64 format.
+
+        Returns:
+            Image bytes
+        """
+
+        pattern = r"data:image/\w{2,4};base64,(.*)"
+        match = re.search(pattern, base64_image)
+
+        if match is not None:
+            encoded_string = match.group(1)
+            return base64.b64decode(encoded_string)
+
+        raise ValueError(f"Error in b64 encoded image. Must follow pattern: {pattern}")
+
+    def _bytes_from_file(self, file_path: str) -> bytes:
+        """Gets image bytes from a local file path.
+
+        Args:
+            file_path: Existing file path.
+
+        Returns:
+            Image bytes
+        """
+        with open(file_path, "rb") as image_file:
+            image_bytes = image_file.read()
+        return image_bytes
+
+    def _bytes_from_url(self, url: str) -> bytes:
+        """Gets image bytes from a public url.
+
+        Args:
+            url: Valid url.
+
+        Raises:
+            HTTP Error if there is one.
+
+        Returns:
+            Image bytes
+        """
+
+        response = requests.get(url)
+
+        if not response.ok:
+            response.raise_for_status()
+
+        return response.content
+
+    def _is_url(self, url_string: str) -> bool:
+        """Checks if a url is valid.
+
+        Args:
+            url_string: Url to check.
+
+        Returns:
+            Whether the url is valid.
+        """
+        try:
+            result = urlparse(url_string)
+            return all([result.scheme, result.netloc])
+        except Exception:
+            return False
+
+
+def image_bytes_to_b64_string(
+    image_bytes: bytes, encoding: str = "ascii", image_format: str = "png"
+) -> str:
+    """Encodes image bytes into a b64 encoded 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.
+
+    Returns:
+        B64 image encoded string.
+    """
+    encoded_bytes = base64.b64encode(image_bytes).decode(encoding)
+    return f"data:image/{image_format};base64,{encoded_bytes}"

langchain_google_genai/chat_models.py

@@ -23,14 +23,23 @@ from typing import (
 )
 from urllib.parse import urlparse
 
-import google.ai.generativelanguage as glm
 import google.api_core
 
 # TODO: remove ignore once the google package is published with types
-import google.generativeai as genai  # type: ignore[import]
 import proto  # type: ignore[import]
 import requests
-from google.generativeai.types import SafetySettingDict  # type: ignore[import]
+from google.ai.generativelanguage_v1beta.types import (
+    Candidate,
+    Content,
+    FunctionCall,
+    FunctionResponse,
+    GenerateContentRequest,
+    GenerateContentResponse,
+    GenerationConfig,
+    Part,
+    SafetySetting,
+    ToolConfig,
+)
 from google.generativeai.types import Tool as GoogleTool  # type: ignore[import]
 from google.generativeai.types.content_types import (  # type: ignore[import]
     FunctionDeclarationType,
@@ -56,7 +65,7 @@ from langchain_core.messages import (
 )
 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 SecretStr, root_validator
+from langchain_core.pydantic_v1 import Field, SecretStr, root_validator
 from langchain_core.runnables import Runnable
 from langchain_core.utils import get_from_dict_or_env
 from tenacity import (
@@ -67,7 +76,11 @@ from tenacity import (
     wait_exponential,
 )
 
-from langchain_google_genai._common import GoogleGenerativeAIError
+from langchain_google_genai._common import (
+    GoogleGenerativeAIError,
+    SafetySettingDict,
+    get_client_info,
+)
 from langchain_google_genai._function_utils import (
     _tool_choice_to_tool_config,
     _ToolChoiceType,
@@ -75,7 +88,10 @@ from langchain_google_genai._function_utils import (
     convert_to_genai_function_declarations,
     tool_to_dict,
 )
-from langchain_google_genai.llms import GoogleModelFamily, _BaseGoogleGenerativeAI
+from langchain_google_genai._image_utils import ImageBytesLoader
+from langchain_google_genai.llms import _BaseGoogleGenerativeAI
+
+from . import _genai_extension as genaix
 
 IMAGE_TYPES: Tuple = ()
 try:
@@ -279,18 +295,19 @@ def _url_to_pil(image_source: str) -> Image:
 
 def _convert_to_parts(
     raw_content: Union[str, Sequence[Union[str, dict]]],
-) -> List[genai.types.PartType]:
+) -> List[Part]:
     """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()
     for part in content:
         if isinstance(part, str):
-            parts.append(genai.types.PartDict(text=part))
+            parts.append(Part(text=part))
         elif isinstance(part, Mapping):
             # OpenAI Format
             if _is_openai_parts_format(part):
                 if part["type"] == "text":
-                    parts.append({"text": part["text"]})
+                    parts.append(Part(text=part["text"]))
                 elif part["type"] == "image_url":
                     img_url = part["image_url"]
                     if isinstance(img_url, dict):
@@ -299,7 +316,7 @@ def _convert_to_parts(
                                 f"Unrecognized message image format: {img_url}"
                             )
                         img_url = img_url["url"]
-                    parts.append({"inline_data": _url_to_pil(img_url)})
+                    parts.append(image_loader.load_part(img_url))
                 else:
                     raise ValueError(f"Unrecognized message part type: {part['type']}")
             else:
@@ -307,7 +324,7 @@ def _convert_to_parts(
                 logger.warning(
                     "Unrecognized message part format. Assuming it's a text part."
                 )
-                parts.append(part)
+                parts.append(Part(text=str(part)))
         else:
             # TODO: Maybe some of Google's native stuff
             # would hit this branch.
@@ -319,33 +336,36 @@ def _convert_to_parts(
 
 def _parse_chat_history(
     input_messages: Sequence[BaseMessage], convert_system_message_to_human: bool = False
-) -> Tuple[Optional[genai.types.ContentDict], List[genai.types.ContentDict]]:
-    messages: List[genai.types.MessageDict] = []
+) -> Tuple[Optional[Content], List[Content]]:
+    messages: List[Content] = []
 
     if convert_system_message_to_human:
         warnings.warn("Convert_system_message_to_human will be deprecated!")
 
-    system_instruction: Optional[genai.types.ContentDict] = None
+    system_instruction: Optional[Content] = None
     for i, message in enumerate(input_messages):
         if i == 0 and isinstance(message, SystemMessage):
-            system_instruction = _convert_to_parts(message.content)
+            system_instruction = Content(parts=_convert_to_parts(message.content))
             continue
         elif isinstance(message, AIMessage):
             role = "model"
             raw_function_call = message.additional_kwargs.get("function_call")
             if raw_function_call:
-                function_call = glm.FunctionCall(
+                function_call = FunctionCall(
                     {
                         "name": raw_function_call["name"],
                         "args": json.loads(raw_function_call["arguments"]),
                     }
                 )
-                parts = [glm.Part(function_call=function_call)]
+                parts = [Part(function_call=function_call)]
             else:
                 parts = _convert_to_parts(message.content)
         elif isinstance(message, HumanMessage):
             role = "user"
             parts = _convert_to_parts(message.content)
+            if i == 1 and convert_system_message_to_human and system_instruction:
+                parts = [p for p in system_instruction.parts] + parts
+                system_instruction = None
         elif isinstance(message, FunctionMessage):
             role = "user"
             response: Any
@@ -357,8 +377,8 @@ def _parse_chat_history(
                 except json.JSONDecodeError:
                     response = message.content  # leave as str representation
             parts = [
-                glm.Part(
-                    function_response=glm.FunctionResponse(
+                Part(
+                    function_response=FunctionResponse(
                         name=message.name,
                         response=(
                             {"output": response}
@@ -391,8 +411,8 @@ def _parse_chat_history(
                 except json.JSONDecodeError:
                     tool_response = message.content  # leave as str representation
             parts = [
-                glm.Part(
-                    function_response=glm.FunctionResponse(
+                Part(
+                    function_response=FunctionResponse(
                         name=name,
                         response=(
                             {"output": tool_response}
@@ -407,12 +427,12 @@ def _parse_chat_history(
                 f"Unexpected message with type {type(message)} at the position {i}."
             )
 
-        messages.append({"role": role, "parts": parts})
+        messages.append(Content(role=role, parts=parts))
     return system_instruction, messages
 
 
 def _parse_response_candidate(
-    response_candidate: glm.Candidate, streaming: bool = False
+    response_candidate: Candidate, streaming: bool = False
 ) -> AIMessage:
     content: Union[None, str, List[str]] = None
     additional_kwargs = {}
@@ -499,7 +519,7 @@ def _parse_response_candidate(
 
 
 def _response_to_result(
-    response: glm.GenerateContentResponse,
+    response: GenerateContentResponse,
     stream: bool = False,
 ) -> ChatResult:
     """Converts a PaLM API response into a LangChain ChatResult."""
@@ -557,6 +577,10 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
     """
 
     client: Any  #: :meta private:
+    async_client: Any  #: :meta private:
+    default_metadata: Sequence[Tuple[str, str]] = Field(
+        default_factory=list
+    )  #: :meta private:
 
     convert_system_message_to_human: bool = False
     """Whether to merge any leading SystemMessage into the following HumanMessage.
@@ -582,29 +606,6 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
     @root_validator()
     def validate_environment(cls, values: Dict) -> Dict:
         """Validates params and passes them to google-generativeai package."""
-        additional_headers = values.get("additional_headers") or {}
-        default_metadata = tuple(additional_headers.items())
-
-        if values.get("credentials"):
-            genai.configure(
-                credentials=values.get("credentials"),
-                transport=values.get("transport"),
-                client_options=values.get("client_options"),
-                default_metadata=default_metadata,
-            )
-        else:
-            google_api_key = get_from_dict_or_env(
-                values, "google_api_key", "GOOGLE_API_KEY"
-            )
-            if isinstance(google_api_key, SecretStr):
-                google_api_key = google_api_key.get_secret_value()
-
-            genai.configure(
-                api_key=google_api_key,
-                transport=values.get("transport"),
-                client_options=values.get("client_options"),
-                default_metadata=default_metadata,
-            )
         if (
             values.get("temperature") is not None
             and not 0 <= values["temperature"] <= 1
@@ -616,8 +617,36 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
 
         if values.get("top_k") is not None and values["top_k"] <= 0:
             raise ValueError("top_k must be positive")
-        model = values["model"]
-        values["client"] = genai.GenerativeModel(model_name=model)
+
+        if not values["model"].startswith("models/"):
+            values["model"] = f"models/{values['model']}"
+
+        additional_headers = values.get("additional_headers") or {}
+        values["default_metadata"] = tuple(additional_headers.items())
+        client_info = get_client_info("ChatGoogleGenerativeAI")
+        google_api_key = None
+        if not values.get("credentials"):
+            google_api_key = get_from_dict_or_env(
+                values, "google_api_key", "GOOGLE_API_KEY"
+            )
+            if isinstance(google_api_key, SecretStr):
+                google_api_key = google_api_key.get_secret_value()
+        transport: Optional[str] = values.get("transport")
+        values["client"] = genaix.build_generative_service(
+            credentials=values.get("credentials"),
+            api_key=google_api_key,
+            client_info=client_info,
+            client_options=values.get("client_options"),
+            transport=transport,
+        )
+        values["async_client"] = genaix.build_generative_async_service(
+            credentials=values.get("credentials"),
+            api_key=google_api_key,
+            client_info=client_info,
+            client_options=values.get("client_options"),
+            transport=transport,
+        )
+
         return values
 
     @property
@@ -632,8 +661,10 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
         }
 
     def _prepare_params(
-        self, stop: Optional[List[str]], **kwargs: Any
-    ) -> Dict[str, Any]:
+        self,
+        stop: Optional[List[str]],
+        generation_config: Optional[Dict[str, Any]] = None,
+    ) -> GenerationConfig:
         gen_config = {
             k: v
             for k, v in {
@@ -646,27 +677,37 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
             }.items()
             if v is not None
         }
-        if "generation_config" in kwargs:
-            gen_config = {**gen_config, **kwargs.pop("generation_config")}
-        params = {"generation_config": gen_config, **kwargs}
-        return params
+        if generation_config:
+            gen_config = {**gen_config, **generation_config}
+        return GenerationConfig(**gen_config)
 
     def _generate(
         self,
         messages: List[BaseMessage],
         stop: Optional[List[str]] = None,
         run_manager: Optional[CallbackManagerForLLMRun] = None,
+        *,
+        tools: Optional[Sequence[Union[ToolDict, GoogleTool]]] = None,
+        functions: Optional[Sequence[FunctionDeclarationType]] = None,
+        safety_settings: Optional[SafetySettingDict] = None,
+        tool_config: Optional[Union[Dict, _ToolConfigDict]] = None,
+        generation_config: Optional[Dict[str, Any]] = None,
         **kwargs: Any,
     ) -> ChatResult:
-        params, chat, message = self._prepare_chat(
+        request = self._prepare_request(
             messages,
             stop=stop,
-            **kwargs,
+            tools=tools,
+            functions=functions,
+            safety_settings=safety_settings,
+            tool_config=tool_config,
+            generation_config=generation_config,
         )
-        response: genai.types.GenerateContentResponse = _chat_with_retry(
-            content=message,
-            **params,
-            generation_method=chat.send_message,
+        response: GenerateContentResponse = _chat_with_retry(
+            request=request,
+            **kwargs,
+            generation_method=self.client.generate_content,
+            metadata=self.default_metadata,
         )
         return _response_to_result(response)
 
@@ -675,17 +716,28 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
         messages: List[BaseMessage],
         stop: Optional[List[str]] = None,
         run_manager: Optional[AsyncCallbackManagerForLLMRun] = None,
+        *,
+        tools: Optional[Sequence[Union[ToolDict, GoogleTool]]] = None,
+        functions: Optional[Sequence[FunctionDeclarationType]] = None,
+        safety_settings: Optional[SafetySettingDict] = None,
+        tool_config: Optional[Union[Dict, _ToolConfigDict]] = None,
+        generation_config: Optional[Dict[str, Any]] = None,
         **kwargs: Any,
     ) -> ChatResult:
-        params, chat, message = self._prepare_chat(
+        request = self._prepare_request(
             messages,
             stop=stop,
-            **kwargs,
+            tools=tools,
+            functions=functions,
+            safety_settings=safety_settings,
+            tool_config=tool_config,
+            generation_config=generation_config,
         )
-        response: genai.types.GenerateContentResponse = await _achat_with_retry(
-            content=message,
-            **params,
-            generation_method=chat.send_message_async,
+        response: GenerateContentResponse = await _achat_with_retry(
+            request=request,
+            **kwargs,
+            generation_method=self.async_client.generate_content,
+            metadata=self.default_metadata,
         )
         return _response_to_result(response)
 
@@ -694,18 +746,28 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
         messages: List[BaseMessage],
         stop: Optional[List[str]] = None,
         run_manager: Optional[CallbackManagerForLLMRun] = None,
+        *,
+        tools: Optional[Sequence[Union[ToolDict, GoogleTool]]] = None,
+        functions: Optional[Sequence[FunctionDeclarationType]] = None,
+        safety_settings: Optional[SafetySettingDict] = None,
+        tool_config: Optional[Union[Dict, _ToolConfigDict]] = None,
+        generation_config: Optional[Dict[str, Any]] = None,
         **kwargs: Any,
     ) -> Iterator[ChatGenerationChunk]:
-        params, chat, message = self._prepare_chat(
+        request = self._prepare_request(
             messages,
             stop=stop,
-            **kwargs,
+            tools=tools,
+            functions=functions,
+            safety_settings=safety_settings,
+            tool_config=tool_config,
+            generation_config=generation_config,
         )
-        response: genai.types.GenerateContentResponse = _chat_with_retry(
-            content=message,
-            **params,
-            generation_method=chat.send_message,
-            stream=True,
+        response: GenerateContentResponse = _chat_with_retry(
+            request=request,
+            generation_method=self.client.stream_generate_content,
+            **kwargs,
+            metadata=self.default_metadata,
         )
         for chunk in response:
             _chat_result = _response_to_result(chunk, stream=True)
@@ -720,18 +782,28 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
         messages: List[BaseMessage],
         stop: Optional[List[str]] = None,
         run_manager: Optional[AsyncCallbackManagerForLLMRun] = None,
+        *,
+        tools: Optional[Sequence[Union[ToolDict, GoogleTool]]] = None,
+        functions: Optional[Sequence[FunctionDeclarationType]] = None,
+        safety_settings: Optional[SafetySettingDict] = None,
+        tool_config: Optional[Union[Dict, _ToolConfigDict]] = None,
+        generation_config: Optional[Dict[str, Any]] = None,
         **kwargs: Any,
     ) -> AsyncIterator[ChatGenerationChunk]:
-        params, chat, message = self._prepare_chat(
+        request = self._prepare_request(
             messages,
             stop=stop,
-            **kwargs,
+            tools=tools,
+            functions=functions,
+            safety_settings=safety_settings,
+            tool_config=tool_config,
+            generation_config=generation_config,
         )
         async for chunk in await _achat_with_retry(
-            content=message,
-            **params,
-            generation_method=chat.send_message_async,
-            stream=True,
+            request=request,
+            generation_method=self.async_client.stream_generate_content,
+            **kwargs,
+            metadata=self.default_metadata,
         ):
             _chat_result = _response_to_result(chunk, stream=True)
             gen = cast(ChatGenerationChunk, _chat_result.generations[0])
@@ -740,17 +812,17 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
                 await run_manager.on_llm_new_token(gen.text)
             yield gen
 
-    def _prepare_chat(
+    def _prepare_request(
         self,
         messages: List[BaseMessage],
+        *,
         stop: Optional[List[str]] = None,
         tools: Optional[Sequence[Union[ToolDict, GoogleTool]]] = None,
         functions: Optional[Sequence[FunctionDeclarationType]] = None,
         safety_settings: Optional[SafetySettingDict] = None,
         tool_config: Optional[Union[Dict, _ToolConfigDict]] = None,
-        **kwargs: Any,
-    ) -> Tuple[Dict[str, Any], genai.ChatSession, genai.types.ContentDict]:
-        client = self.client
+        generation_config: Optional[Dict[str, Any]] = None,
+    ) -> Tuple[GenerateContentRequest, Dict[str, Any]]:
         formatted_tools = None
         if tools:
             formatted_tools = [
@@ -759,25 +831,35 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
         elif functions:
             formatted_tools = [convert_to_genai_function_declarations(functions)]
 
-        if formatted_tools or safety_settings:
-            client = genai.GenerativeModel(
-                model_name=self.model,
-                tools=formatted_tools,
-                safety_settings=safety_settings,
-            )
-
-        params = self._prepare_params(stop, tool_config=tool_config, **kwargs)
         system_instruction, history = _parse_chat_history(
             messages,
             convert_system_message_to_human=self.convert_system_message_to_human,
         )
-        message = history.pop()
-        if self.client._system_instruction != system_instruction:
-            self.client = genai.GenerativeModel(
-                model_name=self.model, system_instruction=system_instruction
+        formatted_tool_config = None
+        if tool_config:
+            formatted_tool_config = ToolConfig(
+                function_calling_config=tool_config["function_calling_config"]
             )
-        chat = client.start_chat(history=history)
-        return params, chat, message
+        formatted_safety_settings = []
+        if safety_settings:
+            formatted_safety_settings = [
+                SafetySetting(category=c, threshold=t)
+                for c, t in safety_settings.items()
+            ]
+        request = GenerateContentRequest(
+            model=self.model,
+            contents=history,
+            tools=formatted_tools,
+            tool_config=formatted_tool_config,
+            safety_settings=formatted_safety_settings,
+            generation_config=self._prepare_params(
+                stop, generation_config=generation_config
+            ),
+        )
+        if system_instruction:
+            request.system_instruction = system_instruction
+
+        return request
 
     def get_num_tokens(self, text: str) -> int:
         """Get the number of tokens present in the text.
@@ -790,14 +872,10 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
         Returns:
             The integer number of tokens in the text.
         """
-        if self._model_family == GoogleModelFamily.GEMINI:
-            result = self.client.count_tokens(text)
-            token_count = result.total_tokens
-        else:
-            result = self.client.count_text_tokens(model=self.model, prompt=text)
-            token_count = result["token_count"]
-
-        return token_count
+        result = self.client.count_tokens(
+            model=self.model, contents=[Content(parts=[Part(text=text)])]
+        )
+        return result.total_tokens
 
     def bind_tools(
         self,
@@ -828,7 +906,9 @@ class ChatGoogleGenerativeAI(_BaseGoogleGenerativeAI, BaseChatModel):
         genai_tools = [tool_to_dict(convert_to_genai_function_declarations(tools))]
         if tool_choice:
             all_names = [
-                f["name"] for t in genai_tools for f in t["function_declarations"]
+                f["name"]  # type: ignore[index]
+                for t in genai_tools
+                for f in t["function_declarations"]
             ]
             tool_config = _tool_choice_to_tool_config(tool_choice, all_names)
         return self.bind(tools=genai_tools, tool_config=tool_config, **kwargs)

langchain_google_genai/embeddings.py

@@ -1,12 +1,19 @@
 from typing import Any, Dict, List, Optional
 
 # TODO: remove ignore once the google package is published with types
-import google.generativeai as genai  # type: ignore[import]
+from google.ai.generativelanguage_v1beta.types import (
+    BatchEmbedContentsRequest,
+    EmbedContentRequest,
+)
 from langchain_core.embeddings import Embeddings
 from langchain_core.pydantic_v1 import BaseModel, Field, SecretStr, root_validator
 from langchain_core.utils import get_from_dict_or_env
 
-from langchain_google_genai._common import GoogleGenerativeAIError
+from langchain_google_genai._common import (
+    GoogleGenerativeAIError,
+    get_client_info,
+)
+from langchain_google_genai._genai_extension import build_generative_service
 
 
 class GoogleGenerativeAIEmbeddings(BaseModel, Embeddings):
@@ -27,6 +34,7 @@ class GoogleGenerativeAIEmbeddings(BaseModel, Embeddings):
             embeddings.embed_query("What's our Q1 revenue?")
     """
 
+    client: Any  #: :meta private:
     model: str = Field(
         ...,
         description="The name of the embedding model to use. "
@@ -70,44 +78,43 @@ class GoogleGenerativeAIEmbeddings(BaseModel, Embeddings):
     @root_validator()
     def validate_environment(cls, values: Dict) -> Dict:
         """Validates params and passes them to google-generativeai package."""
-        if values.get("credentials"):
-            genai.configure(
-                credentials=values.get("credentials"),
-                transport=values.get("transport"),
-                client_options=values.get("client_options"),
-            )
-        else:
-            google_api_key = get_from_dict_or_env(
-                values, "google_api_key", "GOOGLE_API_KEY"
-            )
-            if isinstance(google_api_key, SecretStr):
-                google_api_key = google_api_key.get_secret_value()
-
-            genai.configure(
-                api_key=google_api_key,
-                transport=values.get("transport"),
-                client_options=values.get("client_options"),
-            )
+        google_api_key = get_from_dict_or_env(
+            values, "google_api_key", "GOOGLE_API_KEY"
+        )
+        client_info = get_client_info("GoogleGenerativeAIEmbeddings")
+
+        values["client"] = build_generative_service(
+            credentials=values.get("credentials"),
+            api_key=google_api_key,
+            client_info=client_info,
+            client_options=values.get("client_options"),
+        )
         return values
 
-    def _embed(
-        self, texts: List[str], task_type: str, title: Optional[str] = None
-    ) -> List[List[float]]:
-        task_type = self.task_type or "retrieval_document"
-        try:
-            result = genai.embed_content(
-                model=self.model,
-                content=texts,
-                task_type=task_type,
-                title=title,
-                request_options=self.request_options,
-            )
-        except Exception as e:
-            raise GoogleGenerativeAIError(f"Error embedding content: {e}") from e
-        return result["embedding"]
+    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,
+            task_type=task_type.upper(),
+            title=title,
+            output_dimensionality=output_dimensionality,
+        )
+        return request
 
     def embed_documents(
-        self, texts: List[str], batch_size: int = 5
+        self,
+        texts: List[str],
+        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.
@@ -115,21 +122,58 @@ class GoogleGenerativeAIEmbeddings(BaseModel, Embeddings):
         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)
+            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
 
         Returns:
             List of embeddings, one for each text.
         """
-        task_type = self.task_type or "retrieval_document"
-        return self._embed(texts, task_type=task_type)
+        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)
+        ]
 
-    def embed_query(self, text: str) -> List[float]:
+        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]
+
+    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.
 
         Args:
             text: The text to embed.
+            task_type: task_type (https://ai.google.dev/api/rest/v1/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/rest/v1/models/batchEmbedContents#EmbedContentRequest
 
         Returns:
             Embedding for the text.
         """
-        task_type = self.task_type or "retrieval_query"
-        return self._embed([text], task_type=task_type)[0]
+        task_type = self.task_type or "RETRIEVAL_QUERY"
+        return self.embed_documents(
+            [text],
+            task_type=task_type,
+            titles=[title] if title else None,
+            output_dimensionality=output_dimensionality,
+        )[0]

langchain_google_genai/llms.py

@@ -174,7 +174,6 @@ Supported examples:
             from google.generativeai.types.safety_types import HarmBlockThreshold, HarmCategory
 
             safety_settings = {
-                HarmCategory.HARM_CATEGORY_UNSPECIFIED: HarmBlockThreshold.BLOCK_NONE,
                 HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT: HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE,
                 HarmCategory.HARM_CATEGORY_HATE_SPEECH: HarmBlockThreshold.BLOCK_ONLY_HIGH,
                 HarmCategory.HARM_CATEGORY_HARASSMENT: HarmBlockThreshold.BLOCK_LOW_AND_ABOVE,

{langchain_google_genai-1.0.3.dist-info → langchain_google_genai-1.0.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: langchain-google-genai
-Version: 1.0.3
+Version: 1.0.4
 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.1.45,<0.2)
+Requires-Dist: langchain-core (>=0.1.45,<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.4.dist-info/RECORD

@@ -0,0 +1,16 @@
+langchain_google_genai/__init__.py,sha256=Oji-S2KYWrku1wyQEskY84IOfY8MfRhujjJ4d7hbsk4,2758
+langchain_google_genai/_common.py,sha256=ASlwE8hEbvOm55BVF_D4rf2nl7RYsnpsi5xbM6DW3Cc,1576
+langchain_google_genai/_enums.py,sha256=KLPmxS1K83K4HjBIXFaXoL_sFEOv8Hq-2B2PDMKyDgo,197
+langchain_google_genai/_function_utils.py,sha256=d0ApSCjoV9Em1CteBaGznilxrw-PDXqQ4sQa5p7cJfM,8232
+langchain_google_genai/_genai_extension.py,sha256=ZwNwLV22RSf9LB7FOCLsoHzLlQDF-EQmRNYM1an2uSw,20769
+langchain_google_genai/_image_utils.py,sha256=-0XgCMdYkvrIktFvUpy-2GPbFgfSVKZICawB2hiJzus,4999
+langchain_google_genai/chat_models.py,sha256=3ubY5qCaZjFSHKHiiP5XCOPDusUxO8kJvpj9DwLtUG4,33014
+langchain_google_genai/embeddings.py,sha256=kQW6pl1TUGKKSxiUjc7rptp0iEu_Rer1m1LLHKVaW14,6578
+langchain_google_genai/genai_aqa.py,sha256=zcC5cdFYtqLK7DGPhYGvWNeHHeU-CQKA9KhewmsA5lw,4303
+langchain_google_genai/google_vector_store.py,sha256=PPIk-4FmD5UUdmYA2u7VcEhGsiztvRVN59QoGLXdfoA,16139
+langchain_google_genai/llms.py,sha256=S7tOy-c37DElcHtkGl8rwvvg1zOzCxb9PEyJ4E-j7qU,13431
+langchain_google_genai/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+langchain_google_genai-1.0.4.dist-info/LICENSE,sha256=DppmdYJVSc1jd0aio6ptnMUn5tIHrdAhQ12SclEBfBg,1072
+langchain_google_genai-1.0.4.dist-info/METADATA,sha256=nHJMXwe6iuI99J_VO1GQrVgv1BLvVGW5x0mSNswDWq0,3818
+langchain_google_genai-1.0.4.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
+langchain_google_genai-1.0.4.dist-info/RECORD,,

langchain_google_genai-1.0.3.dist-info/RECORD

@@ -1,15 +0,0 @@
-langchain_google_genai/__init__.py,sha256=NiLfU4IyEQSlSl8hbN_fTdX-hrO5tuOflxFlEK0Sy4c,2762
-langchain_google_genai/_common.py,sha256=1r0VrrBSTZfGprmICZ5OV-W5SK31jKRFFCNE3vJ3jmk,136
-langchain_google_genai/_enums.py,sha256=q8IYAqufV-_yZ98FDnsZ3x-1w4804J_e8PrTKT0sdhY,163
-langchain_google_genai/_function_utils.py,sha256=uDWg2Gcuv3PtdUL14sDOVTFbq8gaaGJ360bL4IbN4AI,8705
-langchain_google_genai/_genai_extension.py,sha256=2Uqg7vSF0vu1J4AhAyIPzadtpM5JJwZsBXvpItO2TY4,18736
-langchain_google_genai/chat_models.py,sha256=edkRRStq42pxY1xBzfC2yUfN-jBsM-Vr1dx9QVg-qd4,29969
-langchain_google_genai/embeddings.py,sha256=QZJRd5xQkGzalAGiKeorrsnVmsyaO4NGmGuzQFDoRe0,4807
-langchain_google_genai/genai_aqa.py,sha256=zcC5cdFYtqLK7DGPhYGvWNeHHeU-CQKA9KhewmsA5lw,4303
-langchain_google_genai/google_vector_store.py,sha256=PPIk-4FmD5UUdmYA2u7VcEhGsiztvRVN59QoGLXdfoA,16139
-langchain_google_genai/llms.py,sha256=QPjCs0AHb-2d3GMCS3sZqzG_Yr71YbaGX_Vs8QlLTKU,13518
-langchain_google_genai/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-langchain_google_genai-1.0.3.dist-info/LICENSE,sha256=DppmdYJVSc1jd0aio6ptnMUn5tIHrdAhQ12SclEBfBg,1072
-langchain_google_genai-1.0.3.dist-info/METADATA,sha256=IPH2elmUC6Rt7ZG-g5eyma97A8r48jftkeq9v8XyQMc,3818
-langchain_google_genai-1.0.3.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
-langchain_google_genai-1.0.3.dist-info/RECORD,,