langchain-b12 0.1.0__py3-none-any.whl

langchain_b12/genai/embeddings.py

@@ -0,0 +1,99 @@
+import os
+
+from google.genai import Client
+from google.oauth2 import service_account
+from langchain_core.embeddings import Embeddings
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class GenAIEmbeddings(Embeddings, BaseModel):
+    """Embeddings implementation using `google-genai`."""
+
+    model_name: str = Field(default="text-multilingual-embedding-002")
+    client: Client = Field(
+        default_factory=lambda: Client(
+            credentials=service_account.Credentials.from_service_account_file(
+                filename=os.getenv("GOOGLE_APPLICATION_CREDENTIALS"),
+                scopes=["https://www.googleapis.com/auth/cloud-platform"],
+            )
+        ),
+        exclude=True,
+    )
+    model_config = ConfigDict(
+        arbitrary_types_allowed=True,
+    )
+
+    def embed_documents(self, texts: list[str]) -> list[list[float]]:
+        """Embed a list of text strings using the Google GenAI API.
+
+        Args:
+            texts (list[str]): The text strings to embed.
+
+        Returns:
+            list[list[float]]: The embedding vectors.
+        """
+        embeddings = []
+        for text in texts:
+            response = self.client.models.embed_content(
+                model=self.model_name,
+                contents=[text],
+            )
+            assert (
+                response.embeddings is not None
+            ), "No embeddings found in the response."
+            for embedding in response.embeddings:
+                assert (
+                    embedding.values is not None
+                ), "No embedding values found in the response."
+                embeddings.append(embedding.values)
+        assert len(embeddings) == len(
+            texts
+        ), "The number of embeddings does not match the number of texts."
+        return embeddings
+
+    def embed_query(self, text: str) -> list[float]:
+        """Embed a text string using the Google GenAI API.
+
+        Args:
+            text (str): The text to embed.
+
+        Returns:
+            list[float]: The embedding vector.
+        """
+        return self.embed_documents([text])[0]
+
+    async def aembed_documents(self, texts: list[str]) -> list[list[float]]:
+        """Embed a list of text strings using the Google GenAI API asynchronously.
+
+        Args:
+            texts (list[str]): The text strings to embed.
+
+        Returns:
+            list[list[float]]: The embedding vectors.
+        """
+        embeddings = []
+        response = await self.client.aio.models.embed_content(
+            model=self.model_name,
+            contents=texts,
+        )
+        assert response.embeddings is not None, "No embeddings found in the response."
+        for embedding in response.embeddings:
+            assert (
+                embedding.values is not None
+            ), "No embedding values found in the response."
+            embeddings.append(embedding.values)
+        assert len(embeddings) == len(
+            texts
+        ), "The number of embeddings does not match the number of texts."
+        return embeddings
+
+    async def aembed_query(self, text: str) -> list[float]:
+        """Embed a text string using the Google GenAI API asynchronously.
+
+        Args:
+            text (str): The text to embed.
+
+        Returns:
+            list[float]: The embedding vector.
+        """
+        return (await self.aembed_documents([text]))[0]

langchain_b12/genai/genai.py

@@ -0,0 +1,407 @@
+import logging
+import os
+from collections.abc import AsyncIterator, Callable, Iterator, Sequence
+from operator import itemgetter
+from typing import Any, Literal, cast
+
+from google import genai
+from google.genai import types
+from google.oauth2 import service_account
+from langchain_b12.genai.genai_utils import (
+    convert_messages_to_contents,
+    parse_response_candidate,
+)
+from langchain_core.callbacks import (
+    AsyncCallbackManagerForLLMRun,
+    CallbackManagerForLLMRun,
+)
+from langchain_core.language_models import LangSmithParams, LanguageModelInput
+from langchain_core.language_models.chat_models import (
+    BaseChatModel,
+    agenerate_from_stream,
+    generate_from_stream,
+)
+from langchain_core.messages import (
+    AIMessageChunk,
+    BaseMessage,
+    HumanMessage,
+    SystemMessage,
+)
+from langchain_core.messages.ai import UsageMetadata
+from langchain_core.output_parsers import PydanticOutputParser
+from langchain_core.output_parsers.base import OutputParserLike
+from langchain_core.output_parsers.openai_tools import (
+    PydanticToolsParser,
+)
+from langchain_core.outputs import ChatGenerationChunk, ChatResult
+from langchain_core.runnables import Runnable, RunnablePassthrough
+from langchain_core.tools import BaseTool
+from langchain_core.utils.function_calling import (
+    convert_to_openai_tool,
+)
+from pydantic import BaseModel, ConfigDict, Field
+
+logger = logging.getLogger(__name__)
+
+
+class ChatGenAI(BaseChatModel):
+    """Implementation of BaseChatModel using `google-genai`"""
+
+    client: genai.Client = Field(
+        default_factory=lambda: genai.Client(
+            vertexai=True,
+            credentials=service_account.Credentials.from_service_account_file(
+                filename=os.getenv("GOOGLE_APPLICATION_CREDENTIALS"),
+                scopes=["https://www.googleapis.com/auth/cloud-platform"],
+            ),
+        ),
+        exclude=True,
+    )
+    model_name: str = Field(default="gemini-2.0-flash", alias="model")
+    "Underlying model name."
+    stop: list[str] | None = Field(default=None, alias="stop_sequences")
+    "Optional list of stop words to use when generating."
+    temperature: float | None = None
+    "Sampling temperature, it controls the degree of randomness in token selection."
+    max_output_tokens: int | None = Field(default=None, alias="max_tokens")
+    "Token limit determines the maximum amount of text output from one prompt."
+    top_p: float | None = None
+    "Tokens are selected from most probable to least until the sum of their "
+    "probabilities equals the top-p value. Top-p is ignored for Codey models."
+    top_k: int | None = None
+    "How the model selects tokens for output, the next token is selected from "
+    "among the top-k most probable tokens. Top-k is ignored for Codey models."
+    n: int = 1
+    """How many completions to generate for each prompt."""
+    seed: int | None = None
+    """Random seed for the generation."""
+    safety_settings: list[types.SafetySetting] | None = None
+    """The default safety settings to use for all generations.
+
+        For example:
+
+            from langchain_google_vertexai 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,
+                HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT: HarmBlockThreshold.BLOCK_NONE,
+            }
+            """  # noqa: E501
+
+    model_config = ConfigDict(
+        arbitrary_types_allowed=True,
+    )
+
+    @property
+    def _llm_type(self) -> str:
+        return "vertexai"
+
+    @property
+    def _default_params(self) -> dict[str, Any]:
+        return {
+            "temperature": self.temperature,
+            "max_output_tokens": self.max_output_tokens,
+            "candidate_count": self.n,
+            "seed": self.seed,
+            "top_k": self.top_k,
+            "top_p": self.top_p,
+        }
+
+    @property
+    def _identifying_params(self) -> dict[str, Any]:
+        """Gets the identifying parameters."""
+        return {**{"model_name": self.model_name}, **self._default_params}
+
+    @classmethod
+    def is_lc_serializable(cls) -> bool:
+        return True
+
+    @classmethod
+    def get_lc_namespace(cls) -> list[str]:
+        """Get the namespace of the langchain object."""
+        return ["langchain_b12", "genai", "genai"]
+
+    def _get_ls_params(
+        self, stop: list[str] | None = None, **kwargs: Any
+    ) -> LangSmithParams:
+        """Get standard params for tracing."""
+        params = {**self._default_params, **kwargs}
+        ls_params = LangSmithParams(
+            ls_provider="google_vertexai",
+            ls_model_name=self.model_name,
+            ls_model_type="chat",
+            ls_temperature=params.get("temperature", self.temperature),
+        )
+        if ls_max_tokens := params.get("max_output_tokens", self.max_output_tokens):
+            ls_params["ls_max_tokens"] = ls_max_tokens
+        if ls_stop := stop or params.get("stop", None) or self.stop:
+            ls_params["ls_stop"] = ls_stop
+        return ls_params
+
+    def _prepare_request(
+        self, messages: list[BaseMessage]
+    ) -> tuple[str | None, types.ContentListUnion]:
+        contents = convert_messages_to_contents(messages)
+        if isinstance(messages[-1], SystemMessage):
+            system_instruction = messages[-1].content
+            assert isinstance(
+                system_instruction, str
+            ), "System message content must be a string"
+        else:
+            system_instruction = None
+        return system_instruction, cast(types.ContentListUnion, contents)
+
+    def get_num_tokens(self, text: str) -> int:
+        """Get the number of tokens present in the text."""
+        contents = convert_messages_to_contents([HumanMessage(content=text)])
+        response = self.client.models.count_tokens(
+            model=self.model_name,
+            contents=cast(types.ContentListUnion, contents),
+        )
+        return response.total_tokens or 0
+
+    def _generate(
+        self,
+        messages: list[BaseMessage],
+        stop: list[str] | None = None,
+        run_manager: CallbackManagerForLLMRun | None = None,
+        **kwargs: Any,
+    ) -> ChatResult:
+        stream_iter = self._stream(
+            messages, stop=stop, run_manager=run_manager, **kwargs
+        )
+        return generate_from_stream(stream_iter)
+
+    async def _agenerate(
+        self,
+        messages: list[BaseMessage],
+        stop: list[str] | None = None,
+        run_manager: AsyncCallbackManagerForLLMRun | None = None,
+        **kwargs: Any,
+    ) -> ChatResult:
+        stream_iter = self._astream(
+            messages, stop=stop, run_manager=run_manager, **kwargs
+        )
+        return await agenerate_from_stream(stream_iter)
+
+    def _stream(
+        self,
+        messages: list[BaseMessage],
+        stop: list[str] | None = None,
+        run_manager: CallbackManagerForLLMRun | None = None,
+        **kwargs: Any,
+    ) -> Iterator[ChatGenerationChunk]:
+        system_message, contents = self._prepare_request(messages=messages)
+        response_iter = self.client.models.generate_content_stream(
+            model=self.model_name,
+            contents=contents,
+            config=types.GenerateContentConfig(
+                system_instruction=system_message,
+                temperature=self.temperature,
+                top_k=self.top_k,
+                top_p=self.top_p,
+                max_output_tokens=self.max_output_tokens,
+                candidate_count=self.n,
+                stop_sequences=stop or self.stop,
+                safety_settings=self.safety_settings,
+                **kwargs,
+            ),
+        )
+        total_lc_usage = None
+        for response_chunk in response_iter:
+            chunk, total_lc_usage = self._gemini_chunk_to_generation_chunk(
+                response_chunk, prev_total_usage=total_lc_usage
+            )
+            if run_manager and isinstance(chunk.message.content, str):
+                run_manager.on_llm_new_token(chunk.message.content)
+            yield chunk
+
+    async def _astream(
+        self,
+        messages: list[BaseMessage],
+        stop: list[str] | None = None,
+        run_manager: AsyncCallbackManagerForLLMRun | None = None,
+        **kwargs: Any,
+    ) -> AsyncIterator[ChatGenerationChunk]:
+        system_message, contents = self._prepare_request(messages=messages)
+        response_iter = self.client.aio.models.generate_content_stream(
+            model=self.model_name,
+            contents=contents,
+            config=types.GenerateContentConfig(
+                system_instruction=system_message,
+                temperature=self.temperature,
+                top_k=self.top_k,
+                top_p=self.top_p,
+                max_output_tokens=self.max_output_tokens,
+                candidate_count=self.n,
+                stop_sequences=stop or self.stop,
+                safety_settings=self.safety_settings,
+                **kwargs,
+            ),
+        )
+        total_lc_usage = None
+        async for response_chunk in await response_iter:
+            chunk, total_lc_usage = self._gemini_chunk_to_generation_chunk(
+                response_chunk, prev_total_usage=total_lc_usage
+            )
+            if run_manager and isinstance(chunk.message.content, str):
+                await run_manager.on_llm_new_token(chunk.message.content)
+            yield chunk
+
+    def with_structured_output(
+        self,
+        schema: dict | type,
+        *,
+        include_raw: bool = False,
+        method: Literal["json_mode", "function_calling"] = "json_mode",
+        **kwargs: Any,
+    ) -> Runnable[LanguageModelInput, dict | BaseModel]:
+        assert isinstance(schema, type) and issubclass(
+            schema, BaseModel
+        ), "Structured output is only supported for Pydantic models."
+        if kwargs:
+            raise ValueError(f"Received unsupported arguments {kwargs}")
+
+        parser: OutputParserLike
+
+        if method == "json_mode":
+            parser = PydanticOutputParser(pydantic_object=schema)
+
+            llm = self.bind(
+                response_mime_type="application/json",
+                response_schema=schema,
+                ls_structured_output_format={
+                    "kwargs": {"method": method},
+                    "schema": schema,
+                },
+            )
+        elif method == "function_calling":
+            parser = PydanticToolsParser(tools=[schema], first_tool_only=True)
+            tool_choice = schema.__name__
+            llm = self.bind_tools(
+                [schema],
+                tool_choice=tool_choice,
+                ls_structured_output_format={
+                    "kwargs": {"method": "function_calling"},
+                    "schema": convert_to_openai_tool(schema),
+                },
+            )
+        else:
+            raise ValueError("method must be either 'json_mode' or 'function_calling'.")
+
+        if include_raw:
+            parser_with_fallback = RunnablePassthrough.assign(
+                parsed=itemgetter("raw") | parser, parsing_error=lambda _: None
+            ).with_fallbacks(
+                [RunnablePassthrough.assign(parsed=lambda _: None)],
+                exception_key="parsing_error",
+            )
+            return {"raw": llm} | parser_with_fallback
+        else:
+            return llm | parser
+
+    def bind_tools(
+        self,
+        tools: Sequence[
+            dict[str, Any] | type | Callable[..., Any] | BaseTool | types.Tool
+        ],
+        *,
+        tool_choice: str | None = None,
+        **kwargs: Any,
+    ) -> Runnable[LanguageModelInput, BaseMessage]:
+        """Bind tool-like objects to this chat model.
+
+        Assumes model is compatible with Vertex tool-calling API.
+
+        Args:
+            tools: A list of tool definitions to bind to this chat model.
+                Can be a pydantic model, callable, or BaseTool. Pydantic
+                models, callables, and BaseTools will be automatically converted to
+                their schema dictionary representation.
+            **kwargs: Any additional parameters to pass to the
+                :class:`~langchain.runnable.Runnable` constructor.
+        """
+        formatted_tools = []
+        for tool in tools:
+            if not isinstance(tool, types.Tool):
+                openai_tool = convert_to_openai_tool(tool)
+                if openai_tool["type"] != "function":
+                    raise ValueError(
+                        f"Tool {tool} is not a function tool. "
+                        f"It is a {openai_tool['type']}. "
+                        "Only function tools are supported."
+                    )
+                function = openai_tool["function"]
+                formatted_tools.append(
+                    types.Tool(
+                        function_declarations=[types.FunctionDeclaration(**function)],
+                    )
+                )
+            else:
+                formatted_tools.append(tool)
+        if tool_choice:
+            kwargs["tool_config"] = types.FunctionCallingConfig(
+                mode=types.FunctionCallingConfigMode.ANY,
+                allowed_function_names=[tool_choice],
+            )
+        return self.bind(tools=formatted_tools, **kwargs)
+
+    def _gemini_chunk_to_generation_chunk(
+        self,
+        response_chunk: types.GenerateContentResponse,
+        prev_total_usage: UsageMetadata | None = None,
+    ) -> tuple[ChatGenerationChunk, UsageMetadata | None]:
+        def _parse_usage_metadata(
+            usage_metadata: types.GenerateContentResponseUsageMetadata,
+        ) -> UsageMetadata:
+            return UsageMetadata(
+                input_tokens=usage_metadata.prompt_token_count or 0,
+                output_tokens=usage_metadata.candidates_token_count or 0,
+                total_tokens=usage_metadata.total_token_count or 0,
+            )
+
+        total_lc_usage: UsageMetadata | None = (
+            _parse_usage_metadata(response_chunk.usage_metadata)
+            if response_chunk.usage_metadata
+            else None
+        )
+
+        if total_lc_usage and prev_total_usage:
+            lc_usage: UsageMetadata | None = UsageMetadata(
+                input_tokens=total_lc_usage["input_tokens"]
+                - prev_total_usage["input_tokens"],
+                output_tokens=total_lc_usage["output_tokens"]
+                - prev_total_usage["output_tokens"],
+                total_tokens=total_lc_usage["total_tokens"]
+                - prev_total_usage["total_tokens"],
+            )
+        else:
+            lc_usage = total_lc_usage
+        if not response_chunk.candidates:
+            message = AIMessageChunk(content="")
+            if lc_usage:
+                message.usage_metadata = lc_usage
+            generation_info = {}
+        else:
+            top_candidate = response_chunk.candidates[0]
+            generation_info = {
+                "finish_reason": top_candidate.finish_reason,
+                "finish_message": top_candidate.finish_message,
+            }
+            message = parse_response_candidate(top_candidate)
+            if lc_usage:
+                message.usage_metadata = lc_usage
+            # add model name if final chunk
+            if top_candidate.finish_reason is not None:
+                message.response_metadata["model_name"] = self.model_name
+
+        return (
+            ChatGenerationChunk(
+                message=message,
+                generation_info=generation_info,
+            ),
+            total_lc_usage,
+        )

langchain_b12/genai/genai_utils.py

@@ -0,0 +1,219 @@
+import base64
+import json
+import uuid
+from collections.abc import Sequence
+from typing import Any, cast
+
+from google.genai import types
+from langchain_core.messages import (
+    AIMessage,
+    AIMessageChunk,
+    BaseMessage,
+    HumanMessage,
+    SystemMessage,
+    ToolMessage,
+)
+from langchain_core.messages.tool import tool_call_chunk
+
+
+def multi_content_to_part(
+    contents: Sequence[dict[str, str | dict[str, str]] | str],
+) -> list[types.Part]:
+    """Convert sequence content to a Part object.
+
+    Args:
+        contents: A sequence of dictionaries representing content. Examples:
+            [
+                {
+                    "type": "text",
+                    "text": "This is a text message"
+                },
+                {
+                    "type": "image_url",
+                    "image_url": {
+                        "url": f"data:{mime_type};base64,{encoded_artifact}"
+                    },
+                },
+                {
+                    "type": "file",
+                    "file": {
+                        "uri": f"gs://{bucket_name}/{file_name}",
+                        "mime_type": mime_type,
+                    }
+                }
+            ]
+    """
+    parts = []
+    for content in contents:
+        assert isinstance(content, dict), "Expected dict content"
+        assert "type" in content, "Received dict content without type"
+        if content["type"] == "text":
+            assert "text" in content, "Expected 'text' in content"
+            if content["text"]:
+                assert isinstance(content["text"], str), "Expected str content"
+                parts.append(types.Part(text=content["text"]))
+        elif content["type"] == "image_url":
+            assert isinstance(content["image_url"], dict), "Expected dict image_url"
+            assert "url" in content["image_url"], "Expected 'url' in content"
+            split_url: tuple[str, str] = content["image_url"]["url"].split(",", 1)  # type: ignore
+            header, encoded_data = split_url
+            mime_type = header.split(":", 1)[1].split(";", 1)[0]
+            data = base64.b64decode(encoded_data)
+            parts.append(types.Part.from_bytes(data=data, mime_type=mime_type))
+        elif content["type"] == "file":
+            assert "file" in content, "Expected 'file' in content"
+            file = content["file"]
+            assert isinstance(file, dict), "Expected dict file"
+            assert "uri" in file, "Expected 'uri' in content['file']"
+            assert "mime_type" in file, "Expected 'mime_type' in content['file']"
+            parts.append(
+                types.Part.from_uri(file_uri=file["uri"], mime_type=file["mime_type"])
+            )
+        else:
+            raise ValueError(f"Unknown content type: {content['type']}")
+    return parts
+
+
+def convert_base_message_to_parts(
+    message: BaseMessage,
+) -> list[types.Part]:
+    """Convert a LangChain BaseMessage to Google GenAI Content object."""
+    parts = []
+    if isinstance(message.content, str):
+        if message.content:
+            parts.append(types.Part(text=message.content))
+    elif isinstance(message.content, list):
+        parts.extend(multi_content_to_part(message.content))
+    else:
+        raise ValueError(
+            "Received unexpected content type, "
+            f"expected str or list, but got {type(message.content)}"
+        )
+    return parts
+
+
+def convert_messages_to_contents(
+    messages: Sequence[BaseMessage],
+) -> list[types.Content]:
+    """Convert a sequence of LangChain messages to Google GenAI Content objects.
+
+    Args:
+        messages: A sequence of LangChain BaseMessage objects
+
+    Returns:
+        A list of Google GenAI Content objects
+    """
+    contents = []
+
+    for message in messages:
+        if isinstance(message, HumanMessage):
+            parts = convert_base_message_to_parts(message)
+            contents.append(types.UserContent(parts=parts))
+        elif isinstance(message, AIMessage):
+            text_parts = convert_base_message_to_parts(message)
+            function_parts = []
+            if message.tool_calls:
+                # Example of tool_call
+                # tool_call = {
+                #     "name": "foo",
+                #     "args": {"a": 1},
+                #     "id": "123"
+                # }
+                for tool_call in message.tool_calls:
+                    tool_id = tool_call["id"]
+                    assert tool_id, "Tool call ID is required"
+                    function_parts.append(
+                        types.Part(
+                            function_call=types.FunctionCall(
+                                name=tool_call["name"],
+                                args=tool_call["args"],
+                                id=tool_id,
+                            ),
+                        )
+                    )
+
+            contents.append(
+                types.ModelContent(
+                    parts=[*text_parts, *function_parts],
+                )
+            )
+        elif isinstance(message, ToolMessage):
+            # Note: We tried combining function_call and function_response into one
+            # part, but that throws a 4xx server error.
+            assert isinstance(message.content, str), "Expected str content"
+            assert message.name, "Tool name is required"
+            tool_part = types.Part(
+                function_response=types.FunctionResponse(
+                    id=message.tool_call_id,
+                    name=message.name,
+                    response={"output": message.content},
+                ),
+            )
+
+            # Ensure that all function_responses are in a single content
+            last_content = contents[-1]
+            last_content_part = last_content.parts[-1]
+            if last_content_part.function_response:
+                # Merge with the last content
+                last_content.parts.append(tool_part)
+            else:
+                # Create a new content
+                contents.append(types.UserContent(parts=[tool_part]))
+        elif isinstance(message, SystemMessage):
+            # There is no genai.types equivalent for SystemMessage
+            pass
+        else:
+            raise ValueError(f"Invalid message type: {type(message)}")
+
+    return contents
+
+
+def parse_response_candidate(response_candidate: types.Candidate) -> AIMessageChunk:
+    content: None | str | list[str] = None
+    additional_kwargs = {}
+    tool_call_chunks = []
+
+    assert response_candidate.content, "Response candidate content is None"
+    for part in response_candidate.content.parts or []:
+        try:
+            text: str | None = part.text
+        except AttributeError:
+            text = None
+
+        if text:
+            if not content:
+                content = text
+            elif isinstance(content, str):
+                content = [content, text]
+            elif isinstance(content, list):
+                content.append(text)
+            else:
+                raise ValueError("Unexpected content type")
+
+        if part.function_call:
+            # For backward compatibility we store a function call in additional_kwargs,
+            # but in general the full set of function calls is stored in tool_calls.
+            function_call = {"name": part.function_call.name}
+            # dump to match other function calling llm for now
+            function_call_args_dict = part.function_call.args
+            assert function_call_args_dict is not None
+            function_call["arguments"] = json.dumps(function_call_args_dict)
+            additional_kwargs["function_call"] = function_call
+
+            index = function_call.get("index")
+            tool_call_chunks.append(
+                tool_call_chunk(
+                    name=function_call.get("name"),
+                    args=function_call.get("arguments"),
+                    id=function_call.get("id", str(uuid.uuid4())),
+                    index=int(index) if index else None,
+                )
+            )
+    if content is None:
+        content = ""
+
+    return AIMessageChunk(
+        content=cast(str | list[str | dict[Any, Any]], content),
+        additional_kwargs=additional_kwargs,
+        tool_call_chunks=tool_call_chunks,
+    )

langchain_b12-0.1.0.dist-info/METADATA

@@ -0,0 +1,39 @@
+Metadata-Version: 2.4
+Name: langchain-b12
+Version: 0.1.0
+Summary: A reusable collection of tools and implementations for Langchain
+Author-email: Vincent Min <vincent.min@b12-consulting.com>
+Requires-Python: >=3.11
+Requires-Dist: langchain-core>=0.3.60
+Description-Content-Type: text/markdown
+
+# Langchain B12
+
+This repo hosts a collection of custom LangChain components.
+
+- ChatGenAI converts a sequence of LangChain messages to Google GenAI Content objects and vice versa.
+
+## Installation
+
+To install this package, run
+```bash
+pip install langchain-b12
+```
+
+Some components rely on additional packages that may be installed as extras.
+For example, to use the Google chatmodel `ChatGenAI`, you can run
+```bash
+pip install langchain-b12[google]
+```
+
+## Components
+
+The repo contains these components:
+
+- `ChatGenAI`: An implementation of `BaseChatModel` that uses the `google-genai` package. Note that `langchain-google-genai` and `langchain-google-vertexai` exist, but neither uses the latest and recommended `google-genai` package.
+- `GenAIEmbeddings`: An implementation of `Embeddings` that uses the `google-genai` package.
+
+## Comments
+
+This repo exists for easy reuse and extension of custom LangChain components.
+When appropriate, we will create PRs to merge these components directly into LangChain.

langchain_b12-0.1.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+langchain_b12/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+langchain_b12/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+langchain_b12/genai/embeddings.py,sha256=od2bVIgt7v9aNAHG0PVypVF1H_XgHto2nTd8vwfvyN8,3355
+langchain_b12/genai/genai.py,sha256=o2KLo2QlLDy0hijt6T2HaRmjSO60SV62dR_Cso6Ad-8,15796
+langchain_b12/genai/genai_utils.py,sha256=2ojnSumovXyx3CxM7JwzyOkEdD7mQxfLnk50-usPbw8,8221
+langchain_b12-0.1.0.dist-info/METADATA,sha256=72Ct-UG2KHnPQuyUltOQ_HGpvLbDrXglmPn-eY9blnc,1307
+langchain_b12-0.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+langchain_b12-0.1.0.dist-info/RECORD,,

langchain_b12-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any