langchain-google-genai 2.1.5__tar.gz → 2.1.7__tar.gz

langchain_google_genai-2.1.7/PKG-INFO

@@ -0,0 +1,260 @@
+Metadata-Version: 2.1
+Name: langchain-google-genai
+Version: 2.1.7
+Summary: An integration package connecting Google's genai package and LangChain
+Home-page: https://github.com/langchain-ai/langchain-google
+License: MIT
+Requires-Python: >=3.9,<4.0
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+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.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
+Description-Content-Type: text/markdown
+
+# langchain-google-genai
+
+**LangChain integration for Google Gemini models using the `generative-ai` SDK**
+
+This package enables seamless access to Google Gemini's chat, vision, embeddings, and retrieval-augmented generation (RAG) features within the LangChain ecosystem.
+
+---
+
+## Table of Contents
+
+- [Overview](#overview)
+- [Installation](#installation)
+- [Quickstart](#quickstart)
+- [Chat Models](#chat-models)
+  - [Multimodal Inputs](#multimodal-inputs)
+  - [Multimodal Outputs](#multimodal-outputs)
+  - [Multimodal Outputs in Chains](#multimodal-outputs-in-chains)
+  - [Thinking Support](#thinking-support)
+- [Embeddings](#embeddings)
+- [Semantic Retrieval (RAG)](#semantic-retrieval-rag)
+
+---
+
+## Overview
+
+This package provides LangChain support for Google Gemini models (via the official [Google Generative AI SDK](https://googleapis.github.io/python-genai/)). It supports:
+
+- Text and vision-based chat models
+- Embeddings for semantic search
+- Multimodal inputs and outputs
+- Retrieval-Augmented Generation (RAG)
+- Thought tracing with reasoning tokens
+
+---
+
+## Installation
+
+```bash
+pip install -U langchain-google-genai
+````
+
+---
+
+## Quickstart
+
+Set up your environment variable with your Gemini API key:
+
+```bash
+export GOOGLE_API_KEY=your-api-key
+```
+
+Then use the `ChatGoogleGenerativeAI` interface:
+
+```python
+from langchain_google_genai import ChatGoogleGenerativeAI
+
+llm = ChatGoogleGenerativeAI(model="gemini-pro")
+response = llm.invoke("Sing a ballad of LangChain.")
+print(response.content)
+```
+
+---
+
+## Chat Models
+
+The main interface for Gemini chat models is `ChatGoogleGenerativeAI`.
+
+### Multimodal Inputs
+
+Gemini vision models support image inputs in single messages.
+
+```python
+from langchain_core.messages import HumanMessage
+from langchain_google_genai import ChatGoogleGenerativeAI
+
+llm = ChatGoogleGenerativeAI(model="gemini-pro-vision")
+
+message = HumanMessage(
+    content=[
+        {"type": "text", "text": "What's in this image?"},
+        {"type": "image_url", "image_url": "https://picsum.photos/seed/picsum/200/300"},
+    ]
+)
+
+response = llm.invoke([message])
+print(response.content)
+```
+
+✅ `image_url` can be:
+
+* A public image URL
+* A Google Cloud Storage path (`gcs://...`)
+* A base64-encoded image (e.g., `data:image/png;base64,...`)
+
+---
+
+### Multimodal Outputs
+
+The Gemini 2.0 Flash Experimental model supports both text and inline image outputs.
+
+```python
+from langchain_google_genai import ChatGoogleGenerativeAI
+
+llm = ChatGoogleGenerativeAI(model="models/gemini-2.0-flash-exp-image-generation")
+
+response = llm.invoke(
+    "Generate an image of a cat and say meow",
+    generation_config=dict(response_modalities=["TEXT", "IMAGE"]),
+)
+
+image_base64 = response.content[0].get("image_url").get("url").split(",")[-1]
+meow_text = response.content[1]
+print(meow_text)
+```
+
+---
+
+### Audio Output
+
+```
+from langchain_google_genai import ChatGoogleGenerativeAI
+
+llm = ChatGoogleGenerativeAI(model="models/gemini-2.5-flash-preview-tts")
+# example
+response = llm.invoke(
+    "Please say The quick brown fox jumps over the lazy dog",
+    generation_config=dict(response_modalities=["AUDIO"]),
+)
+
+# Base64 encoded binary data of the image
+wav_data = response.additional_kwargs.get("audio")
+with open("output.wav", "wb") as f:
+    f.write(wav_data)
+```
+
+---
+
+### Multimodal Outputs in Chains
+
+You can use Gemini models in a LangChain chain:
+
+```python
+from langchain_core.runnables import RunnablePassthrough
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_google_genai import ChatGoogleGenerativeAI, Modality
+
+llm = ChatGoogleGenerativeAI(
+    model="models/gemini-2.0-flash-exp-image-generation",
+    response_modalities=[Modality.TEXT, Modality.IMAGE],
+)
+
+prompt = ChatPromptTemplate.from_messages([
+    ("human", "Generate an image of {animal} and tell me the sound it makes.")
+])
+
+chain = {"animal": RunnablePassthrough()} | prompt | llm
+response = chain.invoke("cat")
+```
+
+---
+
+### Thinking Support
+
+Gemini 2.5 Flash Preview supports internal reasoning ("thoughts").
+
+```python
+from langchain_google_genai import ChatGoogleGenerativeAI
+
+llm = ChatGoogleGenerativeAI(
+    model="models/gemini-2.5-flash-preview-04-17",
+    thinking_budget=1024
+)
+
+response = llm.invoke("How many O's are in Google? How did you verify your answer?")
+reasoning_score = response.usage_metadata["output_token_details"]["reasoning"]
+
+print("Response:", response.content)
+print("Reasoning tokens used:", reasoning_score)
+```
+
+---
+
+## Embeddings
+
+You can use Gemini embeddings in LangChain:
+
+```python
+from langchain_google_genai import GoogleGenerativeAIEmbeddings
+
+embeddings = GoogleGenerativeAIEmbeddings(model="models/embedding-001")
+vector = embeddings.embed_query("hello, world!")
+print(vector)
+```
+
+---
+
+## Semantic Retrieval (RAG)
+
+Use Gemini with RAG to retrieve relevant documents from your knowledge base.
+
+```python
+from langchain_google_genai.vectorstores import GoogleVectorStore
+from langchain_text_splitters import CharacterTextSplitter
+from langchain_community.document_loaders import DirectoryLoader
+
+# Create a corpus (collection of documents)
+corpus_store = GoogleVectorStore.create_corpus(display_name="My Corpus")
+
+# Create a document under that corpus
+document_store = GoogleVectorStore.create_document(
+    corpus_id=corpus_store.corpus_id, display_name="My Document"
+)
+
+# Load and upload documents
+text_splitter = CharacterTextSplitter(chunk_size=500, chunk_overlap=0)
+for file in DirectoryLoader(path="data/").load():
+    chunks = text_splitter.split_documents([file])
+    document_store.add_documents(chunks)
+
+# Query the document corpus
+aqa = corpus_store.as_aqa()
+response = aqa.invoke("What is the meaning of life?")
+
+print("Answer:", response.answer)
+print("Passages:", response.attributed_passages)
+print("Answerable probability:", response.answerable_probability)
+```
+
+---
+
+
+## Resources
+
+* [LangChain Documentation](https://docs.langchain.com/)
+* [Google Generative AI SDK](https://googleapis.github.io/python-genai/)
+* [Gemini Model Documentation](https://ai.google.dev/)
+
+
+

langchain_google_genai-2.1.7/README.md

@@ -0,0 +1,238 @@
+# langchain-google-genai
+
+**LangChain integration for Google Gemini models using the `generative-ai` SDK**
+
+This package enables seamless access to Google Gemini's chat, vision, embeddings, and retrieval-augmented generation (RAG) features within the LangChain ecosystem.
+
+---
+
+## Table of Contents
+
+- [Overview](#overview)
+- [Installation](#installation)
+- [Quickstart](#quickstart)
+- [Chat Models](#chat-models)
+  - [Multimodal Inputs](#multimodal-inputs)
+  - [Multimodal Outputs](#multimodal-outputs)
+  - [Multimodal Outputs in Chains](#multimodal-outputs-in-chains)
+  - [Thinking Support](#thinking-support)
+- [Embeddings](#embeddings)
+- [Semantic Retrieval (RAG)](#semantic-retrieval-rag)
+
+---
+
+## Overview
+
+This package provides LangChain support for Google Gemini models (via the official [Google Generative AI SDK](https://googleapis.github.io/python-genai/)). It supports:
+
+- Text and vision-based chat models
+- Embeddings for semantic search
+- Multimodal inputs and outputs
+- Retrieval-Augmented Generation (RAG)
+- Thought tracing with reasoning tokens
+
+---
+
+## Installation
+
+```bash
+pip install -U langchain-google-genai
+````
+
+---
+
+## Quickstart
+
+Set up your environment variable with your Gemini API key:
+
+```bash
+export GOOGLE_API_KEY=your-api-key
+```
+
+Then use the `ChatGoogleGenerativeAI` interface:
+
+```python
+from langchain_google_genai import ChatGoogleGenerativeAI
+
+llm = ChatGoogleGenerativeAI(model="gemini-pro")
+response = llm.invoke("Sing a ballad of LangChain.")
+print(response.content)
+```
+
+---
+
+## Chat Models
+
+The main interface for Gemini chat models is `ChatGoogleGenerativeAI`.
+
+### Multimodal Inputs
+
+Gemini vision models support image inputs in single messages.
+
+```python
+from langchain_core.messages import HumanMessage
+from langchain_google_genai import ChatGoogleGenerativeAI
+
+llm = ChatGoogleGenerativeAI(model="gemini-pro-vision")
+
+message = HumanMessage(
+    content=[
+        {"type": "text", "text": "What's in this image?"},
+        {"type": "image_url", "image_url": "https://picsum.photos/seed/picsum/200/300"},
+    ]
+)
+
+response = llm.invoke([message])
+print(response.content)
+```
+
+✅ `image_url` can be:
+
+* A public image URL
+* A Google Cloud Storage path (`gcs://...`)
+* A base64-encoded image (e.g., `data:image/png;base64,...`)
+
+---
+
+### Multimodal Outputs
+
+The Gemini 2.0 Flash Experimental model supports both text and inline image outputs.
+
+```python
+from langchain_google_genai import ChatGoogleGenerativeAI
+
+llm = ChatGoogleGenerativeAI(model="models/gemini-2.0-flash-exp-image-generation")
+
+response = llm.invoke(
+    "Generate an image of a cat and say meow",
+    generation_config=dict(response_modalities=["TEXT", "IMAGE"]),
+)
+
+image_base64 = response.content[0].get("image_url").get("url").split(",")[-1]
+meow_text = response.content[1]
+print(meow_text)
+```
+
+---
+
+### Audio Output
+
+```
+from langchain_google_genai import ChatGoogleGenerativeAI
+
+llm = ChatGoogleGenerativeAI(model="models/gemini-2.5-flash-preview-tts")
+# example
+response = llm.invoke(
+    "Please say The quick brown fox jumps over the lazy dog",
+    generation_config=dict(response_modalities=["AUDIO"]),
+)
+
+# Base64 encoded binary data of the image
+wav_data = response.additional_kwargs.get("audio")
+with open("output.wav", "wb") as f:
+    f.write(wav_data)
+```
+
+---
+
+### Multimodal Outputs in Chains
+
+You can use Gemini models in a LangChain chain:
+
+```python
+from langchain_core.runnables import RunnablePassthrough
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_google_genai import ChatGoogleGenerativeAI, Modality
+
+llm = ChatGoogleGenerativeAI(
+    model="models/gemini-2.0-flash-exp-image-generation",
+    response_modalities=[Modality.TEXT, Modality.IMAGE],
+)
+
+prompt = ChatPromptTemplate.from_messages([
+    ("human", "Generate an image of {animal} and tell me the sound it makes.")
+])
+
+chain = {"animal": RunnablePassthrough()} | prompt | llm
+response = chain.invoke("cat")
+```
+
+---
+
+### Thinking Support
+
+Gemini 2.5 Flash Preview supports internal reasoning ("thoughts").
+
+```python
+from langchain_google_genai import ChatGoogleGenerativeAI
+
+llm = ChatGoogleGenerativeAI(
+    model="models/gemini-2.5-flash-preview-04-17",
+    thinking_budget=1024
+)
+
+response = llm.invoke("How many O's are in Google? How did you verify your answer?")
+reasoning_score = response.usage_metadata["output_token_details"]["reasoning"]
+
+print("Response:", response.content)
+print("Reasoning tokens used:", reasoning_score)
+```
+
+---
+
+## Embeddings
+
+You can use Gemini embeddings in LangChain:
+
+```python
+from langchain_google_genai import GoogleGenerativeAIEmbeddings
+
+embeddings = GoogleGenerativeAIEmbeddings(model="models/embedding-001")
+vector = embeddings.embed_query("hello, world!")
+print(vector)
+```
+
+---
+
+## Semantic Retrieval (RAG)
+
+Use Gemini with RAG to retrieve relevant documents from your knowledge base.
+
+```python
+from langchain_google_genai.vectorstores import GoogleVectorStore
+from langchain_text_splitters import CharacterTextSplitter
+from langchain_community.document_loaders import DirectoryLoader
+
+# Create a corpus (collection of documents)
+corpus_store = GoogleVectorStore.create_corpus(display_name="My Corpus")
+
+# Create a document under that corpus
+document_store = GoogleVectorStore.create_document(
+    corpus_id=corpus_store.corpus_id, display_name="My Document"
+)
+
+# Load and upload documents
+text_splitter = CharacterTextSplitter(chunk_size=500, chunk_overlap=0)
+for file in DirectoryLoader(path="data/").load():
+    chunks = text_splitter.split_documents([file])
+    document_store.add_documents(chunks)
+
+# Query the document corpus
+aqa = corpus_store.as_aqa()
+response = aqa.invoke("What is the meaning of life?")
+
+print("Answer:", response.answer)
+print("Passages:", response.attributed_passages)
+print("Answerable probability:", response.answerable_probability)
+```
+
+---
+
+
+## Resources
+
+* [LangChain Documentation](https://docs.langchain.com/)
+* [Google Generative AI SDK](https://googleapis.github.io/python-genai/)
+* [Gemini Model Documentation](https://ai.google.dev/)
+
+

{langchain_google_genai-2.1.5 → langchain_google_genai-2.1.7}/langchain_google_genai/_function_utils.py

@@ -30,6 +30,7 @@ from langchain_core.utils.function_calling import (
 from langchain_core.utils.json_schema import dereference_refs
 from pydantic import BaseModel
 from pydantic.v1 import BaseModel as BaseModelV1
+from typing_extensions import NotRequired
 
 logger = logging.getLogger(__name__)
 
@@ -65,11 +66,15 @@ _GoogleSearchRetrievalLike = Union[
     gapic.GoogleSearchRetrieval,
     Dict[str, Any],
 ]
+_GoogleSearchLike = Union[gapic.Tool.GoogleSearch, Dict[str, Any]]
+_CodeExecutionLike = Union[gapic.CodeExecution, Dict[str, Any]]
 
 
 class _ToolDict(TypedDict):
     function_declarations: Sequence[_FunctionDeclarationLike]
     google_search_retrieval: Optional[_GoogleSearchRetrievalLike]
+    google_search: NotRequired[_GoogleSearchLike]
+    code_execution: NotRequired[_CodeExecutionLike]
 
 
 # Info: This means one tool=Sequence of FunctionDeclaration
@@ -158,6 +163,8 @@ def convert_to_genai_function_declarations(
                 for f in [
                     "function_declarations",
                     "google_search_retrieval",
+                    "google_search",
+                    "code_execution",
                 ]
             ):
                 fd = _format_to_gapic_function_declaration(tool)  # type: ignore[arg-type]
@@ -184,6 +191,12 @@ def convert_to_genai_function_declarations(
                 gapic_tool.google_search_retrieval = gapic.GoogleSearchRetrieval(
                     tool["google_search_retrieval"]
                 )
+            if "google_search" in tool:
+                gapic_tool.google_search = gapic.Tool.GoogleSearch(
+                    tool["google_search"]
+                )
+            if "code_execution" in tool:
+                gapic_tool.code_execution = gapic.CodeExecution(tool["code_execution"])
         else:
             fd = _format_to_gapic_function_declaration(tool)  # type: ignore[arg-type]
             gapic_tool.function_declarations.append(fd)
@@ -520,3 +533,60 @@ def safe_import(module_name: str, attribute_name: str = "") -> bool:
         return True
     except ImportError:
         return False
+
+
+def replace_defs_in_schema(original_schema: dict, defs: Optional[dict] = None) -> dict:
+    """Given an OpenAPI schema with a property '$defs' replaces all occurrences of
+    referenced items in the dictionary.
+
+    Args:
+        original_schema: Schema generated by `BaseModel.model_schema_json`
+        defs: Definitions for recursive calls.
+
+    Returns:
+        Schema with refs replaced.
+    """
+
+    new_defs = defs or original_schema.get("$defs")
+
+    if new_defs is None or not isinstance(new_defs, dict):
+        return original_schema.copy()
+
+    resulting_schema = {}
+
+    for key, value in original_schema.items():
+        if key == "$defs":
+            continue
+
+        if not isinstance(value, dict):
+            resulting_schema[key] = value
+        else:
+            if "$ref" in value:
+                new_value = value.copy()
+
+                path = new_value.pop("$ref")
+                def_key = _get_def_key_from_schema_path(path)
+                new_item = new_defs.get(def_key)
+
+                assert isinstance(new_item, dict)
+                new_value.update(new_item)
+
+                resulting_schema[key] = replace_defs_in_schema(new_value, defs=new_defs)
+            else:
+                resulting_schema[key] = replace_defs_in_schema(value, defs=new_defs)
+
+    return resulting_schema
+
+
+def _get_def_key_from_schema_path(schema_path: str) -> str:
+    error_message = f"Malformed schema reference path {schema_path}"
+
+    if not isinstance(schema_path, str) or not schema_path.startswith("#/$defs/"):
+        raise ValueError(error_message)
+
+    # Schema has to have only one extra level.
+    parts = schema_path.split("/")
+    if len(parts) != 3:
+        raise ValueError(error_message)
+
+    return parts[-1]