langchain-google-genai 0.0.3__tar.gz → 0.0.5__tar.gz

{langchain_google_genai-0.0.3 → langchain_google_genai-0.0.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: langchain-google-genai
-Version: 0.0.3
+Version: 0.0.5
 Summary: An integration package connecting Google's genai package and LangChain
 Home-page: https://github.com/langchain-ai/langchain/blob/master/libs/partners/google-genai
 Requires-Python: >=3.9,<4.0
@@ -8,8 +8,10 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
+Provides-Extra: images
 Requires-Dist: google-generativeai (>=0.3.1,<0.4.0)
 Requires-Dist: langchain-core (>=0.1,<0.2)
+Requires-Dist: pillow (>=10.1.0,<11.0.0) ; extra == "images"
 Project-URL: Repository, https://github.com/langchain-ai/langchain/blob/master/libs/partners/google-genai
 Description-Content-Type: text/markdown
 
@@ -19,10 +21,17 @@ This package contains the LangChain integrations for Gemini through their genera
 
 ## Installation
 
-```python
+```bash
 pip install -U langchain-google-genai
 ```
 
+### Image utilities
+To use image utility methods, like loading images from GCS urls, install with extras group 'images':
+
+```bash
+pip install -e "langchain-google-genai[images]"
+```
+
 ## Chat Models
 
 This package contains the `ChatGoogleGenerativeAI` class, which is the recommended way to interface with the Google Gemini series of models.

{langchain_google_genai-0.0.3 → langchain_google_genai-0.0.5}/README.md

@@ -4,10 +4,17 @@ This package contains the LangChain integrations for Gemini through their genera
 
 ## Installation
 
-```python
+```bash
 pip install -U langchain-google-genai
 ```
 
+### Image utilities
+To use image utility methods, like loading images from GCS urls, install with extras group 'images':
+
+```bash
+pip install -e "langchain-google-genai[images]"
+```
+
 ## Chat Models
 
 This package contains the `ChatGoogleGenerativeAI` class, which is the recommended way to interface with the Google Gemini series of models.

{langchain_google_genai-0.0.3 → langchain_google_genai-0.0.5}/langchain_google_genai/__init__.py

@@ -6,11 +6,14 @@ This module integrates Google's Generative AI models, specifically the Gemini se
 
 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.
+
 **Embeddings**
 
 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:
@@ -29,6 +32,17 @@ llm = ChatGoogleGenerativeAI(model="gemini-pro")
 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
+
+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.
@@ -42,5 +56,10 @@ embeddings.embed_query("hello, world!")
 """  # noqa: E501
 from langchain_google_genai.chat_models import ChatGoogleGenerativeAI
 from langchain_google_genai.embeddings import GoogleGenerativeAIEmbeddings
+from langchain_google_genai.llms import GoogleGenerativeAI
 
-__all__ = ["ChatGoogleGenerativeAI", "GoogleGenerativeAIEmbeddings"]
+__all__ = [
+    "ChatGoogleGenerativeAI",
+    "GoogleGenerativeAIEmbeddings",
+    "GoogleGenerativeAI",
+]

{langchain_google_genai-0.0.3 → langchain_google_genai-0.0.5}/langchain_google_genai/chat_models.py

@@ -37,6 +37,7 @@ from langchain_core.messages import (
     ChatMessageChunk,
     HumanMessage,
     HumanMessageChunk,
+    SystemMessage,
 )
 from langchain_core.outputs import ChatGeneration, ChatGenerationChunk, ChatResult
 from langchain_core.pydantic_v1 import Field, SecretStr, root_validator
@@ -106,7 +107,7 @@ def _create_retry_decorator() -> Callable[[Any], Any]:
     )
 
 
-def _chat_with_retry(*, generation_method: Callable, **kwargs: Any) -> Any:
+def _chat_with_retry(generation_method: Callable, **kwargs: Any) -> Any:
     """
     Executes a chat generation method with retry logic using tenacity.
 
@@ -139,7 +140,7 @@ def _chat_with_retry(*, generation_method: Callable, **kwargs: Any) -> Any:
     return _chat_with_retry(**kwargs)
 
 
-async def _achat_with_retry(*, generation_method: Callable, **kwargs: Any) -> Any:
+async def _achat_with_retry(generation_method: Callable, **kwargs: Any) -> Any:
     """
     Executes a chat generation method with retry logic using tenacity.
 
@@ -172,26 +173,6 @@ async def _achat_with_retry(*, generation_method: Callable, **kwargs: Any) -> An
     return await _achat_with_retry(**kwargs)
 
 
-def _get_role(message: BaseMessage) -> str:
-    if isinstance(message, ChatMessage):
-        if message.role not in ("user", "model"):
-            raise ChatGoogleGenerativeAIError(
-                "Gemini only supports user and model roles when"
-                " providing it with Chat messages."
-            )
-        return message.role
-    elif isinstance(message, HumanMessage):
-        return "user"
-    elif isinstance(message, AIMessage):
-        return "model"
-    else:
-        # TODO: Gemini doesn't seem to have a concept of system messages yet.
-        raise ChatGoogleGenerativeAIError(
-            f"Message of '{message.type}' type not supported by Gemini."
-            " Please only provide it with Human or AI (user/assistant) messages."
-        )
-
-
 def _is_openai_parts_format(part: dict) -> bool:
     return "type" in part
 
@@ -266,13 +247,14 @@ def _url_to_pil(image_source: str) -> Image:
 
 
 def _convert_to_parts(
-    content: Sequence[Union[str, dict]],
+    raw_content: Union[str, Sequence[Union[str, dict]]],
 ) -> List[genai.types.PartType]:
     """Converts a list of LangChain messages into a google parts."""
     parts = []
+    content = [raw_content] if isinstance(raw_content, str) else raw_content
     for part in content:
         if isinstance(part, str):
-            parts.append(genai.types.PartDict(text=part, inline_data=None))
+            parts.append(genai.types.PartDict(text=part))
         elif isinstance(part, Mapping):
             # OpenAI Format
             if _is_openai_parts_format(part):
@@ -304,27 +286,49 @@ def _convert_to_parts(
     return parts
 
 
-def _messages_to_genai_contents(
-    input_messages: Sequence[BaseMessage],
+def _parse_chat_history(
+    input_messages: Sequence[BaseMessage], convert_system_message_to_human: bool = False
 ) -> List[genai.types.ContentDict]:
-    """Converts a list of messages into a Gemini API google content dicts."""
-
     messages: List[genai.types.MessageDict] = []
+
+    raw_system_message: Optional[SystemMessage] = None
     for i, message in enumerate(input_messages):
-        role = _get_role(message)
-        if isinstance(message.content, str):
-            parts = [message.content]
+        if (
+            i == 0
+            and isinstance(message, SystemMessage)
+            and not convert_system_message_to_human
+        ):
+            raise ValueError(
+                """SystemMessages are not yet supported!
+
+To automatically convert the leading SystemMessage to a HumanMessage,
+set  `convert_system_message_to_human` to True. Example:
+
+llm = ChatGoogleGenerativeAI(model="gemini-pro", convert_system_message_to_human=True)
+"""
+            )
+        elif i == 0 and isinstance(message, SystemMessage):
+            raw_system_message = message
+            continue
+        elif isinstance(message, AIMessage):
+            role = "model"
+        elif isinstance(message, HumanMessage):
+            role = "user"
         else:
-            parts = _convert_to_parts(message.content)
-        messages.append({"role": role, "parts": parts})
-        if i > 0:
-            # Cannot have multiple messages from the same role in a row.
-            if role == messages[-2]["role"]:
-                raise ChatGoogleGenerativeAIError(
-                    "Cannot have multiple messages from the same role in a row."
-                    " Consider merging them into a single message with multiple"
-                    f" parts.\nReceived: {messages}"
+            raise ValueError(
+                f"Unexpected message with type {type(message)} at the position {i}."
+            )
+
+        parts = _convert_to_parts(message.content)
+        if raw_system_message:
+            if role == "model":
+                raise ValueError(
+                    "SystemMessage should be followed by a HumanMessage and "
+                    "not by AIMessage."
                 )
+            parts = _convert_to_parts(raw_system_message.content) + parts
+            raw_system_message = None
+        messages.append({"role": role, "parts": parts})
     return messages
 
 
@@ -457,8 +461,11 @@ Supported examples:
     n: int = Field(default=1, alias="candidate_count")
     """Number of chat completions to generate for each prompt. Note that the API may
        not return the full n completions if duplicates are generated."""
-
-    _generative_model: Any  #: :meta private:
+    convert_system_message_to_human: bool = False
+    """Whether to merge any leading SystemMessage into the following HumanMessage.
+    
+    Gemini does not support system messages; any unsupported messages will 
+    raise an error."""
 
     class Config:
         allow_population_by_field_name = True
@@ -499,7 +506,7 @@ Supported examples:
         if values.get("top_k") is not None and values["top_k"] <= 0:
             raise ValueError("top_k must be positive")
         model = values["model"]
-        values["_generative_model"] = genai.GenerativeModel(model_name=model)
+        values["client"] = genai.GenerativeModel(model_name=model)
         return values
 
     @property
@@ -512,18 +519,9 @@ Supported examples:
             "n": self.n,
         }
 
-    @property
-    def _generation_method(self) -> Callable:
-        return self._generative_model.generate_content
-
-    @property
-    def _async_generation_method(self) -> Callable:
-        return self._generative_model.generate_content_async
-
     def _prepare_params(
-        self, messages: Sequence[BaseMessage], stop: Optional[List[str]], **kwargs: Any
+        self, stop: Optional[List[str]], **kwargs: Any
     ) -> Dict[str, Any]:
-        contents = _messages_to_genai_contents(messages)
         gen_config = {
             k: v
             for k, v in {
@@ -538,7 +536,7 @@ Supported examples:
         }
         if "generation_config" in kwargs:
             gen_config = {**gen_config, **kwargs.pop("generation_config")}
-        params = {"generation_config": gen_config, "contents": contents, **kwargs}
+        params = {"generation_config": gen_config, **kwargs}
         return params
 
     def _generate(
@@ -548,10 +546,11 @@ Supported examples:
         run_manager: Optional[CallbackManagerForLLMRun] = None,
         **kwargs: Any,
     ) -> ChatResult:
-        params = self._prepare_params(messages, stop, **kwargs)
+        params, chat, message = self._prepare_chat(messages, stop=stop)
         response: genai.types.GenerateContentResponse = _chat_with_retry(
+            content=message,
             **params,
-            generation_method=self._generation_method,
+            generation_method=chat.send_message,
         )
         return _response_to_result(response)
 
@@ -562,10 +561,11 @@ Supported examples:
         run_manager: Optional[AsyncCallbackManagerForLLMRun] = None,
         **kwargs: Any,
     ) -> ChatResult:
-        params = self._prepare_params(messages, stop, **kwargs)
+        params, chat, message = self._prepare_chat(messages, stop=stop)
         response: genai.types.GenerateContentResponse = await _achat_with_retry(
+            content=message,
             **params,
-            generation_method=self._async_generation_method,
+            generation_method=chat.send_message_async,
         )
         return _response_to_result(response)
 
@@ -576,10 +576,11 @@ Supported examples:
         run_manager: Optional[CallbackManagerForLLMRun] = None,
         **kwargs: Any,
     ) -> Iterator[ChatGenerationChunk]:
-        params = self._prepare_params(messages, stop, **kwargs)
+        params, chat, message = self._prepare_chat(messages, stop=stop)
         response: genai.types.GenerateContentResponse = _chat_with_retry(
+            content=message,
             **params,
-            generation_method=self._generation_method,
+            generation_method=chat.send_message,
             stream=True,
         )
         for chunk in response:
@@ -602,10 +603,11 @@ Supported examples:
         run_manager: Optional[AsyncCallbackManagerForLLMRun] = None,
         **kwargs: Any,
     ) -> AsyncIterator[ChatGenerationChunk]:
-        params = self._prepare_params(messages, stop, **kwargs)
+        params, chat, message = self._prepare_chat(messages, stop=stop)
         async for chunk in await _achat_with_retry(
+            content=message,
             **params,
-            generation_method=self._async_generation_method,
+            generation_method=chat.send_message_async,
             stream=True,
         ):
             _chat_result = _response_to_result(
@@ -619,3 +621,18 @@ Supported examples:
             yield gen
             if run_manager:
                 await run_manager.on_llm_new_token(gen.text)
+
+    def _prepare_chat(
+        self,
+        messages: List[BaseMessage],
+        stop: Optional[List[str]] = None,
+        **kwargs: Any,
+    ) -> Tuple[Dict[str, Any], genai.ChatSession, genai.types.ContentDict]:
+        params = self._prepare_params(stop, **kwargs)
+        history = _parse_chat_history(
+            messages,
+            convert_system_message_to_human=self.convert_system_message_to_human,
+        )
+        message = history.pop()
+        chat = self.client.start_chat(history=history)
+        return params, chat, message

langchain_google_genai-0.0.5/langchain_google_genai/llms.py

@@ -0,0 +1,262 @@
+from __future__ import annotations
+
+from typing import Any, Callable, Dict, Iterator, List, Optional, Union
+
+import google.api_core
+import google.generativeai as genai  # type: ignore[import]
+from langchain_core.callbacks import (
+    AsyncCallbackManagerForLLMRun,
+    CallbackManagerForLLMRun,
+)
+from langchain_core.language_models import LanguageModelInput
+from langchain_core.language_models.llms import BaseLLM, create_base_retry_decorator
+from langchain_core.outputs import Generation, GenerationChunk, LLMResult
+from langchain_core.pydantic_v1 import BaseModel, Field, SecretStr, root_validator
+from langchain_core.utils import get_from_dict_or_env
+
+
+def _create_retry_decorator(
+    llm: BaseLLM,
+    *,
+    max_retries: int = 1,
+    run_manager: Optional[
+        Union[AsyncCallbackManagerForLLMRun, CallbackManagerForLLMRun]
+    ] = None,
+) -> Callable[[Any], Any]:
+    """Creates a retry decorator for Vertex / Palm LLMs."""
+
+    errors = [
+        google.api_core.exceptions.ResourceExhausted,
+        google.api_core.exceptions.ServiceUnavailable,
+        google.api_core.exceptions.Aborted,
+        google.api_core.exceptions.DeadlineExceeded,
+        google.api_core.exceptions.GoogleAPIError,
+    ]
+    decorator = create_base_retry_decorator(
+        error_types=errors, max_retries=max_retries, run_manager=run_manager
+    )
+    return decorator
+
+
+def _completion_with_retry(
+    llm: GoogleGenerativeAI,
+    prompt: LanguageModelInput,
+    is_gemini: bool = False,
+    stream: bool = False,
+    run_manager: Optional[CallbackManagerForLLMRun] = None,
+    **kwargs: Any,
+) -> Any:
+    """Use tenacity to retry the completion call."""
+    retry_decorator = _create_retry_decorator(
+        llm, max_retries=llm.max_retries, run_manager=run_manager
+    )
+
+    @retry_decorator
+    def _completion_with_retry(
+        prompt: LanguageModelInput, is_gemini: bool, stream: bool, **kwargs: Any
+    ) -> Any:
+        generation_config = kwargs.get("generation_config", {})
+        if is_gemini:
+            return llm.client.generate_content(
+                contents=prompt, stream=stream, generation_config=generation_config
+            )
+        return llm.client.generate_text(prompt=prompt, **kwargs)
+
+    return _completion_with_retry(
+        prompt=prompt, is_gemini=is_gemini, stream=stream, **kwargs
+    )
+
+
+def _is_gemini_model(model_name: str) -> bool:
+    return "gemini" in model_name
+
+
+def _strip_erroneous_leading_spaces(text: str) -> str:
+    """Strip erroneous leading spaces from text.
+
+    The PaLM API will sometimes erroneously return a single leading space in all
+    lines > 1. This function strips that space.
+    """
+    has_leading_space = all(not line or line[0] == " " for line in text.split("\n")[1:])
+    if has_leading_space:
+        return text.replace("\n ", "\n")
+    else:
+        return text
+
+
+class GoogleGenerativeAI(BaseLLM, BaseModel):
+    """Google GenerativeAI models.
+
+    Example:
+        .. code-block:: python
+
+            from langchain_google_genai import GoogleGenerativeAI
+            llm = GoogleGenerativeAI(model="gemini-pro")
+    """
+
+    client: Any  #: :meta private:
+    model: str = Field(
+        ...,
+        description="""The name of the model to use.
+Supported examples:
+    - gemini-pro
+    - models/text-bison-001""",
+    )
+    """Model name to use."""
+    google_api_key: Optional[SecretStr] = None
+    temperature: float = 0.7
+    """Run inference with this temperature. Must by in the closed interval
+       [0.0, 1.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]."""
+    top_k: Optional[int] = None
+    """Decode using top-k sampling: consider the set of top_k most probable tokens.
+       Must be positive."""
+    max_output_tokens: Optional[int] = None
+    """Maximum number of tokens to include in a candidate. Must be greater than zero.
+       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."""
+    max_retries: int = 6
+    """The maximum number of retries to make when generating."""
+
+    @property
+    def is_gemini(self) -> bool:
+        """Returns whether a model is belongs to a Gemini family or not."""
+        return _is_gemini_model(self.model)
+
+    @property
+    def lc_secrets(self) -> Dict[str, str]:
+        return {"google_api_key": "GOOGLE_API_KEY"}
+
+    @root_validator()
+    def validate_environment(cls, values: Dict) -> Dict:
+        """Validate api key, python package exists."""
+        google_api_key = get_from_dict_or_env(
+            values, "google_api_key", "GOOGLE_API_KEY"
+        )
+        model_name = values["model"]
+
+        if isinstance(google_api_key, SecretStr):
+            google_api_key = google_api_key.get_secret_value()
+
+        genai.configure(api_key=google_api_key)
+
+        if _is_gemini_model(model_name):
+            values["client"] = genai.GenerativeModel(model_name=model_name)
+        else:
+            values["client"] = genai
+
+        if values["temperature"] is not None and not 0 <= values["temperature"] <= 1:
+            raise ValueError("temperature must be in the range [0.0, 1.0]")
+
+        if values["top_p"] is not None and not 0 <= values["top_p"] <= 1:
+            raise ValueError("top_p must be in the range [0.0, 1.0]")
+
+        if values["top_k"] is not None and values["top_k"] <= 0:
+            raise ValueError("top_k must be positive")
+
+        if values["max_output_tokens"] is not None and values["max_output_tokens"] <= 0:
+            raise ValueError("max_output_tokens must be greater than zero")
+
+        return values
+
+    def _generate(
+        self,
+        prompts: List[str],
+        stop: Optional[List[str]] = None,
+        run_manager: Optional[CallbackManagerForLLMRun] = None,
+        **kwargs: Any,
+    ) -> LLMResult:
+        generations: List[List[Generation]] = []
+        generation_config = {
+            "stop_sequences": stop,
+            "temperature": self.temperature,
+            "top_p": self.top_p,
+            "top_k": self.top_k,
+            "max_output_tokens": self.max_output_tokens,
+            "candidate_count": self.n,
+        }
+        for prompt in prompts:
+            if self.is_gemini:
+                res = _completion_with_retry(
+                    self,
+                    prompt=prompt,
+                    stream=False,
+                    is_gemini=True,
+                    run_manager=run_manager,
+                    generation_config=generation_config,
+                )
+                candidates = [
+                    "".join([p.text for p in c.content.parts]) for c in res.candidates
+                ]
+                generations.append([Generation(text=c) for c in candidates])
+            else:
+                res = _completion_with_retry(
+                    self,
+                    model=self.model,
+                    prompt=prompt,
+                    stream=False,
+                    is_gemini=False,
+                    run_manager=run_manager,
+                    **generation_config,
+                )
+                prompt_generations = []
+                for candidate in res.candidates:
+                    raw_text = candidate["output"]
+                    stripped_text = _strip_erroneous_leading_spaces(raw_text)
+                    prompt_generations.append(Generation(text=stripped_text))
+                generations.append(prompt_generations)
+
+        return LLMResult(generations=generations)
+
+    def _stream(
+        self,
+        prompt: str,
+        stop: Optional[List[str]] = None,
+        run_manager: Optional[CallbackManagerForLLMRun] = None,
+        **kwargs: Any,
+    ) -> Iterator[GenerationChunk]:
+        generation_config = kwargs.get("generation_config", {})
+        if stop:
+            generation_config["stop_sequences"] = stop
+        for stream_resp in _completion_with_retry(
+            self,
+            prompt,
+            stream=True,
+            is_gemini=True,
+            run_manager=run_manager,
+            generation_config=generation_config,
+            **kwargs,
+        ):
+            chunk = GenerationChunk(text=stream_resp.text)
+            yield chunk
+            if run_manager:
+                run_manager.on_llm_new_token(
+                    stream_resp.text,
+                    chunk=chunk,
+                    verbose=self.verbose,
+                )
+
+    @property
+    def _llm_type(self) -> str:
+        """Return type of llm."""
+        return "google_palm"
+
+    def get_num_tokens(self, text: str) -> int:
+        """Get the number of tokens present in the text.
+
+        Useful for checking if an input will fit in a model's context window.
+
+        Args:
+            text: The string input to tokenize.
+
+        Returns:
+            The integer number of tokens in the text.
+        """
+        if self.is_gemini:
+            raise ValueError("Counting tokens is not yet supported!")
+        result = self.client.count_text_tokens(model=self.model, prompt=text)
+        return result["token_count"]

{langchain_google_genai-0.0.3 → langchain_google_genai-0.0.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "langchain-google-genai"
-version = "0.0.3"
+version = "0.0.5"
 description = "An integration package connecting Google's genai package and LangChain"
 authors = []
 readme = "README.md"
@@ -10,6 +10,10 @@ repository = "https://github.com/langchain-ai/langchain/blob/master/libs/partner
 python = ">=3.9,<4.0"
 langchain-core = "^0.1"
 google-generativeai = "^0.3.1"
+pillow = { version = "^10.1.0", optional = true }
+
+[tool.poetry.extras]
+images = ["pillow"]
 
 [tool.poetry.group.test]
 optional = true
@@ -34,6 +38,8 @@ codespell = "^2.2.0"
 optional = true
 
 [tool.poetry.group.test_integration.dependencies]
+pillow = "^10.1.0"
+
 
 [tool.poetry.group.lint]
 optional = true