Add files using upload-large-folder tool

python/user_packages/Python313/site-packages/langchain_community/embeddings/__init__.py

@@ -0,0 +1,454 @@
+"""**Embedding models**  are wrappers around embedding models
+from different APIs and services.
+
+**Embedding models** can be LLMs or not.
+
+**Class hierarchy:**
+
+.. code-block::
+
+    Embeddings --> <name>Embeddings  # Examples: OpenAIEmbeddings, HuggingFaceEmbeddings
+"""
+
+import importlib
+import logging
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from langchain_community.embeddings.aleph_alpha import (
+        AlephAlphaAsymmetricSemanticEmbedding,
+        AlephAlphaSymmetricSemanticEmbedding,
+    )
+    from langchain_community.embeddings.anyscale import (
+        AnyscaleEmbeddings,
+    )
+    from langchain_community.embeddings.ascend import (
+        AscendEmbeddings,
+    )
+    from langchain_community.embeddings.awa import (
+        AwaEmbeddings,
+    )
+    from langchain_community.embeddings.azure_openai import (
+        AzureOpenAIEmbeddings,
+    )
+    from langchain_community.embeddings.baichuan import (
+        BaichuanTextEmbeddings,
+    )
+    from langchain_community.embeddings.baidu_qianfan_endpoint import (
+        QianfanEmbeddingsEndpoint,
+    )
+    from langchain_community.embeddings.bedrock import (
+        BedrockEmbeddings,
+    )
+    from langchain_community.embeddings.bookend import (
+        BookendEmbeddings,
+    )
+    from langchain_community.embeddings.clarifai import (
+        ClarifaiEmbeddings,
+    )
+    from langchain_community.embeddings.clova import (
+        ClovaEmbeddings,
+    )
+    from langchain_community.embeddings.cohere import (
+        CohereEmbeddings,
+    )
+    from langchain_community.embeddings.dashscope import (
+        DashScopeEmbeddings,
+    )
+    from langchain_community.embeddings.databricks import (
+        DatabricksEmbeddings,
+    )
+    from langchain_community.embeddings.deepinfra import (
+        DeepInfraEmbeddings,
+    )
+    from langchain_community.embeddings.edenai import (
+        EdenAiEmbeddings,
+    )
+    from langchain_community.embeddings.elasticsearch import (
+        ElasticsearchEmbeddings,
+    )
+    from langchain_community.embeddings.embaas import (
+        EmbaasEmbeddings,
+    )
+    from langchain_community.embeddings.ernie import (
+        ErnieEmbeddings,
+    )
+    from langchain_community.embeddings.fake import (
+        DeterministicFakeEmbedding,
+        FakeEmbeddings,
+    )
+    from langchain_community.embeddings.fastembed import (
+        FastEmbedEmbeddings,
+    )
+    from langchain_community.embeddings.gigachat import (
+        GigaChatEmbeddings,
+    )
+    from langchain_community.embeddings.google_palm import (
+        GooglePalmEmbeddings,
+    )
+    from langchain_community.embeddings.gpt4all import (
+        GPT4AllEmbeddings,
+    )
+    from langchain_community.embeddings.gradient_ai import (
+        GradientEmbeddings,
+    )
+    from langchain_community.embeddings.huggingface import (
+        HuggingFaceBgeEmbeddings,
+        HuggingFaceEmbeddings,
+        HuggingFaceInferenceAPIEmbeddings,
+        HuggingFaceInstructEmbeddings,
+    )
+    from langchain_community.embeddings.huggingface_hub import (
+        HuggingFaceHubEmbeddings,
+    )
+    from langchain_community.embeddings.hunyuan import (
+        HunyuanEmbeddings,
+    )
+    from langchain_community.embeddings.infinity import (
+        InfinityEmbeddings,
+    )
+    from langchain_community.embeddings.infinity_local import (
+        InfinityEmbeddingsLocal,
+    )
+    from langchain_community.embeddings.ipex_llm import IpexLLMBgeEmbeddings
+    from langchain_community.embeddings.itrex import (
+        QuantizedBgeEmbeddings,
+    )
+    from langchain_community.embeddings.javelin_ai_gateway import (
+        JavelinAIGatewayEmbeddings,
+    )
+    from langchain_community.embeddings.jina import (
+        JinaEmbeddings,
+    )
+    from langchain_community.embeddings.johnsnowlabs import (
+        JohnSnowLabsEmbeddings,
+    )
+    from langchain_community.embeddings.laser import (
+        LaserEmbeddings,
+    )
+    from langchain_community.embeddings.llamacpp import (
+        LlamaCppEmbeddings,
+    )
+    from langchain_community.embeddings.llamafile import (
+        LlamafileEmbeddings,
+    )
+    from langchain_community.embeddings.llm_rails import (
+        LLMRailsEmbeddings,
+    )
+    from langchain_community.embeddings.localai import (
+        LocalAIEmbeddings,
+    )
+    from langchain_community.embeddings.minimax import (
+        MiniMaxEmbeddings,
+    )
+    from langchain_community.embeddings.mlflow import (
+        MlflowCohereEmbeddings,
+        MlflowEmbeddings,
+    )
+    from langchain_community.embeddings.mlflow_gateway import (
+        MlflowAIGatewayEmbeddings,
+    )
+    from langchain_community.embeddings.model2vec import (
+        Model2vecEmbeddings,
+    )
+    from langchain_community.embeddings.modelscope_hub import (
+        ModelScopeEmbeddings,
+    )
+    from langchain_community.embeddings.mosaicml import (
+        MosaicMLInstructorEmbeddings,
+    )
+    from langchain_community.embeddings.naver import (
+        ClovaXEmbeddings,
+    )
+    from langchain_community.embeddings.nemo import (
+        NeMoEmbeddings,
+    )
+    from langchain_community.embeddings.nlpcloud import (
+        NLPCloudEmbeddings,
+    )
+    from langchain_community.embeddings.oci_generative_ai import (
+        OCIGenAIEmbeddings,
+    )
+    from langchain_community.embeddings.octoai_embeddings import (
+        OctoAIEmbeddings,
+    )
+    from langchain_community.embeddings.ollama import (
+        OllamaEmbeddings,
+    )
+    from langchain_community.embeddings.openai import (
+        OpenAIEmbeddings,
+    )
+    from langchain_community.embeddings.openvino import (
+        OpenVINOBgeEmbeddings,
+        OpenVINOEmbeddings,
+    )
+    from langchain_community.embeddings.optimum_intel import (
+        QuantizedBiEncoderEmbeddings,
+    )
+    from langchain_community.embeddings.oracleai import (
+        OracleEmbeddings,
+    )
+    from langchain_community.embeddings.ovhcloud import (
+        OVHCloudEmbeddings,
+    )
+    from langchain_community.embeddings.premai import (
+        PremAIEmbeddings,
+    )
+    from langchain_community.embeddings.sagemaker_endpoint import (
+        SagemakerEndpointEmbeddings,
+    )
+    from langchain_community.embeddings.sambanova import (
+        SambaStudioEmbeddings,
+    )
+    from langchain_community.embeddings.self_hosted import (
+        SelfHostedEmbeddings,
+    )
+    from langchain_community.embeddings.self_hosted_hugging_face import (
+        SelfHostedHuggingFaceEmbeddings,
+        SelfHostedHuggingFaceInstructEmbeddings,
+    )
+    from langchain_community.embeddings.sentence_transformer import (
+        SentenceTransformerEmbeddings,
+    )
+    from langchain_community.embeddings.solar import (
+        SolarEmbeddings,
+    )
+    from langchain_community.embeddings.spacy_embeddings import (
+        SpacyEmbeddings,
+    )
+    from langchain_community.embeddings.sparkllm import (
+        SparkLLMTextEmbeddings,
+    )
+    from langchain_community.embeddings.tensorflow_hub import (
+        TensorflowHubEmbeddings,
+    )
+    from langchain_community.embeddings.textembed import (
+        TextEmbedEmbeddings,
+    )
+    from langchain_community.embeddings.titan_takeoff import (
+        TitanTakeoffEmbed,
+    )
+    from langchain_community.embeddings.vertexai import (
+        VertexAIEmbeddings,
+    )
+    from langchain_community.embeddings.volcengine import (
+        VolcanoEmbeddings,
+    )
+    from langchain_community.embeddings.voyageai import (
+        VoyageEmbeddings,
+    )
+    from langchain_community.embeddings.xinference import (
+        XinferenceEmbeddings,
+    )
+    from langchain_community.embeddings.yandex import (
+        YandexGPTEmbeddings,
+    )
+    from langchain_community.embeddings.zhipuai import (
+        ZhipuAIEmbeddings,
+    )
+
+__all__ = [
+    "AlephAlphaAsymmetricSemanticEmbedding",
+    "AlephAlphaSymmetricSemanticEmbedding",
+    "AnyscaleEmbeddings",
+    "AscendEmbeddings",
+    "AwaEmbeddings",
+    "AzureOpenAIEmbeddings",
+    "BaichuanTextEmbeddings",
+    "BedrockEmbeddings",
+    "BookendEmbeddings",
+    "ClarifaiEmbeddings",
+    "ClovaEmbeddings",
+    "ClovaXEmbeddings",
+    "CohereEmbeddings",
+    "DashScopeEmbeddings",
+    "DatabricksEmbeddings",
+    "DeepInfraEmbeddings",
+    "DeterministicFakeEmbedding",
+    "EdenAiEmbeddings",
+    "ElasticsearchEmbeddings",
+    "EmbaasEmbeddings",
+    "ErnieEmbeddings",
+    "FakeEmbeddings",
+    "FastEmbedEmbeddings",
+    "GPT4AllEmbeddings",
+    "GigaChatEmbeddings",
+    "GooglePalmEmbeddings",
+    "GradientEmbeddings",
+    "HuggingFaceBgeEmbeddings",
+    "HuggingFaceEmbeddings",
+    "HuggingFaceHubEmbeddings",
+    "HuggingFaceInferenceAPIEmbeddings",
+    "HuggingFaceInstructEmbeddings",
+    "InfinityEmbeddings",
+    "InfinityEmbeddingsLocal",
+    "IpexLLMBgeEmbeddings",
+    "JavelinAIGatewayEmbeddings",
+    "JinaEmbeddings",
+    "JohnSnowLabsEmbeddings",
+    "LLMRailsEmbeddings",
+    "LaserEmbeddings",
+    "LlamaCppEmbeddings",
+    "LlamafileEmbeddings",
+    "LocalAIEmbeddings",
+    "MiniMaxEmbeddings",
+    "MlflowAIGatewayEmbeddings",
+    "MlflowCohereEmbeddings",
+    "MlflowEmbeddings",
+    "Model2vecEmbeddings",
+    "ModelScopeEmbeddings",
+    "MosaicMLInstructorEmbeddings",
+    "NLPCloudEmbeddings",
+    "NeMoEmbeddings",
+    "OCIGenAIEmbeddings",
+    "OctoAIEmbeddings",
+    "OllamaEmbeddings",
+    "OpenAIEmbeddings",
+    "OpenVINOBgeEmbeddings",
+    "OpenVINOEmbeddings",
+    "OracleEmbeddings",
+    "OVHCloudEmbeddings",
+    "PremAIEmbeddings",
+    "QianfanEmbeddingsEndpoint",
+    "QuantizedBgeEmbeddings",
+    "QuantizedBiEncoderEmbeddings",
+    "SagemakerEndpointEmbeddings",
+    "SambaStudioEmbeddings",
+    "SelfHostedEmbeddings",
+    "SelfHostedHuggingFaceEmbeddings",
+    "SelfHostedHuggingFaceInstructEmbeddings",
+    "SentenceTransformerEmbeddings",
+    "SolarEmbeddings",
+    "SpacyEmbeddings",
+    "SparkLLMTextEmbeddings",
+    "TensorflowHubEmbeddings",
+    "TextEmbedEmbeddings",
+    "TitanTakeoffEmbed",
+    "VertexAIEmbeddings",
+    "VolcanoEmbeddings",
+    "VoyageEmbeddings",
+    "XinferenceEmbeddings",
+    "YandexGPTEmbeddings",
+    "ZhipuAIEmbeddings",
+    "HunyuanEmbeddings",
+]
+
+_module_lookup = {
+    "AlephAlphaAsymmetricSemanticEmbedding": "langchain_community.embeddings.aleph_alpha",  # noqa: E501
+    "AlephAlphaSymmetricSemanticEmbedding": "langchain_community.embeddings.aleph_alpha",  # noqa: E501
+    "AnyscaleEmbeddings": "langchain_community.embeddings.anyscale",
+    "AwaEmbeddings": "langchain_community.embeddings.awa",
+    "AzureOpenAIEmbeddings": "langchain_community.embeddings.azure_openai",
+    "BaichuanTextEmbeddings": "langchain_community.embeddings.baichuan",
+    "BedrockEmbeddings": "langchain_community.embeddings.bedrock",
+    "BookendEmbeddings": "langchain_community.embeddings.bookend",
+    "ClarifaiEmbeddings": "langchain_community.embeddings.clarifai",
+    "ClovaEmbeddings": "langchain_community.embeddings.clova",
+    "ClovaXEmbeddings": "langchain_community.embeddings.naver",
+    "CohereEmbeddings": "langchain_community.embeddings.cohere",
+    "DashScopeEmbeddings": "langchain_community.embeddings.dashscope",
+    "DatabricksEmbeddings": "langchain_community.embeddings.databricks",
+    "DeepInfraEmbeddings": "langchain_community.embeddings.deepinfra",
+    "DeterministicFakeEmbedding": "langchain_community.embeddings.fake",
+    "EdenAiEmbeddings": "langchain_community.embeddings.edenai",
+    "ElasticsearchEmbeddings": "langchain_community.embeddings.elasticsearch",
+    "EmbaasEmbeddings": "langchain_community.embeddings.embaas",
+    "ErnieEmbeddings": "langchain_community.embeddings.ernie",
+    "FakeEmbeddings": "langchain_community.embeddings.fake",
+    "FastEmbedEmbeddings": "langchain_community.embeddings.fastembed",
+    "GPT4AllEmbeddings": "langchain_community.embeddings.gpt4all",
+    "GooglePalmEmbeddings": "langchain_community.embeddings.google_palm",
+    "GradientEmbeddings": "langchain_community.embeddings.gradient_ai",
+    "GigaChatEmbeddings": "langchain_community.embeddings.gigachat",
+    "HuggingFaceBgeEmbeddings": "langchain_community.embeddings.huggingface",
+    "HuggingFaceEmbeddings": "langchain_community.embeddings.huggingface",
+    "HuggingFaceHubEmbeddings": "langchain_community.embeddings.huggingface_hub",
+    "HuggingFaceInferenceAPIEmbeddings": "langchain_community.embeddings.huggingface",
+    "HuggingFaceInstructEmbeddings": "langchain_community.embeddings.huggingface",
+    "InfinityEmbeddings": "langchain_community.embeddings.infinity",
+    "InfinityEmbeddingsLocal": "langchain_community.embeddings.infinity_local",
+    "IpexLLMBgeEmbeddings": "langchain_community.embeddings.ipex_llm",
+    "JavelinAIGatewayEmbeddings": "langchain_community.embeddings.javelin_ai_gateway",
+    "JinaEmbeddings": "langchain_community.embeddings.jina",
+    "JohnSnowLabsEmbeddings": "langchain_community.embeddings.johnsnowlabs",
+    "LLMRailsEmbeddings": "langchain_community.embeddings.llm_rails",
+    "LaserEmbeddings": "langchain_community.embeddings.laser",
+    "LlamaCppEmbeddings": "langchain_community.embeddings.llamacpp",
+    "LlamafileEmbeddings": "langchain_community.embeddings.llamafile",
+    "LocalAIEmbeddings": "langchain_community.embeddings.localai",
+    "MiniMaxEmbeddings": "langchain_community.embeddings.minimax",
+    "MlflowAIGatewayEmbeddings": "langchain_community.embeddings.mlflow_gateway",
+    "MlflowCohereEmbeddings": "langchain_community.embeddings.mlflow",
+    "MlflowEmbeddings": "langchain_community.embeddings.mlflow",
+    "Model2vecEmbeddings": "langchain_community.embeddings.model2vec",
+    "ModelScopeEmbeddings": "langchain_community.embeddings.modelscope_hub",
+    "MosaicMLInstructorEmbeddings": "langchain_community.embeddings.mosaicml",
+    "NLPCloudEmbeddings": "langchain_community.embeddings.nlpcloud",
+    "NeMoEmbeddings": "langchain_community.embeddings.nemo",
+    "OCIGenAIEmbeddings": "langchain_community.embeddings.oci_generative_ai",
+    "OctoAIEmbeddings": "langchain_community.embeddings.octoai_embeddings",
+    "OllamaEmbeddings": "langchain_community.embeddings.ollama",
+    "OpenAIEmbeddings": "langchain_community.embeddings.openai",
+    "OpenVINOEmbeddings": "langchain_community.embeddings.openvino",
+    "OpenVINOBgeEmbeddings": "langchain_community.embeddings.openvino",
+    "QianfanEmbeddingsEndpoint": "langchain_community.embeddings.baidu_qianfan_endpoint",  # noqa: E501
+    "QuantizedBgeEmbeddings": "langchain_community.embeddings.itrex",
+    "QuantizedBiEncoderEmbeddings": "langchain_community.embeddings.optimum_intel",
+    "OracleEmbeddings": "langchain_community.embeddings.oracleai",
+    "OVHCloudEmbeddings": "langchain_community.embeddings.ovhcloud",
+    "SagemakerEndpointEmbeddings": "langchain_community.embeddings.sagemaker_endpoint",
+    "SambaStudioEmbeddings": "langchain_community.embeddings.sambanova",
+    "SelfHostedEmbeddings": "langchain_community.embeddings.self_hosted",
+    "SelfHostedHuggingFaceEmbeddings": "langchain_community.embeddings.self_hosted_hugging_face",  # noqa: E501
+    "SelfHostedHuggingFaceInstructEmbeddings": "langchain_community.embeddings.self_hosted_hugging_face",  # noqa: E501
+    "SentenceTransformerEmbeddings": "langchain_community.embeddings.sentence_transformer",  # noqa: E501
+    "SolarEmbeddings": "langchain_community.embeddings.solar",
+    "SpacyEmbeddings": "langchain_community.embeddings.spacy_embeddings",
+    "SparkLLMTextEmbeddings": "langchain_community.embeddings.sparkllm",
+    "TensorflowHubEmbeddings": "langchain_community.embeddings.tensorflow_hub",
+    "VertexAIEmbeddings": "langchain_community.embeddings.vertexai",
+    "VolcanoEmbeddings": "langchain_community.embeddings.volcengine",
+    "VoyageEmbeddings": "langchain_community.embeddings.voyageai",
+    "XinferenceEmbeddings": "langchain_community.embeddings.xinference",
+    "TextEmbedEmbeddings": "langchain_community.embeddings.textembed",
+    "TitanTakeoffEmbed": "langchain_community.embeddings.titan_takeoff",
+    "PremAIEmbeddings": "langchain_community.embeddings.premai",
+    "YandexGPTEmbeddings": "langchain_community.embeddings.yandex",
+    "AscendEmbeddings": "langchain_community.embeddings.ascend",
+    "ZhipuAIEmbeddings": "langchain_community.embeddings.zhipuai",
+    "HunyuanEmbeddings": "langchain_community.embeddings.hunyuan",
+}
+
+
+def __getattr__(name: str) -> Any:
+    if name in _module_lookup:
+        module = importlib.import_module(_module_lookup[name])
+        return getattr(module, name)
+    raise AttributeError(f"module {__name__} has no attribute {name}")
+
+
+logger = logging.getLogger(__name__)
+
+
+# TODO: this is in here to maintain backwards compatibility
+class HypotheticalDocumentEmbedder:
+    def __init__(self, *args: Any, **kwargs: Any):
+        logger.warning(
+            "Using a deprecated class. Please use "
+            "`from langchain_classic.chains import HypotheticalDocumentEmbedder` "
+            "instead"
+        )
+        from langchain_classic.chains.hyde.base import HypotheticalDocumentEmbedder as H
+
+        return H(*args, **kwargs)  # type: ignore[return-value]
+
+    @classmethod
+    def from_llm(cls, *args: Any, **kwargs: Any) -> Any:
+        logger.warning(
+            "Using a deprecated class. Please use "
+            "`from langchain_classic.chains import HypotheticalDocumentEmbedder` "
+            "instead"
+        )
+        from langchain_classic.chains.hyde.base import HypotheticalDocumentEmbedder as H
+
+        return H.from_llm(*args, **kwargs)

python/user_packages/Python313/site-packages/langchain_community/embeddings/javelin_ai_gateway.py

@@ -0,0 +1,109 @@
+from __future__ import annotations
+
+from typing import Any, Iterator, List, Optional
+
+from langchain_core.embeddings import Embeddings
+from pydantic import BaseModel
+
+
+def _chunk(texts: List[str], size: int) -> Iterator[List[str]]:
+    for i in range(0, len(texts), size):
+        yield texts[i : i + size]
+
+
+class JavelinAIGatewayEmbeddings(Embeddings, BaseModel):
+    """Javelin AI Gateway embeddings.
+
+    To use, you should have the ``javelin_sdk`` python package installed.
+    For more information, see https://docs.getjavelin.io
+
+    Example:
+        .. code-block:: python
+
+            from langchain_community.embeddings import JavelinAIGatewayEmbeddings
+
+            embeddings = JavelinAIGatewayEmbeddings(
+                gateway_uri="<javelin-ai-gateway-uri>",
+                route="<your-javelin-gateway-embeddings-route>"
+            )
+    """
+
+    client: Any
+    """javelin client."""
+
+    route: str
+    """The route to use for the Javelin AI Gateway API."""
+
+    gateway_uri: Optional[str] = None
+    """The URI for the Javelin AI Gateway API."""
+
+    javelin_api_key: Optional[str] = None
+    """The API key for the Javelin AI Gateway API."""
+
+    def __init__(self, **kwargs: Any):
+        try:
+            from javelin_sdk import (
+                JavelinClient,
+                UnauthorizedError,
+            )
+        except ImportError:
+            raise ImportError(
+                "Could not import javelin_sdk python package. "
+                "Please install it with `pip install javelin_sdk`."
+            )
+
+        super().__init__(**kwargs)
+        if self.gateway_uri:
+            try:
+                self.client = JavelinClient(
+                    base_url=self.gateway_uri, api_key=self.javelin_api_key
+                )
+            except UnauthorizedError as e:
+                raise ValueError("Javelin: Incorrect API Key.") from e
+
+    def _query(self, texts: List[str]) -> List[List[float]]:
+        embeddings = []
+        for txt in _chunk(texts, 20):
+            try:
+                resp = self.client.query_route(self.route, query_body={"input": txt})
+                resp_dict = resp.dict()
+
+                embeddings_chunk = resp_dict.get("llm_response", {}).get("data", [])
+                for item in embeddings_chunk:
+                    if "embedding" in item:
+                        embeddings.append(item["embedding"])
+            except ValueError as e:
+                print("Failed to query route: " + str(e))  # noqa: T201
+
+        return embeddings
+
+    async def _aquery(self, texts: List[str]) -> List[List[float]]:
+        embeddings = []
+        for txt in _chunk(texts, 20):
+            try:
+                resp = await self.client.aquery_route(
+                    self.route, query_body={"input": txt}
+                )
+                resp_dict = resp.dict()
+
+                embeddings_chunk = resp_dict.get("llm_response", {}).get("data", [])
+                for item in embeddings_chunk:
+                    if "embedding" in item:
+                        embeddings.append(item["embedding"])
+            except ValueError as e:
+                print("Failed to query route: " + str(e))  # noqa: T201
+
+        return embeddings
+
+    def embed_documents(self, texts: List[str]) -> List[List[float]]:
+        return self._query(texts)
+
+    def embed_query(self, text: str) -> List[float]:
+        return self._query([text])[0]
+
+    async def aembed_documents(self, texts: List[str]) -> List[List[float]]:
+        return await self._aquery(texts)
+
+    async def aembed_query(self, text: str) -> List[float]:
+        result = await self._aquery([text])
+        return result[0]

python/user_packages/Python313/site-packages/langchain_community/embeddings/jina.py

@@ -0,0 +1,124 @@
+import base64
+from os.path import exists
+from typing import Any, Dict, List, Optional
+from urllib.parse import urlparse
+
+import requests
+from langchain_core.embeddings import Embeddings
+from langchain_core.utils import convert_to_secret_str, get_from_dict_or_env
+from pydantic import BaseModel, ConfigDict, SecretStr, model_validator
+
+JINA_API_URL: str = "https://api.jina.ai/v1/embeddings"
+
+
+def is_local(url: str) -> bool:
+    """Check if a URL is a local file.
+
+    Args:
+        url (str): The URL to check.
+
+    Returns:
+        bool: True if the URL is a local file, False otherwise.
+    """
+    url_parsed = urlparse(url)
+    if url_parsed.scheme in ("file", ""):  # Possibly a local file
+        return exists(url_parsed.path)
+    return False
+
+
+def get_bytes_str(file_path: str) -> str:
+    """Get the bytes string of a file.
+
+    Args:
+        file_path (str): The path to the file.
+
+    Returns:
+        str: The bytes string of the file.
+    """
+    with open(file_path, "rb") as image_file:
+        return base64.b64encode(image_file.read()).decode("utf-8")
+
+
+class JinaEmbeddings(BaseModel, Embeddings):
+    """Jina embedding models."""
+
+    session: Any  #: :meta private:
+    model_name: str = "jina-embeddings-v2-base-en"
+    jina_api_key: Optional[SecretStr] = None
+
+    model_config = ConfigDict(protected_namespaces=())
+
+    @model_validator(mode="before")
+    @classmethod
+    def validate_environment(cls, values: Dict) -> Any:
+        """Validate that auth token exists in environment."""
+        try:
+            jina_api_key = convert_to_secret_str(
+                get_from_dict_or_env(values, "jina_api_key", "JINA_API_KEY")
+            )
+        except ValueError as original_exc:
+            try:
+                jina_api_key = convert_to_secret_str(
+                    get_from_dict_or_env(values, "jina_auth_token", "JINA_AUTH_TOKEN")
+                )
+            except ValueError:
+                raise original_exc
+        session = requests.Session()
+        session.headers.update(
+            {
+                "Authorization": f"Bearer {jina_api_key.get_secret_value()}",
+                "Accept-Encoding": "identity",
+                "Content-type": "application/json",
+            }
+        )
+        values["session"] = session
+        return values
+
+    def _embed(self, input: Any) -> List[List[float]]:
+        # Call Jina AI Embedding API
+        resp = self.session.post(
+            JINA_API_URL, json={"input": input, "model": self.model_name}
+        ).json()
+        if "data" not in resp:
+            raise RuntimeError(resp["detail"])
+
+        embeddings = resp["data"]
+
+        # Sort resulting embeddings by index
+        sorted_embeddings = sorted(embeddings, key=lambda e: e["index"])
+
+        # Return just the embeddings
+        return [result["embedding"] for result in sorted_embeddings]
+
+    def embed_documents(self, texts: List[str]) -> List[List[float]]:
+        """Call out to Jina's embedding endpoint.
+        Args:
+            texts: The list of texts to embed.
+        Returns:
+            List of embeddings, one for each text.
+        """
+        return self._embed(texts)
+
+    def embed_query(self, text: str) -> List[float]:
+        """Call out to Jina's embedding endpoint.
+        Args:
+            text: The text to embed.
+        Returns:
+            Embeddings for the text.
+        """
+        return self._embed([text])[0]
+
+    def embed_images(self, uris: List[str]) -> List[List[float]]:
+        """Call out to Jina's image embedding endpoint.
+        Args:
+            uris: The list of uris to embed.
+        Returns:
+            List of embeddings, one for each text.
+        """
+        input = []
+        for uri in uris:
+            if is_local(uri):
+                input.append({"bytes": get_bytes_str(uri)})
+            else:
+                input.append({"url": uri})
+        return self._embed(input)

python/user_packages/Python313/site-packages/langchain_community/embeddings/johnsnowlabs.py

@@ -0,0 +1,91 @@
+import os
+import sys
+from typing import Any, List
+
+from langchain_core.embeddings import Embeddings
+from pydantic import BaseModel, ConfigDict
+
+
+class JohnSnowLabsEmbeddings(BaseModel, Embeddings):
+    """JohnSnowLabs embedding models
+
+    To use, you should have the ``johnsnowlabs`` python package installed.
+    Example:
+        .. code-block:: python
+
+            from langchain_community.embeddings.johnsnowlabs import JohnSnowLabsEmbeddings
+
+            embedding = JohnSnowLabsEmbeddings(model='embed_sentence.bert')
+            output = embedding.embed_query("foo bar")
+    """  # noqa: E501
+
+    model: Any = "embed_sentence.bert"
+
+    def __init__(
+        self,
+        model: Any = "embed_sentence.bert",
+        hardware_target: str = "cpu",
+        **kwargs: Any,
+    ):
+        """Initialize the johnsnowlabs model."""
+        super().__init__(**kwargs)
+        # 1) Check imports
+        try:
+            from johnsnowlabs import nlp
+            from nlu.pipe.pipeline import NLUPipeline
+        except ImportError as exc:
+            raise ImportError(
+                "Could not import johnsnowlabs python package. "
+                "Please install it with `pip install johnsnowlabs`."
+            ) from exc
+
+        # 2) Start a Spark Session
+        try:
+            os.environ["PYSPARK_PYTHON"] = sys.executable
+            os.environ["PYSPARK_DRIVER_PYTHON"] = sys.executable
+            nlp.start(hardware_target=hardware_target)
+        except Exception as exc:
+            raise Exception("Failure starting Spark Session") from exc
+
+        # 3) Load the model
+        try:
+            if isinstance(model, str):
+                self.model = nlp.load(model)
+            elif isinstance(model, NLUPipeline):
+                self.model = model
+            else:
+                self.model = nlp.to_nlu_pipe(model)
+        except Exception as exc:
+            raise Exception("Failure loading model") from exc
+
+    model_config = ConfigDict(
+        extra="forbid",
+    )
+
+    def embed_documents(self, texts: List[str]) -> List[List[float]]:
+        """Compute doc embeddings using a JohnSnowLabs transformer model.
+
+        Args:
+            texts: The list of texts to embed.
+
+        Returns:
+            List of embeddings, one for each text.
+        """
+
+        df = self.model.predict(texts, output_level="document")
+        emb_col = None
+        for c in df.columns:
+            if "embedding" in c:
+                emb_col = c
+        return [vec.tolist() for vec in df[emb_col].tolist()]
+
+    def embed_query(self, text: str) -> List[float]:
+        """Compute query embeddings using a JohnSnowLabs transformer model.
+
+        Args:
+            text: The text to embed.
+
+        Returns:
+            Embeddings for the text.
+        """
+        return self.embed_documents([text])[0]

python/user_packages/Python313/site-packages/langchain_community/embeddings/laser.py

@@ -0,0 +1,89 @@
+from typing import Any, Dict, List, Optional, cast
+
+import numpy as np
+from langchain_core.embeddings import Embeddings
+from langchain_core.utils import pre_init
+from pydantic import BaseModel, ConfigDict
+
+LASER_MULTILINGUAL_MODEL: str = "laser2"
+
+
+class LaserEmbeddings(BaseModel, Embeddings):
+    """LASER Language-Agnostic SEntence Representations.
+    LASER is a Python library developed by the Meta AI Research team
+    and used for creating multilingual sentence embeddings for over 147 languages
+    as of 2/25/2024
+    See more documentation at:
+    * https://github.com/facebookresearch/LASER/
+    * https://github.com/facebookresearch/LASER/tree/main/laser_encoders
+    * https://arxiv.org/abs/2205.12654
+
+    To use this class, you must install the `laser_encoders` Python package.
+
+    `pip install laser_encoders`
+    Example:
+        from laser_encoders import LaserEncoderPipeline
+        encoder = LaserEncoderPipeline(lang="eng_Latn")
+        embeddings = encoder.encode_sentences(["Hello", "World"])
+    """
+
+    lang: Optional[str] = None
+    """The language or language code you'd like to use
+    If empty, this implementation will default
+    to using a multilingual earlier LASER encoder model (called laser2)
+    Find the list of supported languages at
+    https://github.com/facebookresearch/flores/blob/main/flores200/README.md#languages-in-flores-200
+    """
+
+    _encoder_pipeline: Any = None  # : :meta private:
+
+    model_config = ConfigDict(
+        extra="forbid",
+    )
+
+    @pre_init
+    def validate_environment(cls, values: Dict) -> Dict:
+        """Validate that laser_encoders has been installed."""
+        try:
+            from laser_encoders import LaserEncoderPipeline
+
+            lang = values.get("lang")
+            if lang:
+                encoder_pipeline = LaserEncoderPipeline(lang=lang)
+            else:
+                encoder_pipeline = LaserEncoderPipeline(laser=LASER_MULTILINGUAL_MODEL)
+            values["_encoder_pipeline"] = encoder_pipeline
+
+        except ImportError as e:
+            raise ImportError(
+                "Could not import 'laser_encoders' Python package. "
+                "Please install it with `pip install laser_encoders`."
+            ) from e
+        return values
+
+    def embed_documents(self, texts: List[str]) -> List[List[float]]:
+        """Generate embeddings for documents using LASER.
+
+        Args:
+            texts: The list of texts to embed.
+
+        Returns:
+            List of embeddings, one for each text.
+        """
+        embeddings: np.ndarray
+        embeddings = self._encoder_pipeline.encode_sentences(texts)
+
+        return cast(List[List[float]], embeddings.tolist())
+
+    def embed_query(self, text: str) -> List[float]:
+        """Generate single query text embeddings using LASER.
+
+        Args:
+            text: The text to embed.
+
+        Returns:
+            Embeddings for the text.
+        """
+        query_embeddings: np.ndarray
+        query_embeddings = self._encoder_pipeline.encode_sentences([text])
+        return cast(List[List[float]], query_embeddings.tolist())[0]

python/user_packages/Python313/site-packages/langchain_community/embeddings/llamacpp.py

@@ -0,0 +1,145 @@
+from typing import Any, List, Optional
+
+from langchain_core.embeddings import Embeddings
+from pydantic import BaseModel, ConfigDict, Field, model_validator
+from typing_extensions import Self
+
+
+class LlamaCppEmbeddings(BaseModel, Embeddings):
+    """llama.cpp embedding models.
+
+    To use, you should have the llama-cpp-python library installed, and provide the
+    path to the Llama model as a named parameter to the constructor.
+    Check out: https://github.com/abetlen/llama-cpp-python
+
+    Example:
+        .. code-block:: python
+
+            from langchain_community.embeddings import LlamaCppEmbeddings
+            llama = LlamaCppEmbeddings(model_path="/path/to/model.bin")
+    """
+
+    client: Any = None  #: :meta private:
+    model_path: str = Field(default="")
+
+    n_ctx: int = Field(512, alias="n_ctx")
+    """Token context window."""
+
+    n_parts: int = Field(-1, alias="n_parts")
+    """Number of parts to split the model into. 
+    If -1, the number of parts is automatically determined."""
+
+    seed: int = Field(-1, alias="seed")
+    """Seed. If -1, a random seed is used."""
+
+    f16_kv: bool = Field(False, alias="f16_kv")
+    """Use half-precision for key/value cache."""
+
+    logits_all: bool = Field(False, alias="logits_all")
+    """Return logits for all tokens, not just the last token."""
+
+    vocab_only: bool = Field(False, alias="vocab_only")
+    """Only load the vocabulary, no weights."""
+
+    use_mlock: bool = Field(False, alias="use_mlock")
+    """Force system to keep model in RAM."""
+
+    n_threads: Optional[int] = Field(None, alias="n_threads")
+    """Number of threads to use. If None, the number 
+    of threads is automatically determined."""
+
+    n_batch: Optional[int] = Field(512, alias="n_batch")
+    """Number of tokens to process in parallel.
+    Should be a number between 1 and n_ctx."""
+
+    n_gpu_layers: Optional[int] = Field(None, alias="n_gpu_layers")
+    """Number of layers to be loaded into gpu memory. Default None."""
+
+    verbose: bool = Field(True, alias="verbose")
+    """Print verbose output to stderr."""
+
+    device: Optional[str] = Field(None, alias="device")
+    """Device type to use and pass to the model"""
+
+    model_config = ConfigDict(
+        extra="forbid",
+        protected_namespaces=(),
+    )
+
+    @model_validator(mode="after")
+    def validate_environment(self) -> Self:
+        """Validate that llama-cpp-python library is installed."""
+        model_path = self.model_path
+        model_param_names = [
+            "n_ctx",
+            "n_parts",
+            "seed",
+            "f16_kv",
+            "logits_all",
+            "vocab_only",
+            "use_mlock",
+            "n_threads",
+            "n_batch",
+            "verbose",
+            "device",
+        ]
+        model_params = {k: getattr(self, k) for k in model_param_names}
+        # For backwards compatibility, only include if non-null.
+        if self.n_gpu_layers is not None:
+            model_params["n_gpu_layers"] = self.n_gpu_layers
+
+        if not self.client:
+            try:
+                from llama_cpp import Llama
+
+                self.client = Llama(model_path, embedding=True, **model_params)
+            except ImportError:
+                raise ImportError(
+                    "Could not import llama-cpp-python library. "
+                    "Please install the llama-cpp-python library to "
+                    "use this embedding model: pip install llama-cpp-python"
+                )
+            except Exception as e:
+                raise ValueError(
+                    f"Could not load Llama model from path: {model_path}. "
+                    f"Received error {e}"
+                )
+
+        return self
+
+    def embed_documents(self, texts: List[str]) -> List[List[float]]:
+        """Embed a list of documents using the Llama model.
+
+        Args:
+            texts: The list of texts to embed.
+
+        Returns:
+            List of embeddings, one for each text.
+        """
+        embeddings = self.client.create_embedding(texts)
+        final_embeddings = []
+        for e in embeddings["data"]:
+            try:
+                if isinstance(e["embedding"][0], list):
+                    for data in e["embedding"]:
+                        final_embeddings.append(list(map(float, data)))
+                else:
+                    final_embeddings.append(list(map(float, e["embedding"])))
+            except (IndexError, TypeError):
+                final_embeddings.append(list(map(float, e["embedding"])))
+        return final_embeddings
+
+    def embed_query(self, text: str) -> List[float]:
+        """Embed a query using the Llama model.
+
+        Args:
+            text: The text to embed.
+
+        Returns:
+            Embeddings for the text.
+        """
+        embedding = self.client.embed(text)
+        if embedding and isinstance(embedding, list) and isinstance(embedding[0], list):
+            return list(map(float, embedding[0]))
+        else:
+            return list(map(float, embedding))

python/user_packages/Python313/site-packages/langchain_community/embeddings/llamafile.py

@@ -0,0 +1,119 @@
+import logging
+from typing import List, Optional
+
+import requests
+from langchain_core.embeddings import Embeddings
+from pydantic import BaseModel
+
+logger = logging.getLogger(__name__)
+
+
+class LlamafileEmbeddings(BaseModel, Embeddings):
+    """Llamafile lets you distribute and run large language models with a
+    single file.
+
+    To get started, see: https://github.com/Mozilla-Ocho/llamafile
+
+    To use this class, you will need to first:
+
+    1. Download a llamafile.
+    2. Make the downloaded file executable: `chmod +x path/to/model.llamafile`
+    3. Start the llamafile in server mode with embeddings enabled:
+
+        `./path/to/model.llamafile --server --nobrowser --embedding`
+
+    Example:
+        .. code-block:: python
+
+            from langchain_community.embeddings import LlamafileEmbeddings
+            embedder = LlamafileEmbeddings()
+            doc_embeddings = embedder.embed_documents(
+                [
+                    "Alpha is the first letter of the Greek alphabet",
+                    "Beta is the second letter of the Greek alphabet",
+                ]
+            )
+            query_embedding = embedder.embed_query(
+                "What is the second letter of the Greek alphabet"
+            )
+
+    """
+
+    base_url: str = "http://localhost:8080"
+    """Base url where the llamafile server is listening."""
+
+    request_timeout: Optional[int] = None
+    """Timeout for server requests"""
+
+    def _embed(self, text: str) -> List[float]:
+        try:
+            response = requests.post(
+                url=f"{self.base_url}/embedding",
+                headers={
+                    "Content-Type": "application/json",
+                },
+                json={
+                    "content": text,
+                },
+                timeout=self.request_timeout,
+            )
+        except requests.exceptions.ConnectionError:
+            raise requests.exceptions.ConnectionError(
+                f"Could not connect to Llamafile server. Please make sure "
+                f"that a server is running at {self.base_url}."
+            )
+
+        # Raise exception if we got a bad (non-200) response status code
+        response.raise_for_status()
+
+        contents = response.json()
+        if "embedding" not in contents:
+            raise KeyError(
+                "Unexpected output from /embedding endpoint, output dict "
+                "missing 'embedding' key."
+            )
+
+        embedding = contents["embedding"]
+
+        # Sanity check the embedding vector:
+        # Prior to llamafile v0.6.2, if the server was not started with the
+        # `--embedding` option, the embedding endpoint would always return a
+        # 0-vector. See issue:
+        # https://github.com/Mozilla-Ocho/llamafile/issues/243
+        # So here we raise an exception if the vector sums to exactly 0.
+        if sum(embedding) == 0.0:
+            raise ValueError(
+                "Embedding sums to 0, did you start the llamafile server with "
+                "the `--embedding` option enabled?"
+            )
+
+        return embedding
+
+    def embed_documents(self, texts: List[str]) -> List[List[float]]:
+        """Embed documents using a llamafile server running at `self.base_url`.
+        llamafile server should be started in a separate process before invoking
+        this method.
+
+        Args:
+            texts: The list of texts to embed.
+
+        Returns:
+            List of embeddings, one for each text.
+        """
+        doc_embeddings = []
+        for text in texts:
+            doc_embeddings.append(self._embed(text))
+        return doc_embeddings
+
+    def embed_query(self, text: str) -> List[float]:
+        """Embed a query using a llamafile server running at `self.base_url`.
+        llamafile server should be started in a separate process before invoking
+        this method.
+
+        Args:
+            text: The text to embed.
+
+        Returns:
+            Embeddings for the text.
+        """
+        return self._embed(text)

python/user_packages/Python313/site-packages/langchain_community/embeddings/llm_rails.py

@@ -0,0 +1,74 @@
+"""This file is for LLMRails Embedding"""
+
+from typing import Dict, List, Optional
+
+import requests
+from langchain_core.embeddings import Embeddings
+from langchain_core.utils import convert_to_secret_str, get_from_dict_or_env, pre_init
+from pydantic import BaseModel, ConfigDict, SecretStr
+
+
+class LLMRailsEmbeddings(BaseModel, Embeddings):
+    """LLMRails embedding models.
+
+    To use, you should have the  environment
+    variable ``LLM_RAILS_API_KEY`` set with your API key or pass it
+    as a named parameter to the constructor.
+
+    Model can be one of ["embedding-english-v1","embedding-multi-v1"]
+
+    Example:
+        .. code-block:: python
+
+            from langchain_community.embeddings import LLMRailsEmbeddings
+            cohere = LLMRailsEmbeddings(
+                model="embedding-english-v1", api_key="my-api-key"
+            )
+    """
+
+    model: str = "embedding-english-v1"
+    """Model name to use."""
+
+    api_key: Optional[SecretStr] = None
+    """LLMRails API key."""
+
+    model_config = ConfigDict(
+        extra="forbid",
+    )
+
+    @pre_init
+    def validate_environment(cls, values: Dict) -> Dict:
+        """Validate that api key exists in environment."""
+        api_key = convert_to_secret_str(
+            get_from_dict_or_env(values, "api_key", "LLM_RAILS_API_KEY")
+        )
+        values["api_key"] = api_key
+        return values
+
+    def embed_documents(self, texts: List[str]) -> List[List[float]]:
+        """Call out to Cohere's embedding endpoint.
+
+        Args:
+            texts: The list of texts to embed.
+
+        Returns:
+            List of embeddings, one for each text.
+        """
+        response = requests.post(
+            "https://api.llmrails.com/v1/embeddings",
+            headers={"X-API-KEY": self.api_key.get_secret_value()},  # type: ignore[union-attr]
+            json={"input": texts, "model": self.model},
+            timeout=60,
+        )
+        return [item["embedding"] for item in response.json()["data"]]
+
+    def embed_query(self, text: str) -> List[float]:
+        """Call out to Cohere's embedding endpoint.
+
+        Args:
+            text: The text to embed.
+
+        Returns:
+            Embeddings for the text.
+        """
+        return self.embed_documents([text])[0]

python/user_packages/Python313/site-packages/langchain_community/embeddings/localai.py

@@ -0,0 +1,347 @@
+from __future__ import annotations
+
+import logging
+import warnings
+from typing import (
+    Any,
+    Callable,
+    Dict,
+    List,
+    Literal,
+    Optional,
+    Sequence,
+    Set,
+    Tuple,
+    Union,
+)
+
+from langchain_core.embeddings import Embeddings
+from langchain_core.utils import (
+    get_from_dict_or_env,
+    get_pydantic_field_names,
+    pre_init,
+)
+from pydantic import BaseModel, ConfigDict, Field, model_validator
+from tenacity import (
+    AsyncRetrying,
+    before_sleep_log,
+    retry,
+    retry_if_exception_type,
+    stop_after_attempt,
+    wait_exponential,
+)
+
+logger = logging.getLogger(__name__)
+
+
+def _create_retry_decorator(embeddings: LocalAIEmbeddings) -> Callable[[Any], Any]:
+    import openai
+
+    min_seconds = 4
+    max_seconds = 10
+    # Wait 2^x * 1 second between each retry starting with
+    # 4 seconds, then up to 10 seconds, then 10 seconds afterwards
+    return retry(
+        reraise=True,
+        stop=stop_after_attempt(embeddings.max_retries),
+        wait=wait_exponential(multiplier=1, min=min_seconds, max=max_seconds),
+        retry=(
+            retry_if_exception_type(openai.error.Timeout)
+            | retry_if_exception_type(openai.error.APIError)
+            | retry_if_exception_type(openai.error.APIConnectionError)
+            | retry_if_exception_type(openai.error.RateLimitError)
+            | retry_if_exception_type(openai.error.ServiceUnavailableError)
+        ),
+        before_sleep=before_sleep_log(logger, logging.WARNING),
+    )
+
+
+def _async_retry_decorator(embeddings: LocalAIEmbeddings) -> Any:
+    import openai
+
+    min_seconds = 4
+    max_seconds = 10
+    # Wait 2^x * 1 second between each retry starting with
+    # 4 seconds, then up to 10 seconds, then 10 seconds afterwards
+    async_retrying = AsyncRetrying(
+        reraise=True,
+        stop=stop_after_attempt(embeddings.max_retries),
+        wait=wait_exponential(multiplier=1, min=min_seconds, max=max_seconds),
+        retry=(
+            retry_if_exception_type(openai.error.Timeout)
+            | retry_if_exception_type(openai.error.APIError)
+            | retry_if_exception_type(openai.error.APIConnectionError)
+            | retry_if_exception_type(openai.error.RateLimitError)
+            | retry_if_exception_type(openai.error.ServiceUnavailableError)
+        ),
+        before_sleep=before_sleep_log(logger, logging.WARNING),
+    )
+
+    def wrap(func: Callable) -> Callable:
+        async def wrapped_f(*args: Any, **kwargs: Any) -> Callable:
+            async for _ in async_retrying:
+                return await func(*args, **kwargs)
+            raise AssertionError("this is unreachable")
+
+        return wrapped_f
+
+    return wrap
+
+
+# https://stackoverflow.com/questions/76469415/getting-embeddings-of-length-1-from-langchain-openaiembeddings
+def _check_response(response: dict) -> dict:
+    if any(len(d["embedding"]) == 1 for d in response["data"]):
+        import openai
+
+        raise openai.error.APIError("LocalAI API returned an empty embedding")
+    return response
+
+
+def embed_with_retry(embeddings: LocalAIEmbeddings, **kwargs: Any) -> Any:
+    """Use tenacity to retry the embedding call."""
+    retry_decorator = _create_retry_decorator(embeddings)
+
+    @retry_decorator
+    def _embed_with_retry(**kwargs: Any) -> Any:
+        response = embeddings.client.create(**kwargs)
+        return _check_response(response)
+
+    return _embed_with_retry(**kwargs)
+
+
+async def async_embed_with_retry(embeddings: LocalAIEmbeddings, **kwargs: Any) -> Any:
+    """Use tenacity to retry the embedding call."""
+
+    @_async_retry_decorator(embeddings)
+    async def _async_embed_with_retry(**kwargs: Any) -> Any:
+        response = await embeddings.client.acreate(**kwargs)
+        return _check_response(response)
+
+    return await _async_embed_with_retry(**kwargs)
+
+
+class LocalAIEmbeddings(BaseModel, Embeddings):
+    """LocalAI embedding models.
+
+    Since LocalAI and OpenAI have 1:1 compatibility between APIs, this class
+    uses the ``openai`` Python package's ``openai.Embedding`` as its client.
+    Thus, you should have the ``openai`` python package installed, and defeat
+    the environment variable ``OPENAI_API_KEY`` by setting to a random string.
+    You also need to specify ``OPENAI_API_BASE`` to point to your LocalAI
+    service endpoint.
+
+    Example:
+        .. code-block:: python
+
+            from langchain_community.embeddings import LocalAIEmbeddings
+            openai = LocalAIEmbeddings(
+                openai_api_key="random-string",
+                openai_api_base="http://localhost:8080"
+            )
+
+    """
+
+    client: Any = None  #: :meta private:
+    model: str = "text-embedding-ada-002"
+    deployment: str = model
+    openai_api_version: Optional[str] = None
+    openai_api_base: Optional[str] = None
+    # to support explicit proxy for LocalAI
+    openai_proxy: Optional[str] = None
+    embedding_ctx_length: int = 8191
+    """The maximum number of tokens to embed at once."""
+    openai_api_key: Optional[str] = None
+    openai_organization: Optional[str] = None
+    allowed_special: Union[Literal["all"], Set[str]] = set()
+    disallowed_special: Union[Literal["all"], Set[str], Sequence[str]] = "all"
+    chunk_size: int = 1000
+    """Maximum number of texts to embed in each batch"""
+    max_retries: int = 6
+    """Maximum number of retries to make when generating."""
+    request_timeout: Optional[Union[float, Tuple[float, float]]] = None
+    """Timeout in seconds for the LocalAI request."""
+    headers: Any = None
+    show_progress_bar: bool = False
+    """Whether to show a progress bar when embedding."""
+    model_kwargs: Dict[str, Any] = Field(default_factory=dict)
+    """Holds any model parameters valid for `create` call not explicitly specified."""
+
+    model_config = ConfigDict(extra="forbid", protected_namespaces=())
+
+    @model_validator(mode="before")
+    @classmethod
+    def build_extra(cls, values: Dict[str, Any]) -> Any:
+        """Build extra kwargs from additional params that were passed in."""
+        all_required_field_names = get_pydantic_field_names(cls)
+        extra = values.get("model_kwargs", {})
+        for field_name in list(values):
+            if field_name in extra:
+                raise ValueError(f"Found {field_name} supplied twice.")
+            if field_name not in all_required_field_names:
+                warnings.warn(
+                    f"""WARNING! {field_name} is not default parameter.
+                    {field_name} was transferred to model_kwargs.
+                    Please confirm that {field_name} is what you intended."""
+                )
+                extra[field_name] = values.pop(field_name)
+
+        invalid_model_kwargs = all_required_field_names.intersection(extra.keys())
+        if invalid_model_kwargs:
+            raise ValueError(
+                f"Parameters {invalid_model_kwargs} should be specified explicitly. "
+                f"Instead they were passed in as part of `model_kwargs` parameter."
+            )
+
+        values["model_kwargs"] = extra
+        return values
+
+    @pre_init
+    def validate_environment(cls, values: Dict) -> Dict:
+        """Validate that api key and python package exists in environment."""
+        values["openai_api_key"] = get_from_dict_or_env(
+            values, "openai_api_key", "OPENAI_API_KEY"
+        )
+        values["openai_api_base"] = get_from_dict_or_env(
+            values,
+            "openai_api_base",
+            "OPENAI_API_BASE",
+            default="",
+        )
+        values["openai_proxy"] = get_from_dict_or_env(
+            values,
+            "openai_proxy",
+            "OPENAI_PROXY",
+            default="",
+        )
+
+        default_api_version = ""
+        values["openai_api_version"] = get_from_dict_or_env(
+            values,
+            "openai_api_version",
+            "OPENAI_API_VERSION",
+            default=default_api_version,
+        )
+        values["openai_organization"] = get_from_dict_or_env(
+            values,
+            "openai_organization",
+            "OPENAI_ORGANIZATION",
+            default="",
+        )
+        try:
+            import openai
+
+            values["client"] = openai.Embedding
+        except ImportError:
+            raise ImportError(
+                "Could not import openai python package. "
+                "Please install it with `pip install openai`."
+            )
+        return values
+
+    @property
+    def _invocation_params(self) -> Dict:
+        openai_args = {
+            "model": self.model,
+            "request_timeout": self.request_timeout,
+            "headers": self.headers,
+            "api_key": self.openai_api_key,
+            "organization": self.openai_organization,
+            "api_base": self.openai_api_base,
+            "api_version": self.openai_api_version,
+            **self.model_kwargs,
+        }
+        if self.openai_proxy:
+            import openai
+
+            openai.proxy = {
+                "http": self.openai_proxy,
+                "https": self.openai_proxy,
+            }
+        return openai_args
+
+    def _embedding_func(self, text: str, *, engine: str) -> List[float]:
+        """Call out to LocalAI's embedding endpoint."""
+        # handle large input text
+        if self.model.endswith("001"):
+            # See: https://github.com/openai/openai-python/issues/418#issuecomment-1525939500
+            # replace newlines, which can negatively affect performance.
+            text = text.replace("\n", " ")
+        return embed_with_retry(
+            self,
+            input=[text],
+            **self._invocation_params,
+        )["data"][0]["embedding"]
+
+    async def _aembedding_func(self, text: str, *, engine: str) -> List[float]:
+        """Call out to LocalAI's embedding endpoint."""
+        # handle large input text
+        if self.model.endswith("001"):
+            # See: https://github.com/openai/openai-python/issues/418#issuecomment-1525939500
+            # replace newlines, which can negatively affect performance.
+            text = text.replace("\n", " ")
+        return (
+            await async_embed_with_retry(
+                self,
+                input=[text],
+                **self._invocation_params,
+            )
+        )["data"][0]["embedding"]
+
+    def embed_documents(
+        self, texts: List[str], chunk_size: Optional[int] = 0
+    ) -> List[List[float]]:
+        """Call out to LocalAI's embedding endpoint for embedding search docs.
+
+        Args:
+            texts: The list of texts to embed.
+            chunk_size: The chunk size of embeddings. If None, will use the chunk size
+                specified by the class.
+
+        Returns:
+            List of embeddings, one for each text.
+        """
+        # call _embedding_func for each text
+        return [self._embedding_func(text, engine=self.deployment) for text in texts]
+
+    async def aembed_documents(
+        self, texts: List[str], chunk_size: Optional[int] = 0
+    ) -> List[List[float]]:
+        """Call out to LocalAI's embedding endpoint async for embedding search docs.
+
+        Args:
+            texts: The list of texts to embed.
+            chunk_size: The chunk size of embeddings. If None, will use the chunk size
+                specified by the class.
+
+        Returns:
+            List of embeddings, one for each text.
+        """
+        embeddings = []
+        for text in texts:
+            response = await self._aembedding_func(text, engine=self.deployment)
+            embeddings.append(response)
+        return embeddings
+
+    def embed_query(self, text: str) -> List[float]:
+        """Call out to LocalAI's embedding endpoint for embedding query text.
+
+        Args:
+            text: The text to embed.
+
+        Returns:
+            Embedding for the text.
+        """
+        embedding = self._embedding_func(text, engine=self.deployment)
+        return embedding
+
+    async def aembed_query(self, text: str) -> List[float]:
+        """Call out to LocalAI's embedding endpoint async for embedding query text.
+
+        Args:
+            text: The text to embed.
+
+        Returns:
+            Embedding for the text.
+        """
+        embedding = await self._aembedding_func(text, engine=self.deployment)
+        return embedding

python/user_packages/Python313/site-packages/langchain_community/embeddings/minimax.py

@@ -0,0 +1,201 @@
+from __future__ import annotations
+
+import logging
+from typing import Any, Callable, Dict, List, Optional
+
+import requests
+from langchain_core.embeddings import Embeddings
+from langchain_core.utils import convert_to_secret_str, get_from_dict_or_env, pre_init
+from pydantic import BaseModel, ConfigDict, Field, SecretStr
+from tenacity import (
+    before_sleep_log,
+    retry,
+    stop_after_attempt,
+    wait_exponential,
+)
+
+logger = logging.getLogger(__name__)
+
+
+def _create_retry_decorator() -> Callable[[Any], Any]:
+    """Returns a tenacity retry decorator."""
+
+    multiplier = 1
+    min_seconds = 1
+    max_seconds = 4
+    max_retries = 6
+
+    return retry(
+        reraise=True,
+        stop=stop_after_attempt(max_retries),
+        wait=wait_exponential(multiplier=multiplier, min=min_seconds, max=max_seconds),
+        before_sleep=before_sleep_log(logger, logging.WARNING),
+    )
+
+
+def embed_with_retry(embeddings: MiniMaxEmbeddings, *args: Any, **kwargs: Any) -> Any:
+    """Use tenacity to retry the completion call."""
+    retry_decorator = _create_retry_decorator()
+
+    @retry_decorator
+    def _embed_with_retry(*args: Any, **kwargs: Any) -> Any:
+        return embeddings.embed(*args, **kwargs)
+
+    return _embed_with_retry(*args, **kwargs)
+
+
+class MiniMaxEmbeddings(BaseModel, Embeddings):
+    """MiniMax embedding model integration.
+
+    Setup:
+        To use, you should have the environment variable ``MINIMAX_GROUP_ID`` and
+        ``MINIMAX_API_KEY`` set with your API token.
+
+        .. code-block:: bash
+
+            export MINIMAX_API_KEY="your-api-key"
+            export MINIMAX_GROUP_ID="your-group-id"
+
+    Key init args — completion params:
+        model: Optional[str]
+            Name of ZhipuAI model to use.
+        api_key: Optional[str]
+            Automatically inferred from env var `MINIMAX_GROUP_ID` if not provided.
+        group_id: Optional[str]
+            Automatically inferred from env var `MINIMAX_GROUP_ID` if not provided.
+
+    See full list of supported init args and their descriptions in the params section.
+
+    Instantiate:
+
+        .. code-block:: python
+
+            from langchain_community.embeddings import MiniMaxEmbeddings
+
+            embed = MiniMaxEmbeddings(
+                model="embo-01",
+                # api_key="...",
+                # group_id="...",
+                # other
+            )
+
+    Embed single text:
+        .. code-block:: python
+
+            input_text = "The meaning of life is 42"
+            embed.embed_query(input_text)
+
+        .. code-block:: python
+
+            [0.03016241, 0.03617699, 0.0017198119, -0.002061239, -0.00029994643, -0.0061320597, -0.0043635326, ...]
+
+    Embed multiple text:
+        .. code-block:: python
+
+            input_texts = ["This is a test query1.", "This is a test query2."]
+            embed.embed_documents(input_texts)
+
+        .. code-block:: python
+
+            [
+                [-0.0021588828, -0.007608119, 0.029349545, -0.0038194496, 0.008031177, -0.004529633, -0.020150753, ...],
+                [ -0.00023150232, -0.011122423, 0.016930554, 0.0083089275, 0.012633711, 0.019683322, -0.005971041, ...]
+            ]
+    """  # noqa: E501
+
+    endpoint_url: str = "https://api.minimax.chat/v1/embeddings"
+    """Endpoint URL to use."""
+    model: str = "embo-01"
+    """Embeddings model name to use."""
+    embed_type_db: str = "db"
+    """For embed_documents"""
+    embed_type_query: str = "query"
+    """For embed_query"""
+
+    minimax_group_id: Optional[str] = Field(default=None, alias="group_id")
+    """Group ID for MiniMax API."""
+    minimax_api_key: Optional[SecretStr] = Field(default=None, alias="api_key")
+    """API Key for MiniMax API."""
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        extra="forbid",
+    )
+
+    @pre_init
+    def validate_environment(cls, values: Dict) -> Dict:
+        """Validate that group id and api key exists in environment."""
+        minimax_group_id = get_from_dict_or_env(
+            values, ["minimax_group_id", "group_id"], "MINIMAX_GROUP_ID"
+        )
+        minimax_api_key = convert_to_secret_str(
+            get_from_dict_or_env(
+                values, ["minimax_api_key", "api_key"], "MINIMAX_API_KEY"
+            )
+        )
+        values["minimax_group_id"] = minimax_group_id
+        values["minimax_api_key"] = minimax_api_key
+        return values
+
+    def embed(
+        self,
+        texts: List[str],
+        embed_type: str,
+    ) -> List[List[float]]:
+        payload = {
+            "model": self.model,
+            "type": embed_type,
+            "texts": texts,
+        }
+
+        # HTTP headers for authorization
+        headers = {
+            "Authorization": f"Bearer {self.minimax_api_key.get_secret_value()}",  # type: ignore[union-attr]
+            "Content-Type": "application/json",
+        }
+
+        params = {
+            "GroupId": self.minimax_group_id,
+        }
+
+        # send request
+        response = requests.post(
+            self.endpoint_url, params=params, headers=headers, json=payload
+        )
+        parsed_response = response.json()
+
+        # check for errors
+        if parsed_response["base_resp"]["status_code"] != 0:
+            raise ValueError(
+                f"MiniMax API returned an error: {parsed_response['base_resp']}"
+            )
+
+        embeddings = parsed_response["vectors"]
+
+        return embeddings
+
+    def embed_documents(self, texts: List[str]) -> List[List[float]]:
+        """Embed documents using a MiniMax embedding endpoint.
+
+        Args:
+            texts: The list of texts to embed.
+
+        Returns:
+            List of embeddings, one for each text.
+        """
+        embeddings = embed_with_retry(self, texts=texts, embed_type=self.embed_type_db)
+        return embeddings
+
+    def embed_query(self, text: str) -> List[float]:
+        """Embed a query using a MiniMax embedding endpoint.
+
+        Args:
+            text: The text to embed.
+
+        Returns:
+            Embeddings for the text.
+        """
+        embeddings = embed_with_retry(
+            self, texts=[text], embed_type=self.embed_type_query
+        )
+        return embeddings[0]

python/user_packages/Python313/site-packages/langchain_community/embeddings/mlflow.py

@@ -0,0 +1,91 @@
+from __future__ import annotations
+
+from typing import Any, Dict, Iterator, List
+from urllib.parse import urlparse
+
+from langchain_core.embeddings import Embeddings
+from pydantic import BaseModel, PrivateAttr
+
+
+def _chunk(texts: List[str], size: int) -> Iterator[List[str]]:
+    for i in range(0, len(texts), size):
+        yield texts[i : i + size]
+
+
+class MlflowEmbeddings(Embeddings, BaseModel):
+    """Embedding LLMs in MLflow.
+
+    To use, you should have the `mlflow[genai]` python package installed.
+    For more information, see https://mlflow.org/docs/latest/llms/deployments.
+
+    Example:
+        .. code-block:: python
+
+            from langchain_community.embeddings import MlflowEmbeddings
+
+            embeddings = MlflowEmbeddings(
+                target_uri="http://localhost:5000",
+                endpoint="embeddings",
+            )
+    """
+
+    endpoint: str
+    """The endpoint to use."""
+    target_uri: str
+    """The target URI to use."""
+    _client: Any = PrivateAttr()
+    """The parameters to use for queries."""
+    query_params: Dict[str, str] = {}
+    """The parameters to use for documents."""
+    documents_params: Dict[str, str] = {}
+
+    def __init__(self, **kwargs: Any):
+        super().__init__(**kwargs)
+        self._validate_uri()
+        try:
+            from mlflow.deployments import get_deploy_client
+
+            self._client = get_deploy_client(self.target_uri)
+        except ImportError as e:
+            raise ImportError(
+                "Failed to create the client. "
+                f"Please run `pip install mlflow{self._mlflow_extras}` to install "
+                "required dependencies."
+            ) from e
+
+    @property
+    def _mlflow_extras(self) -> str:
+        return "[genai]"
+
+    def _validate_uri(self) -> None:
+        if self.target_uri == "databricks":
+            return
+        allowed = ["http", "https", "databricks"]
+        if urlparse(self.target_uri).scheme not in allowed:
+            raise ValueError(
+                f"Invalid target URI: {self.target_uri}. "
+                f"The scheme must be one of {allowed}."
+            )
+
+    def embed(self, texts: List[str], params: Dict[str, str]) -> List[List[float]]:
+        embeddings: List[List[float]] = []
+        for txt in _chunk(texts, 20):
+            resp = self._client.predict(
+                endpoint=self.endpoint,
+                inputs={"input": txt, **params},
+            )
+            embeddings.extend(r["embedding"] for r in resp["data"])
+        return embeddings
+
+    def embed_documents(self, texts: List[str]) -> List[List[float]]:
+        return self.embed(texts, params=self.documents_params)
+
+    def embed_query(self, text: str) -> List[float]:
+        return self.embed([text], params=self.query_params)[0]
+
+
+class MlflowCohereEmbeddings(MlflowEmbeddings):
+    """Cohere embedding LLMs in MLflow."""
+
+    query_params: Dict[str, str] = {"input_type": "search_query"}
+    documents_params: Dict[str, str] = {"input_type": "search_document"}

python/user_packages/Python313/site-packages/langchain_community/embeddings/mlflow_gateway.py

@@ -0,0 +1,79 @@
+from __future__ import annotations
+
+import warnings
+from typing import Any, Iterator, List, Optional
+
+from langchain_core.embeddings import Embeddings
+from pydantic import BaseModel
+
+
+def _chunk(texts: List[str], size: int) -> Iterator[List[str]]:
+    for i in range(0, len(texts), size):
+        yield texts[i : i + size]
+
+
+class MlflowAIGatewayEmbeddings(Embeddings, BaseModel):
+    """MLflow AI Gateway embeddings.
+
+    To use, you should have the ``mlflow[gateway]`` python package installed.
+    For more information, see https://mlflow.org/docs/latest/gateway/index.html.
+
+    Example:
+        .. code-block:: python
+
+            from langchain_community.embeddings import MlflowAIGatewayEmbeddings
+
+            embeddings = MlflowAIGatewayEmbeddings(
+                gateway_uri="<your-mlflow-ai-gateway-uri>",
+                route="<your-mlflow-ai-gateway-embeddings-route>"
+            )
+    """
+
+    route: str
+    """The route to use for the MLflow AI Gateway API."""
+    gateway_uri: Optional[str] = None
+    """The URI for the MLflow AI Gateway API."""
+
+    def __init__(self, **kwargs: Any):
+        warnings.warn(
+            "`MlflowAIGatewayEmbeddings` is deprecated. Use `MlflowEmbeddings` or "
+            "`DatabricksEmbeddings` instead.",
+            DeprecationWarning,
+        )
+        try:
+            import mlflow.gateway
+        except ImportError as e:
+            raise ImportError(
+                "Could not import `mlflow.gateway` module. "
+                "Please install it with `pip install mlflow[gateway]`."
+            ) from e
+
+        super().__init__(**kwargs)
+        if self.gateway_uri:
+            mlflow.gateway.set_gateway_uri(self.gateway_uri)
+
+    def _query(self, texts: List[str]) -> List[List[float]]:
+        try:
+            import mlflow.gateway
+        except ImportError as e:
+            raise ImportError(
+                "Could not import `mlflow.gateway` module. "
+                "Please install it with `pip install mlflow[gateway]`."
+            ) from e
+
+        embeddings = []
+        for txt in _chunk(texts, 20):
+            resp = mlflow.gateway.query(self.route, data={"text": txt})
+            # response is List[List[float]]
+            if isinstance(resp["embeddings"][0], List):
+                embeddings.extend(resp["embeddings"])
+            # response is List[float]
+            else:
+                embeddings.append(resp["embeddings"])
+        return embeddings
+
+    def embed_documents(self, texts: List[str]) -> List[List[float]]:
+        return self._query(texts)
+
+    def embed_query(self, text: str) -> List[float]:
+        return self._query([text])[0]

python/user_packages/Python313/site-packages/langchain_community/embeddings/model2vec.py

@@ -0,0 +1,66 @@
+"""Wrapper around model2vec embedding models."""
+
+from typing import List
+
+from langchain_core.embeddings import Embeddings
+
+
+class Model2vecEmbeddings(Embeddings):
+    """Model2Vec embedding models.
+
+    Install model2vec first, run 'pip install -U model2vec'.
+    The github repository for model2vec is : https://github.com/MinishLab/model2vec
+
+    Example:
+        .. code-block:: python
+
+            from langchain_community.embeddings import Model2vecEmbeddings
+
+            embedding = Model2vecEmbeddings("minishlab/potion-base-8M")
+            embedding.embed_documents([
+                "It's dangerous to go alone!",
+                "It's a secret to everybody.",
+            ])
+            embedding.embed_query(
+                "Take this with you."
+            )
+    """
+
+    def __init__(self, model: str):
+        """Initialize embeddings.
+
+        Args:
+            model: Model name.
+        """
+        try:
+            from model2vec import StaticModel
+        except ImportError as e:
+            raise ImportError(
+                "Unable to import model2vec, please install with "
+                "`pip install -U model2vec`."
+            ) from e
+        self._model = StaticModel.from_pretrained(model)
+
+    def embed_documents(self, texts: List[str]) -> List[List[float]]:
+        """Embed documents using the model2vec embeddings model.
+
+        Args:
+            texts: The list of texts to embed.
+
+        Returns:
+            List of embeddings, one for each text.
+        """
+
+        return self._model.encode(texts).tolist()
+
+    def embed_query(self, text: str) -> List[float]:
+        """Embed a query using the model2vec embeddings model.
+
+        Args:
+            text: The text to embed.
+
+        Returns:
+            Embeddings for the text.
+        """
+
+        return self._model.encode(text).tolist()

python/user_packages/Python313/site-packages/langchain_community/embeddings/modelscope_hub.py

@@ -0,0 +1,70 @@
+from typing import Any, List, Optional
+
+from langchain_core.embeddings import Embeddings
+from pydantic import BaseModel, ConfigDict
+
+
+class ModelScopeEmbeddings(BaseModel, Embeddings):
+    """ModelScopeHub embedding models.
+
+    To use, you should have the ``modelscope`` python package installed.
+
+    Example:
+        .. code-block:: python
+
+            from langchain_community.embeddings import ModelScopeEmbeddings
+            model_id = "damo/nlp_corom_sentence-embedding_english-base"
+            embed = ModelScopeEmbeddings(model_id=model_id, model_revision="v1.0.0")
+    """
+
+    embed: Any = None
+    model_id: str = "damo/nlp_corom_sentence-embedding_english-base"
+    """Model name to use."""
+    model_revision: Optional[str] = None
+
+    def __init__(self, **kwargs: Any):
+        """Initialize the modelscope"""
+        super().__init__(**kwargs)
+        try:
+            from modelscope.pipelines import pipeline
+            from modelscope.utils.constant import Tasks
+        except ImportError as e:
+            raise ImportError(
+                "Could not import some python packages."
+                "Please install it with `pip install modelscope`."
+            ) from e
+        self.embed = pipeline(
+            Tasks.sentence_embedding,
+            model=self.model_id,
+            model_revision=self.model_revision,
+        )
+
+    model_config = ConfigDict(extra="forbid", protected_namespaces=())
+
+    def embed_documents(self, texts: List[str]) -> List[List[float]]:
+        """Compute doc embeddings using a modelscope embedding model.
+
+        Args:
+            texts: The list of texts to embed.
+
+        Returns:
+            List of embeddings, one for each text.
+        """
+        texts = list(map(lambda x: x.replace("\n", " "), texts))
+        inputs = {"source_sentence": texts}
+        embeddings = self.embed(input=inputs)["text_embedding"]
+        return embeddings.tolist()
+
+    def embed_query(self, text: str) -> List[float]:
+        """Compute query embeddings using a modelscope embedding model.
+
+        Args:
+            text: The text to embed.
+
+        Returns:
+            Embeddings for the text.
+        """
+        text = text.replace("\n", " ")
+        inputs = {"source_sentence": [text]}
+        embedding = self.embed(input=inputs)["text_embedding"][0]
+        return embedding.tolist()

python/user_packages/Python313/site-packages/langchain_community/embeddings/mosaicml.py

@@ -0,0 +1,147 @@
+from typing import Any, Dict, List, Mapping, Optional, Tuple
+
+import requests
+from langchain_core.embeddings import Embeddings
+from langchain_core.utils import get_from_dict_or_env
+from pydantic import BaseModel, ConfigDict, model_validator
+
+
+class MosaicMLInstructorEmbeddings(BaseModel, Embeddings):
+    """MosaicML embedding service.
+
+    To use, you should have the
+    environment variable ``MOSAICML_API_TOKEN`` set with your API token, or pass
+    it as a named parameter to the constructor.
+
+    Example:
+        .. code-block:: python
+
+            from langchain_community.llms import MosaicMLInstructorEmbeddings
+            endpoint_url = (
+                "https://models.hosted-on.mosaicml.hosting/instructor-large/v1/predict"
+            )
+            mosaic_llm = MosaicMLInstructorEmbeddings(
+                endpoint_url=endpoint_url,
+                mosaicml_api_token="my-api-key"
+            )
+    """
+
+    endpoint_url: str = (
+        "https://models.hosted-on.mosaicml.hosting/instructor-xl/v1/predict"
+    )
+    """Endpoint URL to use."""
+    embed_instruction: str = "Represent the document for retrieval: "
+    """Instruction used to embed documents."""
+    query_instruction: str = (
+        "Represent the question for retrieving supporting documents: "
+    )
+    """Instruction used to embed the query."""
+    retry_sleep: float = 1.0
+    """How long to try sleeping for if a rate limit is encountered"""
+
+    mosaicml_api_token: Optional[str] = None
+
+    model_config = ConfigDict(
+        extra="forbid",
+    )
+
+    @model_validator(mode="before")
+    @classmethod
+    def validate_environment(cls, values: Dict) -> Any:
+        """Validate that api key and python package exists in environment."""
+        mosaicml_api_token = get_from_dict_or_env(
+            values, "mosaicml_api_token", "MOSAICML_API_TOKEN"
+        )
+        values["mosaicml_api_token"] = mosaicml_api_token
+        return values
+
+    @property
+    def _identifying_params(self) -> Mapping[str, Any]:
+        """Get the identifying parameters."""
+        return {"endpoint_url": self.endpoint_url}
+
+    def _embed(
+        self, input: List[Tuple[str, str]], is_retry: bool = False
+    ) -> List[List[float]]:
+        payload = {"inputs": input}
+
+        # HTTP headers for authorization
+        headers = {
+            "Authorization": f"{self.mosaicml_api_token}",
+            "Content-Type": "application/json",
+        }
+
+        # send request
+        try:
+            response = requests.post(self.endpoint_url, headers=headers, json=payload)
+        except requests.exceptions.RequestException as e:
+            raise ValueError(f"Error raised by inference endpoint: {e}")
+
+        try:
+            if response.status_code == 429:
+                if not is_retry:
+                    import time
+
+                    time.sleep(self.retry_sleep)
+
+                    return self._embed(input, is_retry=True)
+
+                raise ValueError(
+                    f"Error raised by inference API: rate limit exceeded.\nResponse: "
+                    f"{response.text}"
+                )
+
+            parsed_response = response.json()
+
+            # The inference API has changed a couple of times, so we add some handling
+            # to be robust to multiple response formats.
+            if isinstance(parsed_response, dict):
+                output_keys = ["data", "output", "outputs"]
+                for key in output_keys:
+                    if key in parsed_response:
+                        output_item = parsed_response[key]
+                        break
+                else:
+                    raise ValueError(
+                        f"No key data or output in response: {parsed_response}"
+                    )
+
+                if isinstance(output_item, list) and isinstance(output_item[0], list):
+                    embeddings = output_item
+                else:
+                    embeddings = [output_item]
+            else:
+                raise ValueError(f"Unexpected response type: {parsed_response}")
+
+        except requests.exceptions.JSONDecodeError as e:
+            raise ValueError(
+                f"Error raised by inference API: {e}.\nResponse: {response.text}"
+            )
+
+        return embeddings
+
+    def embed_documents(self, texts: List[str]) -> List[List[float]]:
+        """Embed documents using a MosaicML deployed instructor embedding model.
+
+        Args:
+            texts: The list of texts to embed.
+
+        Returns:
+            List of embeddings, one for each text.
+        """
+        instruction_pairs = [(self.embed_instruction, text) for text in texts]
+        embeddings = self._embed(instruction_pairs)
+        return embeddings
+
+    def embed_query(self, text: str) -> List[float]:
+        """Embed a query using a MosaicML deployed instructor embedding model.
+
+        Args:
+            text: The text to embed.
+
+        Returns:
+            Embeddings for the text.
+        """
+        instruction_pair = (self.query_instruction, text)
+        embedding = self._embed([instruction_pair])[0]
+        return embedding

python/user_packages/Python313/site-packages/langchain_community/embeddings/naver.py

@@ -0,0 +1,236 @@
+import logging
+from typing import Any, Dict, List, Optional, cast
+
+import httpx
+from langchain_core.embeddings import Embeddings
+from langchain_core.utils import convert_to_secret_str, get_from_env
+from pydantic import (
+    AliasChoices,
+    BaseModel,
+    ConfigDict,
+    Field,
+    SecretStr,
+    model_validator,
+)
+from typing_extensions import Self
+
+_DEFAULT_BASE_URL = "https://clovastudio.apigw.ntruss.com"
+_DEFAULT_BASE_URL_ON_NEW_API_KEY = "https://clovastudio.stream.ntruss.com"
+
+logger = logging.getLogger(__name__)
+
+
+def _raise_on_error(response: httpx.Response) -> None:
+    """Raise an error if the response is an error."""
+    if httpx.codes.is_error(response.status_code):
+        error_message = response.read().decode("utf-8")
+        raise httpx.HTTPStatusError(
+            f"Error response {response.status_code} "
+            f"while fetching {response.url}: {error_message}",
+            request=response.request,
+            response=response,
+        )
+
+
+async def _araise_on_error(response: httpx.Response) -> None:
+    """Raise an error if the response is an error."""
+    if httpx.codes.is_error(response.status_code):
+        error_message = (await response.aread()).decode("utf-8")
+        raise httpx.HTTPStatusError(
+            f"Error response {response.status_code} "
+            f"while fetching {response.url}: {error_message}",
+            request=response.request,
+            response=response,
+        )
+
+
+class ClovaXEmbeddings(BaseModel, Embeddings):
+    """`NCP ClovaStudio` Embedding API.
+
+    following environment variables set or passed in constructor in lower case:
+    - ``NCP_CLOVASTUDIO_API_KEY``
+    - ``NCP_APIGW_API_KEY``
+    - ``NCP_CLOVASTUDIO_APP_ID``
+
+    Example:
+        .. code-block:: python
+
+            from langchain_community import ClovaXEmbeddings
+
+            model = ClovaXEmbeddings(model="clir-emb-dolphin")
+            output = embedding.embed_documents(documents)
+    """  # noqa: E501
+
+    client: Optional[httpx.Client] = Field(default=None)  #: :meta private:
+    async_client: Optional[httpx.AsyncClient] = Field(default=None)  #: :meta private:
+
+    ncp_clovastudio_api_key: Optional[SecretStr] = Field(default=None, alias="api_key")
+    """Automatically inferred from env are `NCP_CLOVASTUDIO_API_KEY` if not provided."""
+
+    ncp_apigw_api_key: Optional[SecretStr] = Field(default=None, alias="apigw_api_key")
+    """Automatically inferred from env are `NCP_APIGW_API_KEY` if not provided."""
+
+    base_url: Optional[str] = Field(default=None, alias="base_url")
+    """
+    Automatically inferred from env are  `NCP_CLOVASTUDIO_API_BASE_URL` if not provided.
+    """
+
+    app_id: Optional[str] = Field(default=None)
+    service_app: bool = Field(
+        default=False,
+        description="false: use testapp, true: use service app on NCP Clova Studio",
+    )
+    model_name: str = Field(
+        default="clir-emb-dolphin",
+        validation_alias=AliasChoices("model_name", "model"),
+        description="NCP ClovaStudio embedding model name",
+    )
+
+    timeout: int = Field(gt=0, default=60)
+
+    model_config = ConfigDict(arbitrary_types_allowed=True, protected_namespaces=())
+
+    @property
+    def lc_secrets(self) -> Dict[str, str]:
+        if not self._is_new_api_key():
+            return {
+                "ncp_clovastudio_api_key": "NCP_CLOVASTUDIO_API_KEY",
+            }
+        else:
+            return {
+                "ncp_clovastudio_api_key": "NCP_CLOVASTUDIO_API_KEY",
+                "ncp_apigw_api_key": "NCP_APIGW_API_KEY",
+            }
+
+    @property
+    def _api_url(self) -> str:
+        """GET embedding api url"""
+        app_type = "serviceapp" if self.service_app else "testapp"
+        model_name = self.model_name if self.model_name != "bge-m3" else "v2"
+        if self._is_new_api_key():
+            return f"{self.base_url}/{app_type}/v1/api-tools/embedding/{model_name}"
+        else:
+            return (
+                f"{self.base_url}/{app_type}"
+                f"/v1/api-tools/embedding/{model_name}/{self.app_id}"
+            )
+
+    @model_validator(mode="after")
+    def validate_model_after(self) -> Self:
+        if not self.ncp_clovastudio_api_key:
+            self.ncp_clovastudio_api_key = convert_to_secret_str(
+                get_from_env("ncp_clovastudio_api_key", "NCP_CLOVASTUDIO_API_KEY")
+            )
+
+        if self._is_new_api_key():
+            self._init_fields_on_new_api_key()
+        else:
+            self._init_fields_on_old_api_key()
+
+        if not self.base_url:
+            raise ValueError("base_url dose not exist.")
+
+        if not self.client:
+            self.client = httpx.Client(
+                base_url=self.base_url,
+                headers=self.default_headers(),
+                timeout=self.timeout,
+            )
+
+        if not self.async_client and self.base_url:
+            self.async_client = httpx.AsyncClient(
+                base_url=self.base_url,
+                headers=self.default_headers(),
+                timeout=self.timeout,
+            )
+
+        return self
+
+    def _is_new_api_key(self) -> bool:
+        if self.ncp_clovastudio_api_key:
+            return self.ncp_clovastudio_api_key.get_secret_value().startswith("nv-")
+        else:
+            return False
+
+    def _init_fields_on_new_api_key(self) -> None:
+        if not self.base_url:
+            self.base_url = get_from_env(
+                "base_url",
+                "NCP_CLOVASTUDIO_API_BASE_URL",
+                _DEFAULT_BASE_URL_ON_NEW_API_KEY,
+            )
+
+    def _init_fields_on_old_api_key(self) -> None:
+        if not self.ncp_apigw_api_key:
+            self.ncp_apigw_api_key = convert_to_secret_str(
+                get_from_env("ncp_apigw_api_key", "NCP_APIGW_API_KEY", "")
+            )
+        if not self.base_url:
+            self.base_url = get_from_env(
+                "base_url", "NCP_CLOVASTUDIO_API_BASE_URL", _DEFAULT_BASE_URL
+            )
+        if not self.app_id:
+            self.app_id = get_from_env("app_id", "NCP_CLOVASTUDIO_APP_ID")
+
+    def default_headers(self) -> Dict[str, Any]:
+        headers = {
+            "Content-Type": "application/json",
+            "Accept": "application/json",
+        }
+
+        clovastudio_api_key = (
+            self.ncp_clovastudio_api_key.get_secret_value()
+            if self.ncp_clovastudio_api_key
+            else None
+        )
+
+        if self._is_new_api_key():
+            ### headers on new api key
+            headers["Authorization"] = f"Bearer {clovastudio_api_key}"
+        else:
+            ### headers on old api key
+            if clovastudio_api_key:
+                headers["X-NCP-CLOVASTUDIO-API-KEY"] = clovastudio_api_key
+
+            apigw_api_key = (
+                self.ncp_apigw_api_key.get_secret_value()
+                if self.ncp_apigw_api_key
+                else None
+            )
+            if apigw_api_key:
+                headers["X-NCP-APIGW-API-KEY"] = apigw_api_key
+
+        return headers
+
+    def _embed_text(self, text: str) -> List[float]:
+        payload = {"text": text}
+        client = cast(httpx.Client, self.client)
+        response = client.post(url=self._api_url, json=payload)
+        _raise_on_error(response)
+        return response.json()["result"]["embedding"]
+
+    async def _aembed_text(self, text: str) -> List[float]:
+        payload = {"text": text}
+        async_client = cast(httpx.AsyncClient, self.async_client)
+        response = await async_client.post(url=self._api_url, json=payload)
+        await _araise_on_error(response)
+        return response.json()["result"]["embedding"]
+
+    def embed_documents(self, texts: List[str]) -> List[List[float]]:
+        embeddings = []
+        for text in texts:
+            embeddings.append(self._embed_text(text))
+        return embeddings
+
+    def embed_query(self, text: str) -> List[float]:
+        return self._embed_text(text)
+
+    async def aembed_documents(self, texts: List[str]) -> List[List[float]]:
+        embeddings = []
+        for text in texts:
+            embedding = await self._aembed_text(text)
+            embeddings.append(embedding)
+        return embeddings
+
+    async def aembed_query(self, text: str) -> List[float]:
+        return await self._aembed_text(text)

python/user_packages/Python313/site-packages/langchain_community/embeddings/nemo.py

@@ -0,0 +1,190 @@
+from __future__ import annotations
+
+import asyncio
+import json
+from typing import Any, Dict, List, Optional
+
+import aiohttp
+import requests
+from langchain_core._api.deprecation import deprecated
+from langchain_core.embeddings import Embeddings
+from langchain_core.utils import pre_init
+from pydantic import BaseModel
+
+
+def is_endpoint_live(url: str, headers: Optional[dict], payload: Any) -> bool:
+    """
+    Check if an endpoint is live by sending a GET request to the specified URL.
+
+    Args:
+        url (str): The URL of the endpoint to check.
+
+    Returns:
+        bool: True if the endpoint is live (status code 200), False otherwise.
+
+    Raises:
+        Exception: If the endpoint returns a non-successful status code or if there is
+            an error querying the endpoint.
+    """
+    try:
+        response = requests.request("POST", url, headers=headers, data=payload)
+
+        # Check if the status code is 200 (OK)
+        if response.status_code == 200:
+            return True
+        else:
+            # Raise an exception if the status code is not 200
+            raise Exception(
+                f"Endpoint returned a non-successful status code: "
+                f"{response.status_code}"
+            )
+    except requests.exceptions.RequestException as e:
+        # Handle any exceptions (e.g., connection errors)
+        raise Exception(f"Error querying the endpoint: {e}")
+
+
+@deprecated(
+    since="0.0.37",
+    removal="1.0.0",
+    message=(
+        "Directly instantiating a NeMoEmbeddings from langchain-community is "
+        "deprecated. Please use langchain-nvidia-ai-endpoints NVIDIAEmbeddings "
+        "interface."
+    ),
+)
+class NeMoEmbeddings(BaseModel, Embeddings):
+    """NeMo embedding models."""
+
+    batch_size: int = 16
+    model: str = "NV-Embed-QA-003"
+    api_endpoint_url: str = "http://localhost:8088/v1/embeddings"
+
+    @pre_init
+    def validate_environment(cls, values: Dict) -> Dict:
+        """Validate that the end point is alive using the values that are provided."""
+
+        url = values["api_endpoint_url"]
+        model = values["model"]
+
+        # Optional: A minimal test payload and headers required by the endpoint
+        headers = {"Content-Type": "application/json"}
+        payload = json.dumps(
+            {
+                "input": "Hello World",
+                "model": model,
+                "input_type": "query",
+            }
+        )
+
+        is_endpoint_live(url, headers, payload)
+
+        return values
+
+    async def _aembedding_func(
+        self, session: Any, text: str, input_type: str
+    ) -> List[float]:
+        """Async call out to embedding endpoint.
+
+        Args:
+            text: The text to embed.
+
+        Returns:
+            Embeddings for the text.
+        """
+
+        headers = {"Content-Type": "application/json"}
+
+        async with session.post(
+            self.api_endpoint_url,
+            json={"input": text, "model": self.model, "input_type": input_type},
+            headers=headers,
+        ) as response:
+            response.raise_for_status()
+            answer = await response.text()
+            answer = json.loads(answer)
+            return answer["data"][0]["embedding"]
+
+    def _embedding_func(self, text: str, input_type: str) -> List[float]:
+        """Call out to Cohere's embedding endpoint.
+
+        Args:
+            text: The text to embed.
+
+        Returns:
+            Embeddings for the text.
+        """
+
+        payload = json.dumps(
+            {
+                "input": text,
+                "model": self.model,
+                "input_type": input_type,
+            }
+        )
+        headers = {"Content-Type": "application/json"}
+
+        response = requests.request(
+            "POST", self.api_endpoint_url, headers=headers, data=payload
+        )
+        response_json = json.loads(response.text)
+        embedding = response_json["data"][0]["embedding"]
+
+        return embedding
+
+    def embed_documents(self, documents: List[str]) -> List[List[float]]:
+        """Embed a list of document texts.
+
+        Args:
+            texts: The list of texts to embed.
+
+        Returns:
+            List of embeddings, one for each text.
+        """
+        return [self._embedding_func(text, input_type="passage") for text in documents]
+
+    def embed_query(self, text: str) -> List[float]:
+        return self._embedding_func(text, input_type="query")
+
+    async def aembed_query(self, text: str) -> List[float]:
+        """Call out to NeMo's embedding endpoint async for embedding query text.
+
+        Args:
+            text: The text to embed.
+
+        Returns:
+            Embedding for the text.
+        """
+
+        async with aiohttp.ClientSession() as session:
+            embedding = await self._aembedding_func(session, text, "passage")
+            return embedding
+
+    async def aembed_documents(self, texts: List[str]) -> List[List[float]]:
+        """Call out to NeMo's embedding endpoint async for embedding search docs.
+
+        Args:
+            texts: The list of texts to embed.
+
+        Returns:
+            List of embeddings, one for each text.
+        """
+        embeddings = []
+
+        async with aiohttp.ClientSession() as session:
+            for batch in range(0, len(texts), self.batch_size):
+                text_batch = texts[batch : batch + self.batch_size]
+
+                for text in text_batch:
+                    # Create tasks for all texts in the batch
+                    tasks = [
+                        self._aembedding_func(session, text, "passage")
+                        for text in text_batch
+                    ]
+
+                    # Run all tasks concurrently
+                    batch_results = await asyncio.gather(*tasks)
+
+                    # Extend the embeddings list with results from this batch
+                    embeddings.extend(batch_results)
+
+        return embeddings

python/user_packages/Python313/site-packages/langchain_community/embeddings/nlpcloud.py

@@ -0,0 +1,75 @@
+from typing import Any, Dict, List
+
+from langchain_core.embeddings import Embeddings
+from langchain_core.utils import get_from_dict_or_env, pre_init
+from pydantic import BaseModel, ConfigDict
+
+
+class NLPCloudEmbeddings(BaseModel, Embeddings):
+    """NLP Cloud embedding models.
+
+    To use, you should have the nlpcloud python package installed
+
+    Example:
+        .. code-block:: python
+
+            from langchain_community.embeddings import NLPCloudEmbeddings
+
+            embeddings = NLPCloudEmbeddings()
+    """
+
+    model_name: str  # Define model_name as a class attribute
+    gpu: bool  # Define gpu as a class attribute
+    client: Any  #: :meta private:
+
+    model_config = ConfigDict(protected_namespaces=())
+
+    def __init__(
+        self,
+        model_name: str = "paraphrase-multilingual-mpnet-base-v2",
+        gpu: bool = False,
+        **kwargs: Any,
+    ) -> None:
+        super().__init__(model_name=model_name, gpu=gpu, **kwargs)
+
+    @pre_init
+    def validate_environment(cls, values: Dict) -> Dict:
+        """Validate that api key and python package exists in environment."""
+        nlpcloud_api_key = get_from_dict_or_env(
+            values, "nlpcloud_api_key", "NLPCLOUD_API_KEY"
+        )
+        try:
+            import nlpcloud
+
+            values["client"] = nlpcloud.Client(
+                values["model_name"], nlpcloud_api_key, gpu=values["gpu"], lang="en"
+            )
+        except ImportError:
+            raise ImportError(
+                "Could not import nlpcloud python package. "
+                "Please install it with `pip install nlpcloud`."
+            )
+        return values
+
+    def embed_documents(self, texts: List[str]) -> List[List[float]]:
+        """Embed a list of documents using NLP Cloud.
+
+        Args:
+            texts: The list of texts to embed.
+
+        Returns:
+            List of embeddings, one for each text.
+        """
+
+        return self.client.embeddings(texts)["embeddings"]
+
+    def embed_query(self, text: str) -> List[float]:
+        """Embed a query using NLP Cloud.
+
+        Args:
+            text: The text to embed.
+
+        Returns:
+            Embeddings for the text.
+        """
+        return self.client.embeddings([text])["embeddings"][0]

python/user_packages/Python313/site-packages/langchain_community/embeddings/oci_generative_ai.py

@@ -0,0 +1,232 @@
+from enum import Enum
+from typing import TYPE_CHECKING, Any, Dict, Iterator, List, Mapping, Optional
+
+from langchain_core.embeddings import Embeddings
+from langchain_core.utils import pre_init
+from pydantic import BaseModel, ConfigDict
+
+if TYPE_CHECKING:
+    import oci
+
+CUSTOM_ENDPOINT_PREFIX = "ocid1.generativeaiendpoint"
+
+
+class OCIAuthType(Enum):
+    """OCI authentication types as enumerator."""
+
+    API_KEY = 1
+    SECURITY_TOKEN = 2
+    INSTANCE_PRINCIPAL = 3
+    RESOURCE_PRINCIPAL = 4
+
+
+class OCIGenAIEmbeddings(BaseModel, Embeddings):
+    """OCI embedding models.
+
+    To authenticate, the OCI client uses the methods described in
+    https://docs.oracle.com/en-us/iaas/Content/API/Concepts/sdk_authentication_methods.htm
+
+    The authentifcation method is passed through auth_type and should be one of:
+    API_KEY (default), SECURITY_TOKEN, INSTANCE_PRINCIPLE, RESOURCE_PRINCIPLE
+
+    Make sure you have the required policies (profile/roles) to
+    access the OCI Generative AI service. If a specific config profile is used,
+    you must pass the name of the profile (~/.oci/config) through auth_profile.
+    If a specific config file location is used, you must pass
+    the file location where profile name configs present
+    through auth_file_location
+
+    To use, you must provide the compartment id
+    along with the endpoint url, and model id
+    as named parameters to the constructor.
+
+    Example:
+        .. code-block:: python
+
+            from langchain_classic.embeddings import OCIGenAIEmbeddings
+
+            embeddings = OCIGenAIEmbeddings(
+                model_id="MY_EMBEDDING_MODEL",
+                service_endpoint="https://inference.generativeai.us-chicago-1.oci.oraclecloud.com",
+                compartment_id="MY_OCID"
+            )
+    """
+
+    client: Any = None  #: :meta private:
+
+    service_models: Any = None  #: :meta private:
+
+    auth_type: Optional[str] = "API_KEY"
+    """Authentication type, could be 
+
+    API_KEY, 
+    SECURITY_TOKEN, 
+    INSTANCE_PRINCIPLE, 
+    RESOURCE_PRINCIPLE
+    
+    If not specified, API_KEY will be used
+    """
+
+    auth_profile: Optional[str] = "DEFAULT"
+    """The name of the profile in ~/.oci/config
+    If not specified , DEFAULT will be used 
+    """
+
+    auth_file_location: Optional[str] = "~/.oci/config"
+    """Path to the config file.
+    If not specified, ~/.oci/config will be used
+    """
+
+    model_id: Optional[str] = None
+    """Id of the model to call, e.g., cohere.embed-english-light-v2.0"""
+
+    model_kwargs: Optional[Dict] = None
+    """Keyword arguments to pass to the model"""
+
+    service_endpoint: Optional[str] = None
+    """service endpoint url"""
+
+    compartment_id: Optional[str] = None
+    """OCID of compartment"""
+
+    truncate: Optional[str] = "END"
+    """Truncate embeddings that are too long from start or end ("NONE"|"START"|"END")"""
+
+    batch_size: int = 96
+    """Batch size of OCI GenAI embedding requests. OCI GenAI may handle up to 96 texts
+     per request"""
+
+    model_config = ConfigDict(extra="forbid", protected_namespaces=())
+
+    @pre_init
+    def validate_environment(cls, values: Dict) -> Dict:  # pylint: disable=no-self-argument
+        """Validate that OCI config and python package exists in environment."""
+
+        # Skip creating new client if passed in constructor
+        if values["client"] is not None:
+            return values
+
+        try:
+            import oci
+
+            client_kwargs = {
+                "config": {},
+                "signer": None,
+                "service_endpoint": values["service_endpoint"],
+                "retry_strategy": oci.retry.DEFAULT_RETRY_STRATEGY,
+                "timeout": (10, 240),  # default timeout config for OCI Gen AI service
+            }
+
+            if values["auth_type"] == OCIAuthType(1).name:
+                client_kwargs["config"] = oci.config.from_file(
+                    file_location=values["auth_file_location"],
+                    profile_name=values["auth_profile"],
+                )
+                client_kwargs.pop("signer", None)
+            elif values["auth_type"] == OCIAuthType(2).name:
+
+                def make_security_token_signer(
+                    oci_config: dict[str, Any],
+                ) -> "oci.auth.signers.SecurityTokenSigner":
+                    pk = oci.signer.load_private_key_from_file(
+                        oci_config.get("key_file"), None
+                    )
+                    with open(
+                        str(oci_config.get("security_token_file")), encoding="utf-8"
+                    ) as f:
+                        st_string = f.read()
+                    return oci.auth.signers.SecurityTokenSigner(st_string, pk)
+
+                client_kwargs["config"] = oci.config.from_file(
+                    file_location=values["auth_file_location"],
+                    profile_name=values["auth_profile"],
+                )
+                client_kwargs["signer"] = make_security_token_signer(
+                    oci_config=client_kwargs["config"]
+                )
+            elif values["auth_type"] == OCIAuthType(3).name:
+                client_kwargs["signer"] = (
+                    oci.auth.signers.InstancePrincipalsSecurityTokenSigner()
+                )
+            elif values["auth_type"] == OCIAuthType(4).name:
+                client_kwargs["signer"] = (
+                    oci.auth.signers.get_resource_principals_signer()
+                )
+            else:
+                raise ValueError("Please provide valid value to auth_type")
+
+            values["client"] = oci.generative_ai_inference.GenerativeAiInferenceClient(
+                **client_kwargs
+            )
+
+        except ImportError as ex:
+            raise ImportError(
+                "Could not import oci python package. "
+                "Please make sure you have the oci package installed."
+            ) from ex
+        except Exception as e:
+            raise ValueError(
+                """Could not authenticate with OCI client.
+                If INSTANCE_PRINCIPAL or RESOURCE_PRINCIPAL is used,
+                please check the specified
+                auth_profile, auth_file_location and auth_type are valid.""",
+                e,
+            ) from e
+
+        return values
+
+    @property
+    def _identifying_params(self) -> Mapping[str, Any]:
+        """Get the identifying parameters."""
+        _model_kwargs = self.model_kwargs or {}
+        return {
+            **{"model_kwargs": _model_kwargs},
+        }
+
+    def embed_documents(self, texts: List[str]) -> List[List[float]]:
+        """Call out to OCIGenAI's embedding endpoint.
+
+        Args:
+            texts: The list of texts to embed.
+
+        Returns:
+            List of embeddings, one for each text.
+        """
+        from oci.generative_ai_inference import models
+
+        if not self.model_id:
+            raise ValueError("Model ID is required to embed documents")
+
+        if self.model_id.startswith(CUSTOM_ENDPOINT_PREFIX):
+            serving_mode = models.DedicatedServingMode(endpoint_id=self.model_id)
+        else:
+            serving_mode = models.OnDemandServingMode(model_id=self.model_id)
+
+        embeddings = []
+
+        def split_texts() -> Iterator[List[str]]:
+            for i in range(0, len(texts), self.batch_size):
+                yield texts[i : i + self.batch_size]
+
+        for chunk in split_texts():
+            invocation_obj = models.EmbedTextDetails(
+                serving_mode=serving_mode,
+                compartment_id=self.compartment_id,
+                truncate=self.truncate,
+                inputs=chunk,
+            )
+            response = self.client.embed_text(invocation_obj)
+            embeddings.extend(response.data.embeddings)
+
+        return embeddings
+
+    def embed_query(self, text: str) -> List[float]:
+        """Call out to OCIGenAI's embedding endpoint.
+
+        Args:
+            text: The text to embed.
+
+        Returns:
+            Embeddings for the text.
+        """
+        return self.embed_documents([text])[0]

python/user_packages/Python313/site-packages/langchain_community/embeddings/octoai_embeddings.py

@@ -0,0 +1,86 @@
+from typing import Dict, Optional
+
+from langchain_core.utils import convert_to_secret_str, get_from_dict_or_env, pre_init
+from pydantic import Field, SecretStr
+
+from langchain_community.embeddings.openai import OpenAIEmbeddings
+from langchain_community.utils.openai import is_openai_v1
+
+DEFAULT_API_BASE = "https://text.octoai.run/v1/"
+DEFAULT_MODEL = "thenlper/gte-large"
+
+
+class OctoAIEmbeddings(OpenAIEmbeddings):
+    """OctoAI Compute Service embedding models.
+
+    See https://octo.ai/ for information about OctoAI.
+
+    To use, you should have the ``openai`` python package installed and the
+    environment variable ``OCTOAI_API_TOKEN`` set with your API token.
+    Alternatively, you can use the octoai_api_token keyword argument.
+    """
+
+    octoai_api_token: Optional[SecretStr] = Field(default=None)
+    """OctoAI Endpoints API keys."""
+    endpoint_url: str = Field(default=DEFAULT_API_BASE)
+    """Base URL path for API requests."""
+    model: str = Field(default=DEFAULT_MODEL)
+    """Model name to use."""
+    tiktoken_enabled: bool = False
+    """Set this to False for non-OpenAI implementations of the embeddings API"""
+
+    @property
+    def _llm_type(self) -> str:
+        """Return type of embeddings model."""
+        return "octoai-embeddings"
+
+    @property
+    def lc_secrets(self) -> Dict[str, str]:
+        return {"octoai_api_token": "OCTOAI_API_TOKEN"}
+
+    @pre_init
+    def validate_environment(cls, values: dict) -> dict:
+        """Validate that api key and python package exists in environment."""
+        values["endpoint_url"] = get_from_dict_or_env(
+            values,
+            "endpoint_url",
+            "ENDPOINT_URL",
+            default=DEFAULT_API_BASE,
+        )
+        values["octoai_api_token"] = convert_to_secret_str(
+            get_from_dict_or_env(values, "octoai_api_token", "OCTOAI_API_TOKEN")
+        )
+        values["model"] = get_from_dict_or_env(
+            values,
+            "model",
+            "MODEL",
+            default=DEFAULT_MODEL,
+        )
+
+        try:
+            import openai
+
+            if is_openai_v1():
+                client_params = {
+                    "api_key": values["octoai_api_token"].get_secret_value(),
+                    "base_url": values["endpoint_url"],
+                }
+                if not values.get("client"):
+                    values["client"] = openai.OpenAI(**client_params).embeddings
+                if not values.get("async_client"):
+                    values["async_client"] = openai.AsyncOpenAI(
+                        **client_params
+                    ).embeddings
+            else:
+                values["openai_api_base"] = values["endpoint_url"]
+                values["openai_api_key"] = values["octoai_api_token"].get_secret_value()
+                values["client"] = openai.Embedding
+                values["async_client"] = openai.Embedding
+
+        except ImportError:
+            raise ImportError(
+                "Could not import openai python package. "
+                "Please install it with `pip install openai`."
+            )
+
+        return values

python/user_packages/Python313/site-packages/langchain_community/embeddings/ollama.py

@@ -0,0 +1,228 @@
+import logging
+from typing import Any, Dict, List, Mapping, Optional
+
+import requests
+from langchain_core._api.deprecation import deprecated
+from langchain_core.embeddings import Embeddings
+from pydantic import BaseModel, ConfigDict
+
+logger = logging.getLogger(__name__)
+
+
+@deprecated(
+    since="0.3.1",
+    removal="1.0.0",
+    alternative_import="langchain_ollama.OllamaEmbeddings",
+)
+class OllamaEmbeddings(BaseModel, Embeddings):
+    """Ollama locally runs large language models.
+
+    To use, follow the instructions at https://ollama.ai/.
+
+    Example:
+        .. code-block:: python
+
+            from langchain_community.embeddings import OllamaEmbeddings
+            ollama_emb = OllamaEmbeddings(
+                model="llama:7b",
+            )
+            r1 = ollama_emb.embed_documents(
+                [
+                    "Alpha is the first letter of Greek alphabet",
+                    "Beta is the second letter of Greek alphabet",
+                ]
+            )
+            r2 = ollama_emb.embed_query(
+                "What is the second letter of Greek alphabet"
+            )
+
+    """
+
+    base_url: str = "http://localhost:11434"
+    """Base url the model is hosted under."""
+    model: str = "llama2"
+    """Model name to use."""
+
+    embed_instruction: str = "passage: "
+    """Instruction used to embed documents."""
+    query_instruction: str = "query: "
+    """Instruction used to embed the query."""
+
+    mirostat: Optional[int] = None
+    """Enable Mirostat sampling for controlling perplexity.
+    (default: 0, 0 = disabled, 1 = Mirostat, 2 = Mirostat 2.0)"""
+
+    mirostat_eta: Optional[float] = None
+    """Influences how quickly the algorithm responds to feedback
+    from the generated text. A lower learning rate will result in
+    slower adjustments, while a higher learning rate will make
+    the algorithm more responsive. (Default: 0.1)"""
+
+    mirostat_tau: Optional[float] = None
+    """Controls the balance between coherence and diversity
+    of the output. A lower value will result in more focused and
+    coherent text. (Default: 5.0)"""
+
+    num_ctx: Optional[int] = None
+    """Sets the size of the context window used to generate the
+    next token. (Default: 2048)	"""
+
+    num_gpu: Optional[int] = None
+    """The number of GPUs to use. On macOS it defaults to 1 to
+    enable metal support, 0 to disable."""
+
+    num_thread: Optional[int] = None
+    """Sets the number of threads to use during computation.
+    By default, Ollama will detect this for optimal performance.
+    It is recommended to set this value to the number of physical
+    CPU cores your system has (as opposed to the logical number of cores)."""
+
+    repeat_last_n: Optional[int] = None
+    """Sets how far back for the model to look back to prevent
+    repetition. (Default: 64, 0 = disabled, -1 = num_ctx)"""
+
+    repeat_penalty: Optional[float] = None
+    """Sets how strongly to penalize repetitions. A higher value (e.g., 1.5)
+    will penalize repetitions more strongly, while a lower value (e.g., 0.9)
+    will be more lenient. (Default: 1.1)"""
+
+    temperature: Optional[float] = None
+    """The temperature of the model. Increasing the temperature will
+    make the model answer more creatively. (Default: 0.8)"""
+
+    stop: Optional[List[str]] = None
+    """Sets the stop tokens to use."""
+
+    tfs_z: Optional[float] = None
+    """Tail free sampling is used to reduce the impact of less probable
+    tokens from the output. A higher value (e.g., 2.0) will reduce the
+    impact more, while a value of 1.0 disables this setting. (default: 1)"""
+
+    top_k: Optional[int] = None
+    """Reduces the probability of generating nonsense. A higher value (e.g. 100)
+    will give more diverse answers, while a lower value (e.g. 10)
+    will be more conservative. (Default: 40)"""
+
+    top_p: Optional[float] = None
+    """Works together with top-k. A higher value (e.g., 0.95) will lead
+    to more diverse text, while a lower value (e.g., 0.5) will
+    generate more focused and conservative text. (Default: 0.9)"""
+
+    show_progress: bool = False
+    """Whether to show a tqdm progress bar. Must have `tqdm` installed."""
+
+    headers: Optional[dict] = None
+    """Additional headers to pass to endpoint (e.g. Authorization, Referer).
+    This is useful when Ollama is hosted on cloud services that require
+    tokens for authentication.
+    """
+
+    @property
+    def _default_params(self) -> Dict[str, Any]:
+        """Get the default parameters for calling Ollama."""
+        return {
+            "model": self.model,
+            "options": {
+                "mirostat": self.mirostat,
+                "mirostat_eta": self.mirostat_eta,
+                "mirostat_tau": self.mirostat_tau,
+                "num_ctx": self.num_ctx,
+                "num_gpu": self.num_gpu,
+                "num_thread": self.num_thread,
+                "repeat_last_n": self.repeat_last_n,
+                "repeat_penalty": self.repeat_penalty,
+                "temperature": self.temperature,
+                "stop": self.stop,
+                "tfs_z": self.tfs_z,
+                "top_k": self.top_k,
+                "top_p": self.top_p,
+            },
+        }
+
+    model_kwargs: Optional[dict] = None
+    """Other model keyword args"""
+
+    @property
+    def _identifying_params(self) -> Mapping[str, Any]:
+        """Get the identifying parameters."""
+        return {**{"model": self.model}, **self._default_params}
+
+    model_config = ConfigDict(extra="forbid", protected_namespaces=())
+
+    def _process_emb_response(self, input: str) -> List[float]:
+        """Process a response from the API.
+
+        Args:
+            response: The response from the API.
+
+        Returns:
+            The response as a dictionary.
+        """
+        headers = {
+            "Content-Type": "application/json",
+            **(self.headers or {}),
+        }
+
+        try:
+            res = requests.post(
+                f"{self.base_url}/api/embeddings",
+                headers=headers,
+                json={"model": self.model, "prompt": input, **self._default_params},
+            )
+        except requests.exceptions.RequestException as e:
+            raise ValueError(f"Error raised by inference endpoint: {e}")
+
+        if res.status_code != 200:
+            raise ValueError(
+                "Error raised by inference API HTTP code: %s, %s"
+                % (res.status_code, res.text)
+            )
+        try:
+            t = res.json()
+            return t["embedding"]
+        except requests.exceptions.JSONDecodeError as e:
+            raise ValueError(
+                f"Error raised by inference API: {e}.\nResponse: {res.text}"
+            )
+
+    def _embed(self, input: List[str]) -> List[List[float]]:
+        if self.show_progress:
+            try:
+                from tqdm import tqdm
+
+                iter_ = tqdm(input, desc="OllamaEmbeddings")
+            except ImportError:
+                logger.warning(
+                    "Unable to show progress bar because tqdm could not be imported. "
+                    "Please install with `pip install tqdm`."
+                )
+                iter_ = input
+        else:
+            iter_ = input
+        return [self._process_emb_response(prompt) for prompt in iter_]
+
+    def embed_documents(self, texts: List[str]) -> List[List[float]]:
+        """Embed documents using an Ollama deployed embedding model.
+
+        Args:
+            texts: The list of texts to embed.
+
+        Returns:
+            List of embeddings, one for each text.
+        """
+        instruction_pairs = [f"{self.embed_instruction}{text}" for text in texts]
+        embeddings = self._embed(instruction_pairs)
+        return embeddings
+
+    def embed_query(self, text: str) -> List[float]:
+        """Embed a query using a Ollama deployed embedding model.
+
+        Args:
+            text: The text to embed.
+
+        Returns:
+            Embeddings for the text.
+        """
+        instruction_pair = f"{self.query_instruction}{text}"
+        embedding = self._embed([instruction_pair])[0]
+        return embedding

python/user_packages/Python313/site-packages/langchain_community/embeddings/openai.py

@@ -0,0 +1,716 @@
+from __future__ import annotations
+
+import logging
+import os
+import warnings
+from typing import (
+    Any,
+    Callable,
+    Dict,
+    List,
+    Literal,
+    Mapping,
+    Optional,
+    Sequence,
+    Set,
+    Tuple,
+    Union,
+    cast,
+)
+
+import numpy as np
+from langchain_core._api.deprecation import deprecated
+from langchain_core.embeddings import Embeddings
+from langchain_core.utils import (
+    get_from_dict_or_env,
+    get_pydantic_field_names,
+    pre_init,
+)
+from pydantic import BaseModel, ConfigDict, Field, model_validator
+from tenacity import (
+    AsyncRetrying,
+    before_sleep_log,
+    retry,
+    retry_if_exception_type,
+    stop_after_attempt,
+    wait_exponential,
+)
+
+from langchain_community.utils.openai import is_openai_v1
+
+logger = logging.getLogger(__name__)
+
+
+def _create_retry_decorator(embeddings: OpenAIEmbeddings) -> Callable[[Any], Any]:
+    import openai
+
+    # Wait 2^x * 1 second between each retry starting with
+    # retry_min_seconds seconds, then up to retry_max_seconds seconds,
+    # then retry_max_seconds seconds afterwards
+    # retry_min_seconds and retry_max_seconds are optional arguments of
+    # OpenAIEmbeddings
+    return retry(
+        reraise=True,
+        stop=stop_after_attempt(embeddings.max_retries),
+        wait=wait_exponential(
+            multiplier=1,
+            min=embeddings.retry_min_seconds,
+            max=embeddings.retry_max_seconds,
+        ),
+        retry=(
+            retry_if_exception_type(openai.error.Timeout)
+            | retry_if_exception_type(openai.error.APIError)
+            | retry_if_exception_type(openai.error.APIConnectionError)
+            | retry_if_exception_type(openai.error.RateLimitError)
+            | retry_if_exception_type(openai.error.ServiceUnavailableError)
+        ),
+        before_sleep=before_sleep_log(logger, logging.WARNING),
+    )
+
+
+def _async_retry_decorator(embeddings: OpenAIEmbeddings) -> Any:
+    import openai
+
+    # Wait 2^x * 1 second between each retry starting with
+    # retry_min_seconds seconds, then up to retry_max_seconds seconds,
+    # then retry_max_seconds seconds afterwards
+    # retry_min_seconds and retry_max_seconds are optional arguments of
+    # OpenAIEmbeddings
+    async_retrying = AsyncRetrying(
+        reraise=True,
+        stop=stop_after_attempt(embeddings.max_retries),
+        wait=wait_exponential(
+            multiplier=1,
+            min=embeddings.retry_min_seconds,
+            max=embeddings.retry_max_seconds,
+        ),
+        retry=(
+            retry_if_exception_type(openai.error.Timeout)
+            | retry_if_exception_type(openai.error.APIError)
+            | retry_if_exception_type(openai.error.APIConnectionError)
+            | retry_if_exception_type(openai.error.RateLimitError)
+            | retry_if_exception_type(openai.error.ServiceUnavailableError)
+        ),
+        before_sleep=before_sleep_log(logger, logging.WARNING),
+    )
+
+    def wrap(func: Callable) -> Callable:
+        async def wrapped_f(*args: Any, **kwargs: Any) -> Callable:
+            async for _ in async_retrying:
+                return await func(*args, **kwargs)
+            raise AssertionError("this is unreachable")
+
+        return wrapped_f
+
+    return wrap
+
+
+# https://stackoverflow.com/questions/76469415/getting-embeddings-of-length-1-from-langchain-openaiembeddings
+def _check_response(response: dict, skip_empty: bool = False) -> dict:
+    if any(len(d["embedding"]) == 1 for d in response["data"]) and not skip_empty:
+        import openai
+
+        raise openai.error.APIError("OpenAI API returned an empty embedding")
+    return response
+
+
+def embed_with_retry(embeddings: OpenAIEmbeddings, **kwargs: Any) -> Any:
+    """Use tenacity to retry the embedding call."""
+    if is_openai_v1():
+        return embeddings.client.create(**kwargs)
+    retry_decorator = _create_retry_decorator(embeddings)
+
+    @retry_decorator
+    def _embed_with_retry(**kwargs: Any) -> Any:
+        response = embeddings.client.create(**kwargs)
+        return _check_response(response, skip_empty=embeddings.skip_empty)
+
+    return _embed_with_retry(**kwargs)
+
+
+async def async_embed_with_retry(embeddings: OpenAIEmbeddings, **kwargs: Any) -> Any:
+    """Use tenacity to retry the embedding call."""
+
+    if is_openai_v1():
+        return await embeddings.async_client.create(**kwargs)
+
+    @_async_retry_decorator(embeddings)
+    async def _async_embed_with_retry(**kwargs: Any) -> Any:
+        response = await embeddings.client.acreate(**kwargs)
+        return _check_response(response, skip_empty=embeddings.skip_empty)
+
+    return await _async_embed_with_retry(**kwargs)
+
+
+@deprecated(
+    since="0.0.9",
+    removal="1.0",
+    alternative_import="langchain_openai.OpenAIEmbeddings",
+)
+class OpenAIEmbeddings(BaseModel, Embeddings):
+    """OpenAI embedding models.
+
+    To use, you should have the ``openai`` python package installed, and the
+    environment variable ``OPENAI_API_KEY`` set with your API key or pass it
+    as a named parameter to the constructor.
+
+    Example:
+        .. code-block:: python
+
+            from langchain_community.embeddings import OpenAIEmbeddings
+            openai = OpenAIEmbeddings(openai_api_key="my-api-key")
+
+    In order to use the library with Microsoft Azure endpoints, you need to set
+    the OPENAI_API_TYPE, OPENAI_API_BASE, OPENAI_API_KEY and OPENAI_API_VERSION.
+    The OPENAI_API_TYPE must be set to 'azure' and the others correspond to
+    the properties of your endpoint.
+    In addition, the deployment name must be passed as the model parameter.
+
+    Example:
+        .. code-block:: python
+
+            import os
+
+            os.environ["OPENAI_API_TYPE"] = "azure"
+            os.environ["OPENAI_API_BASE"] = "https://<your-endpoint.openai.azure.com/"
+            os.environ["OPENAI_API_KEY"] = "your AzureOpenAI key"
+            os.environ["OPENAI_API_VERSION"] = "2023-05-15"
+            os.environ["OPENAI_PROXY"] = "http://your-corporate-proxy:8080"
+
+            from langchain_community.embeddings.openai import OpenAIEmbeddings
+            embeddings = OpenAIEmbeddings(
+                deployment="your-embeddings-deployment-name",
+                model="your-embeddings-model-name",
+                openai_api_base="https://your-endpoint.openai.azure.com/",
+                openai_api_type="azure",
+            )
+            text = "This is a test query."
+            query_result = embeddings.embed_query(text)
+
+    """
+
+    client: Any = Field(default=None, exclude=True)  #: :meta private:
+    async_client: Any = Field(default=None, exclude=True)  #: :meta private:
+    model: str = "text-embedding-ada-002"
+    # to support Azure OpenAI Service custom deployment names
+    deployment: Optional[str] = model
+    # TODO: Move to AzureOpenAIEmbeddings.
+    openai_api_version: Optional[str] = Field(default=None, alias="api_version")
+    """Automatically inferred from env var `OPENAI_API_VERSION` if not provided."""
+    # to support Azure OpenAI Service custom endpoints
+    openai_api_base: Optional[str] = Field(default=None, alias="base_url")
+    """Base URL path for API requests, leave blank if not using a proxy or service 
+        emulator."""
+    # to support Azure OpenAI Service custom endpoints
+    openai_api_type: Optional[str] = None
+    # to support explicit proxy for OpenAI
+    openai_proxy: Optional[str] = None
+    embedding_ctx_length: int = 8191
+    """The maximum number of tokens to embed at once."""
+    openai_api_key: Optional[str] = Field(default=None, alias="api_key")
+    """Automatically inferred from env var `OPENAI_API_KEY` if not provided."""
+    openai_organization: Optional[str] = Field(default=None, alias="organization")
+    """Automatically inferred from env var `OPENAI_ORG_ID` if not provided."""
+    allowed_special: Union[Literal["all"], Set[str]] = set()
+    disallowed_special: Union[Literal["all"], Set[str], Sequence[str]] = "all"
+    chunk_size: int = 1000
+    """Maximum number of texts to embed in each batch"""
+    max_retries: int = 2
+    """Maximum number of retries to make when generating."""
+    request_timeout: Optional[Union[float, Tuple[float, float], Any]] = Field(
+        default=None, alias="timeout"
+    )
+    """Timeout for requests to OpenAI completion API. Can be float, httpx.Timeout or 
+        None."""
+    headers: Any = None
+    tiktoken_enabled: bool = True
+    """Set this to False for non-OpenAI implementations of the embeddings API, e.g.
+    the `--extensions openai` extension for `text-generation-webui`"""
+    tiktoken_model_name: Optional[str] = None
+    """The model name to pass to tiktoken when using this class. 
+    Tiktoken is used to count the number of tokens in documents to constrain 
+    them to be under a certain limit. By default, when set to None, this will 
+    be the same as the embedding model name. However, there are some cases 
+    where you may want to use this Embedding class with a model name not 
+    supported by tiktoken. This can include when using Azure embeddings or 
+    when using one of the many model providers that expose an OpenAI-like 
+    API but with different models. In those cases, in order to avoid erroring 
+    when tiktoken is called, you can specify a model name to use here."""
+    show_progress_bar: bool = False
+    """Whether to show a progress bar when embedding."""
+    model_kwargs: Dict[str, Any] = Field(default_factory=dict)
+    """Holds any model parameters valid for `create` call not explicitly specified."""
+    skip_empty: bool = False
+    """Whether to skip empty strings when embedding or raise an error.
+    Defaults to not skipping."""
+    default_headers: Union[Mapping[str, str], None] = None
+    default_query: Union[Mapping[str, object], None] = None
+    # Configure a custom httpx client. See the
+    # [httpx documentation](https://www.python-httpx.org/api/#client) for more details.
+    retry_min_seconds: int = 4
+    """Min number of seconds to wait between retries"""
+    retry_max_seconds: int = 20
+    """Max number of seconds to wait between retries"""
+    http_client: Union[Any, None] = None
+    """Optional httpx.Client."""
+
+    model_config = ConfigDict(
+        populate_by_name=True, extra="forbid", protected_namespaces=()
+    )
+
+    @model_validator(mode="before")
+    @classmethod
+    def build_extra(cls, values: Dict[str, Any]) -> Any:
+        """Build extra kwargs from additional params that were passed in."""
+        all_required_field_names = get_pydantic_field_names(cls)
+        extra = values.get("model_kwargs", {})
+        for field_name in list(values):
+            if field_name in extra:
+                raise ValueError(f"Found {field_name} supplied twice.")
+            if field_name not in all_required_field_names:
+                warnings.warn(
+                    f"""WARNING! {field_name} is not default parameter.
+                    {field_name} was transferred to model_kwargs.
+                    Please confirm that {field_name} is what you intended."""
+                )
+                extra[field_name] = values.pop(field_name)
+
+        invalid_model_kwargs = all_required_field_names.intersection(extra.keys())
+        if invalid_model_kwargs:
+            raise ValueError(
+                f"Parameters {invalid_model_kwargs} should be specified explicitly. "
+                f"Instead they were passed in as part of `model_kwargs` parameter."
+            )
+
+        values["model_kwargs"] = extra
+        return values
+
+    @pre_init
+    def validate_environment(cls, values: Dict) -> Dict:
+        """Validate that api key and python package exists in environment."""
+        values["openai_api_key"] = get_from_dict_or_env(
+            values, "openai_api_key", "OPENAI_API_KEY"
+        )
+        values["openai_api_base"] = values["openai_api_base"] or os.getenv(
+            "OPENAI_API_BASE"
+        )
+        values["openai_api_type"] = get_from_dict_or_env(
+            values,
+            "openai_api_type",
+            "OPENAI_API_TYPE",
+            default="",
+        )
+        values["openai_proxy"] = get_from_dict_or_env(
+            values,
+            "openai_proxy",
+            "OPENAI_PROXY",
+            default="",
+        )
+        if values["openai_api_type"] in ("azure", "azure_ad", "azuread"):
+            default_api_version = "2023-05-15"
+            # Azure OpenAI embedding models allow a maximum of 2048
+            # texts at a time in each batch
+            # See: https://learn.microsoft.com/en-us/azure/ai-services/openai/reference#embeddings
+            values["chunk_size"] = min(values["chunk_size"], 2048)
+        else:
+            default_api_version = ""
+        values["openai_api_version"] = get_from_dict_or_env(
+            values,
+            "openai_api_version",
+            "OPENAI_API_VERSION",
+            default=default_api_version,
+        )
+        # Check OPENAI_ORGANIZATION for backwards compatibility.
+        values["openai_organization"] = (
+            values["openai_organization"]
+            or os.getenv("OPENAI_ORG_ID")
+            or os.getenv("OPENAI_ORGANIZATION")
+        )
+        try:
+            import openai
+        except ImportError:
+            raise ImportError(
+                "Could not import openai python package. "
+                "Please install it with `pip install openai`."
+            )
+        else:
+            if is_openai_v1():
+                if values["openai_api_type"] in ("azure", "azure_ad", "azuread"):
+                    warnings.warn(
+                        "If you have openai>=1.0.0 installed and are using Azure, "
+                        "please use the `AzureOpenAIEmbeddings` class."
+                    )
+                client_params = {
+                    "api_key": values["openai_api_key"],
+                    "organization": values["openai_organization"],
+                    "base_url": values["openai_api_base"],
+                    "timeout": values["request_timeout"],
+                    "max_retries": values["max_retries"],
+                    "default_headers": values["default_headers"],
+                    "default_query": values["default_query"],
+                    "http_client": values["http_client"],
+                }
+                if not values.get("client"):
+                    values["client"] = openai.OpenAI(**client_params).embeddings
+                if not values.get("async_client"):
+                    values["async_client"] = openai.AsyncOpenAI(
+                        **client_params
+                    ).embeddings
+            elif not values.get("client"):
+                values["client"] = openai.Embedding
+            else:
+                pass
+        return values
+
+    @property
+    def _invocation_params(self) -> Dict[str, Any]:
+        if is_openai_v1():
+            openai_args: Dict = {"model": self.model, **self.model_kwargs}
+        else:
+            openai_args = {
+                "model": self.model,
+                "request_timeout": self.request_timeout,
+                "headers": self.headers,
+                "api_key": self.openai_api_key,
+                "organization": self.openai_organization,
+                "api_base": self.openai_api_base,
+                "api_type": self.openai_api_type,
+                "api_version": self.openai_api_version,
+                **self.model_kwargs,
+            }
+            if self.openai_api_type in ("azure", "azure_ad", "azuread"):
+                openai_args["engine"] = self.deployment
+            # TODO: Look into proxy with openai v1.
+            if self.openai_proxy:
+                try:
+                    import openai
+                except ImportError:
+                    raise ImportError(
+                        "Could not import openai python package. "
+                        "Please install it with `pip install openai`."
+                    )
+
+                openai.proxy = {
+                    "http": self.openai_proxy,
+                    "https": self.openai_proxy,
+                }
+        return openai_args
+
+    # please refer to
+    # https://github.com/openai/openai-cookbook/blob/main/examples/Embedding_long_inputs.ipynb
+    def _get_len_safe_embeddings(
+        self, texts: List[str], *, engine: str, chunk_size: Optional[int] = None
+    ) -> List[List[float]]:
+        """
+        Generate length-safe embeddings for a list of texts.
+
+        This method handles tokenization and embedding generation, respecting the
+        set embedding context length and chunk size. It supports both tiktoken
+        and HuggingFace tokenizer based on the tiktoken_enabled flag.
+
+        Args:
+            texts (List[str]): A list of texts to embed.
+            engine (str): The engine or model to use for embeddings.
+            chunk_size (Optional[int]): The size of chunks for processing embeddings.
+
+        Returns:
+            List[List[float]]: A list of embeddings for each input text.
+        """
+
+        tokens = []
+        indices = []
+        model_name = self.tiktoken_model_name or self.model
+        _chunk_size = chunk_size or self.chunk_size
+
+        # If tiktoken flag set to False
+        if not self.tiktoken_enabled:
+            try:
+                from transformers import AutoTokenizer
+            except ImportError:
+                raise ImportError(
+                    "Could not import transformers python package. "
+                    "This is needed in order to for OpenAIEmbeddings without "
+                    "`tiktoken`. Please install it with `pip install transformers`. "
+                )
+
+            tokenizer = AutoTokenizer.from_pretrained(
+                pretrained_model_name_or_path=model_name
+            )
+            for i, text in enumerate(texts):
+                # Tokenize the text using HuggingFace transformers
+                tokenized = tokenizer.encode(text, add_special_tokens=False)
+
+                # Split tokens into chunks respecting the embedding_ctx_length
+                for j in range(0, len(tokenized), self.embedding_ctx_length):
+                    token_chunk = tokenized[j : j + self.embedding_ctx_length]
+
+                    # Convert token IDs back to a string
+                    chunk_text = tokenizer.decode(token_chunk)
+                    tokens.append(chunk_text)
+                    indices.append(i)
+        else:
+            try:
+                import tiktoken
+            except ImportError:
+                raise ImportError(
+                    "Could not import tiktoken python package. "
+                    "This is needed in order to for OpenAIEmbeddings. "
+                    "Please install it with `pip install tiktoken`."
+                )
+
+            try:
+                encoding = tiktoken.encoding_for_model(model_name)
+            except KeyError:
+                logger.warning("Warning: model not found. Using cl100k_base encoding.")
+                model = "cl100k_base"
+                encoding = tiktoken.get_encoding(model)
+            for i, text in enumerate(texts):
+                if self.model.endswith("001"):
+                    # See: https://github.com/openai/openai-python/
+                    #      issues/418#issuecomment-1525939500
+                    # replace newlines, which can negatively affect performance.
+                    text = text.replace("\n", " ")
+
+                token = encoding.encode(
+                    text=text,
+                    allowed_special=self.allowed_special,
+                    disallowed_special=self.disallowed_special,
+                )
+
+                # Split tokens into chunks respecting the embedding_ctx_length
+                for j in range(0, len(token), self.embedding_ctx_length):
+                    tokens.append(token[j : j + self.embedding_ctx_length])
+                    indices.append(i)
+
+        if self.show_progress_bar:
+            try:
+                from tqdm.auto import tqdm
+
+                _iter = tqdm(range(0, len(tokens), _chunk_size))
+            except ImportError:
+                _iter = range(0, len(tokens), _chunk_size)
+        else:
+            _iter = range(0, len(tokens), _chunk_size)
+
+        batched_embeddings: List[List[float]] = []
+        for i in _iter:
+            response = embed_with_retry(
+                self,
+                input=tokens[i : i + _chunk_size],
+                **self._invocation_params,
+            )
+            if not isinstance(response, dict):
+                response = response.dict()
+            batched_embeddings.extend(r["embedding"] for r in response["data"])
+
+        results: List[List[List[float]]] = [[] for _ in range(len(texts))]
+        num_tokens_in_batch: List[List[int]] = [[] for _ in range(len(texts))]
+        for i in range(len(indices)):
+            if self.skip_empty and len(batched_embeddings[i]) == 1:
+                continue
+            results[indices[i]].append(batched_embeddings[i])
+            num_tokens_in_batch[indices[i]].append(len(tokens[i]))
+
+        embeddings: List[List[float]] = [[] for _ in range(len(texts))]
+        for i in range(len(texts)):
+            _result = results[i]
+            if len(_result) == 0:
+                average_embedded = embed_with_retry(
+                    self,
+                    input="",
+                    **self._invocation_params,
+                )
+                if not isinstance(average_embedded, dict):
+                    average_embedded = average_embedded.dict()
+                average = average_embedded["data"][0]["embedding"]
+            else:
+                average = np.average(_result, axis=0, weights=num_tokens_in_batch[i])
+            embeddings[i] = (average / np.linalg.norm(average)).tolist()
+
+        return embeddings
+
+    # please refer to
+    # https://github.com/openai/openai-cookbook/blob/main/examples/Embedding_long_inputs.ipynb
+    async def _aget_len_safe_embeddings(
+        self, texts: List[str], *, engine: str, chunk_size: Optional[int] = None
+    ) -> List[List[float]]:
+        """
+        Asynchronously generate length-safe embeddings for a list of texts.
+
+        This method handles tokenization and asynchronous embedding generation,
+        respecting the set embedding context length and chunk size. It supports both
+        `tiktoken` and HuggingFace `tokenizer` based on the tiktoken_enabled flag.
+
+        Args:
+            texts (List[str]): A list of texts to embed.
+            engine (str): The engine or model to use for embeddings.
+            chunk_size (Optional[int]): The size of chunks for processing embeddings.
+
+        Returns:
+            List[List[float]]: A list of embeddings for each input text.
+        """
+
+        tokens = []
+        indices = []
+        model_name = self.tiktoken_model_name or self.model
+        _chunk_size = chunk_size or self.chunk_size
+
+        # If tiktoken flag set to False
+        if not self.tiktoken_enabled:
+            try:
+                from transformers import AutoTokenizer
+            except ImportError:
+                raise ImportError(
+                    "Could not import transformers python package. "
+                    "This is needed in order to for OpenAIEmbeddings without "
+                    " `tiktoken`. Please install it with `pip install transformers`."
+                )
+
+            tokenizer = AutoTokenizer.from_pretrained(
+                pretrained_model_name_or_path=model_name
+            )
+            for i, text in enumerate(texts):
+                # Tokenize the text using HuggingFace transformers
+                tokenized = tokenizer.encode(text, add_special_tokens=False)
+
+                # Split tokens into chunks respecting the embedding_ctx_length
+                for j in range(0, len(tokenized), self.embedding_ctx_length):
+                    token_chunk = tokenized[j : j + self.embedding_ctx_length]
+
+                    # Convert token IDs back to a string
+                    chunk_text = tokenizer.decode(token_chunk)
+                    tokens.append(chunk_text)
+                    indices.append(i)
+        else:
+            try:
+                import tiktoken
+            except ImportError:
+                raise ImportError(
+                    "Could not import tiktoken python package. "
+                    "This is needed in order to for OpenAIEmbeddings. "
+                    "Please install it with `pip install tiktoken`."
+                )
+
+            try:
+                encoding = tiktoken.encoding_for_model(model_name)
+            except KeyError:
+                logger.warning("Warning: model not found. Using cl100k_base encoding.")
+                model = "cl100k_base"
+                encoding = tiktoken.get_encoding(model)
+            for i, text in enumerate(texts):
+                if self.model.endswith("001"):
+                    # See: https://github.com/openai/openai-python/
+                    #      issues/418#issuecomment-1525939500
+                    # replace newlines, which can negatively affect performance.
+                    text = text.replace("\n", " ")
+
+                token = encoding.encode(
+                    text=text,
+                    allowed_special=self.allowed_special,
+                    disallowed_special=self.disallowed_special,
+                )
+
+                # Split tokens into chunks respecting the embedding_ctx_length
+                for j in range(0, len(token), self.embedding_ctx_length):
+                    tokens.append(token[j : j + self.embedding_ctx_length])
+                    indices.append(i)
+
+        batched_embeddings: List[List[float]] = []
+        _chunk_size = chunk_size or self.chunk_size
+        for i in range(0, len(tokens), _chunk_size):
+            response = await async_embed_with_retry(
+                self,
+                input=tokens[i : i + _chunk_size],
+                **self._invocation_params,
+            )
+
+            if not isinstance(response, dict):
+                response = response.dict()
+            batched_embeddings.extend(r["embedding"] for r in response["data"])
+
+        results: List[List[List[float]]] = [[] for _ in range(len(texts))]
+        num_tokens_in_batch: List[List[int]] = [[] for _ in range(len(texts))]
+        for i in range(len(indices)):
+            results[indices[i]].append(batched_embeddings[i])
+            num_tokens_in_batch[indices[i]].append(len(tokens[i]))
+
+        embeddings: List[List[float]] = [[] for _ in range(len(texts))]
+        for i in range(len(texts)):
+            _result = results[i]
+            if len(_result) == 0:
+                average_embedded = await async_embed_with_retry(
+                    self,
+                    input="",
+                    **self._invocation_params,
+                )
+                if not isinstance(average_embedded, dict):
+                    average_embedded = average_embedded.dict()
+                average = average_embedded["data"][0]["embedding"]
+            else:
+                average = np.average(_result, axis=0, weights=num_tokens_in_batch[i])
+            embeddings[i] = (average / np.linalg.norm(average)).tolist()
+
+        return embeddings
+
+    def embed_documents(
+        self, texts: List[str], chunk_size: Optional[int] = 0
+    ) -> List[List[float]]:
+        """Call out to OpenAI's embedding endpoint for embedding search docs.
+
+        Args:
+            texts: The list of texts to embed.
+            chunk_size: The chunk size of embeddings. If None, will use the chunk size
+                specified by the class.
+
+        Returns:
+            List of embeddings, one for each text.
+        """
+        # NOTE: to keep things simple, we assume the list may contain texts longer
+        #       than the maximum context and use length-safe embedding function.
+        engine = cast(str, self.deployment)
+        return self._get_len_safe_embeddings(
+            texts, engine=engine, chunk_size=chunk_size
+        )
+
+    async def aembed_documents(
+        self, texts: List[str], chunk_size: Optional[int] = 0
+    ) -> List[List[float]]:
+        """Call out to OpenAI's embedding endpoint async for embedding search docs.
+
+        Args:
+            texts: The list of texts to embed.
+            chunk_size: The chunk size of embeddings. If None, will use the chunk size
+                specified by the class.
+
+        Returns:
+            List of embeddings, one for each text.
+        """
+        # NOTE: to keep things simple, we assume the list may contain texts longer
+        #       than the maximum context and use length-safe embedding function.
+        engine = cast(str, self.deployment)
+        return self._get_len_safe_embeddings(
+            texts, engine=engine, chunk_size=chunk_size
+        )
+
+    def embed_query(self, text: str) -> List[float]:
+        """Call out to OpenAI's embedding endpoint for embedding query text.
+
+        Args:
+            text: The text to embed.
+
+        Returns:
+            Embedding for the text.
+        """
+        return self.embed_documents([text])[0]
+
+    async def aembed_query(self, text: str) -> List[float]:
+        """Call out to OpenAI's embedding endpoint async for embedding query text.
+
+        Args:
+            text: The text to embed.
+
+        Returns:
+            Embedding for the text.
+        """
+        embeddings = await self.aembed_documents([text])
+        return embeddings[0]

python/user_packages/Python313/site-packages/langchain_community/embeddings/openvino.py

@@ -0,0 +1,351 @@
+from pathlib import Path
+from typing import Any, Dict, List
+
+from langchain_core.embeddings import Embeddings
+from pydantic import BaseModel, ConfigDict, Field
+
+DEFAULT_QUERY_INSTRUCTION = (
+    "Represent the question for retrieving supporting documents: "
+)
+DEFAULT_QUERY_BGE_INSTRUCTION_EN = (
+    "Represent this question for searching relevant passages: "
+)
+DEFAULT_QUERY_BGE_INSTRUCTION_ZH = "为这个句子生成表示以用于检索相关文章："
+
+
+class OpenVINOEmbeddings(BaseModel, Embeddings):
+    """OpenVINO embedding models.
+
+    Example:
+        .. code-block:: python
+
+            from langchain_community.embeddings import OpenVINOEmbeddings
+
+            model_name = "sentence-transformers/all-mpnet-base-v2"
+            model_kwargs = {'device': 'CPU'}
+            encode_kwargs = {'normalize_embeddings': True}
+            ov = OpenVINOEmbeddings(
+                model_name_or_path=model_name,
+                model_kwargs=model_kwargs,
+                encode_kwargs=encode_kwargs
+            )
+    """
+
+    ov_model: Any = None
+    """OpenVINO model object."""
+    tokenizer: Any = None
+    """Tokenizer for embedding model."""
+    model_name_or_path: str
+    """HuggingFace model id."""
+    model_kwargs: Dict[str, Any] = Field(default_factory=dict)
+    """Keyword arguments to pass to the model."""
+    encode_kwargs: Dict[str, Any] = Field(default_factory=dict)
+    """Keyword arguments to pass when calling the `encode` method of the model."""
+    show_progress: bool = False
+    """Whether to show a progress bar."""
+
+    def __init__(self, **kwargs: Any):
+        """Initialize the sentence_transformer."""
+        super().__init__(**kwargs)
+
+        try:
+            from optimum.intel.openvino import OVModelForFeatureExtraction
+        except ImportError as e:
+            raise ImportError(
+                "Could not import optimum-intel python package. "
+                "Please install it with: "
+                "pip install -U 'optimum[openvino,nncf]'"
+            ) from e
+
+        try:
+            from huggingface_hub import HfApi
+        except ImportError as e:
+            raise ImportError(
+                "Could not import huggingface_hub python package. "
+                "Please install it with: "
+                "`pip install -U huggingface_hub`."
+            ) from e
+
+        def require_model_export(
+            model_id: str, revision: Any = None, subfolder: Any = None
+        ) -> bool:
+            model_dir = Path(model_id)
+            if subfolder is not None:
+                model_dir = model_dir / subfolder
+            if model_dir.is_dir():
+                return (
+                    not (model_dir / "openvino_model.xml").exists()
+                    or not (model_dir / "openvino_model.bin").exists()
+                )
+            hf_api = HfApi()
+            try:
+                model_info = hf_api.model_info(model_id, revision=revision or "main")
+                normalized_subfolder = (
+                    None if subfolder is None else Path(subfolder).as_posix()
+                )
+                model_files = [
+                    file.rfilename
+                    for file in model_info.siblings
+                    if normalized_subfolder is None
+                    or file.rfilename.startswith(normalized_subfolder)
+                ]
+                ov_model_path = (
+                    "openvino_model.xml"
+                    if subfolder is None
+                    else f"{normalized_subfolder}/openvino_model.xml"
+                )
+                return (
+                    ov_model_path not in model_files
+                    or ov_model_path.replace(".xml", ".bin") not in model_files
+                )
+            except Exception:
+                return True
+
+        if require_model_export(self.model_name_or_path):
+            # use remote model
+            self.ov_model = OVModelForFeatureExtraction.from_pretrained(
+                self.model_name_or_path, export=True, **self.model_kwargs
+            )
+        else:
+            # use local model
+            self.ov_model = OVModelForFeatureExtraction.from_pretrained(
+                self.model_name_or_path, **self.model_kwargs
+            )
+
+        try:
+            from transformers import AutoTokenizer
+        except ImportError as e:
+            raise ImportError(
+                "Unable to import transformers, please install with "
+                "`pip install -U transformers`."
+            ) from e
+        self.tokenizer = AutoTokenizer.from_pretrained(self.model_name_or_path)
+
+    def _text_length(self, text: Any) -> int:
+        """
+        Help function to get the length for the input text. Text can be either
+        a list of ints (which means a single text as input), or a tuple of list of ints
+        (representing several text inputs to the model).
+        """
+
+        if isinstance(text, dict):  # {key: value} case
+            return len(next(iter(text.values())))
+        elif not hasattr(text, "__len__"):  # Object has no len() method
+            return 1
+        # Empty string or list of ints
+        elif len(text) == 0 or isinstance(text[0], int):
+            return len(text)
+        else:
+            # Sum of length of individual strings
+            return sum([len(t) for t in text])
+
+    def encode(
+        self,
+        sentences: Any,
+        batch_size: int = 4,
+        show_progress_bar: bool = False,
+        convert_to_numpy: bool = True,
+        convert_to_tensor: bool = False,
+        mean_pooling: bool = False,
+        normalize_embeddings: bool = True,
+    ) -> Any:
+        """
+        Computes sentence embeddings.
+
+        :param sentences: the sentences to embed.
+        :param batch_size: the batch size used for the computation.
+        :param show_progress_bar: Whether to output a progress bar.
+        :param convert_to_numpy: Whether the output should be a list of numpy vectors.
+        :param convert_to_tensor: Whether the output should be one large tensor.
+        :param mean_pooling: Whether to pool returned vectors.
+        :param normalize_embeddings: Whether to normalize returned vectors.
+
+        :return: By default, a 2d numpy array with shape [num_inputs, output_dimension].
+        """
+        try:
+            import numpy as np
+        except ImportError as e:
+            raise ImportError(
+                "Unable to import numpy, please install with `pip install -U numpy`."
+            ) from e
+        try:
+            from tqdm import trange
+        except ImportError as e:
+            raise ImportError(
+                "Unable to import tqdm, please install with `pip install -U tqdm`."
+            ) from e
+        try:
+            import torch
+        except ImportError as e:
+            raise ImportError(
+                "Unable to import torch, please install with `pip install -U torch`."
+            ) from e
+
+        def run_mean_pooling(model_output: Any, attention_mask: Any) -> Any:
+            token_embeddings = model_output[
+                0
+            ]  # First element of model_output contains all token embeddings
+            input_mask_expanded = (
+                attention_mask.unsqueeze(-1).expand(token_embeddings.size()).float()
+            )
+            return torch.sum(token_embeddings * input_mask_expanded, 1) / torch.clamp(
+                input_mask_expanded.sum(1), min=1e-9
+            )
+
+        if convert_to_tensor:
+            convert_to_numpy = False
+
+        input_was_string = False
+        if isinstance(sentences, str) or not hasattr(
+            sentences, "__len__"
+        ):  # Cast an individual sentence to a list with length 1
+            sentences = [sentences]
+            input_was_string = True
+
+        all_embeddings: Any = []
+        length_sorted_idx = np.argsort([-self._text_length(sen) for sen in sentences])
+        sentences_sorted = [sentences[idx] for idx in length_sorted_idx]
+
+        for start_index in trange(
+            0, len(sentences), batch_size, desc="Batches", disable=not show_progress_bar
+        ):
+            sentences_batch = sentences_sorted[start_index : start_index + batch_size]
+
+            length = self.ov_model.request.inputs[0].get_partial_shape()[1]
+            if length.is_dynamic:
+                features = self.tokenizer(
+                    sentences_batch, padding=True, truncation=True, return_tensors="pt"
+                )
+            else:
+                features = self.tokenizer(
+                    sentences_batch,
+                    padding="max_length",
+                    max_length=length.get_length(),
+                    truncation=True,
+                    return_tensors="pt",
+                )
+
+            out_features = self.ov_model(**features)
+            if mean_pooling:
+                embeddings = run_mean_pooling(out_features, features["attention_mask"])
+            else:
+                embeddings = out_features[0][:, 0]
+            if normalize_embeddings:
+                embeddings = torch.nn.functional.normalize(embeddings, p=2, dim=1)
+
+            # fixes for #522 and #487 to avoid oom problems on gpu with large datasets
+            if convert_to_numpy:
+                embeddings = embeddings.cpu()
+
+            all_embeddings.extend(embeddings)
+
+        all_embeddings = [all_embeddings[idx] for idx in np.argsort(length_sorted_idx)]
+
+        if convert_to_tensor:
+            if len(all_embeddings):
+                all_embeddings = torch.stack(all_embeddings)
+            else:
+                all_embeddings = torch.Tensor()
+        elif convert_to_numpy:
+            all_embeddings = np.asarray([emb.numpy() for emb in all_embeddings])
+
+        if input_was_string:
+            all_embeddings = all_embeddings[0]
+
+        return all_embeddings
+
+    model_config = ConfigDict(extra="forbid", protected_namespaces=())
+
+    def embed_documents(self, texts: List[str]) -> List[List[float]]:
+        """Compute doc embeddings using a HuggingFace transformer model.
+
+        Args:
+            texts: The list of texts to embed.
+
+        Returns:
+            List of embeddings, one for each text.
+        """
+
+        texts = list(map(lambda x: x.replace("\n", " "), texts))
+        embeddings = self.encode(
+            texts, show_progress_bar=self.show_progress, **self.encode_kwargs
+        )
+
+        return embeddings.tolist()
+
+    def embed_query(self, text: str) -> List[float]:
+        """Compute query embeddings using a HuggingFace transformer model.
+
+        Args:
+            text: The text to embed.
+
+        Returns:
+            Embeddings for the text.
+        """
+        return self.embed_documents([text])[0]
+
+    def save_model(
+        self,
+        model_path: str,
+    ) -> bool:
+        self.ov_model.half()
+        self.ov_model.save_pretrained(model_path)
+        self.tokenizer.save_pretrained(model_path)
+        return True
+
+
+class OpenVINOBgeEmbeddings(OpenVINOEmbeddings):
+    """OpenVNO BGE embedding models.
+
+    Bge Example:
+        .. code-block:: python
+
+            from langchain_community.embeddings import OpenVINOBgeEmbeddings
+
+            model_name = "BAAI/bge-large-en-v1.5"
+            model_kwargs = {'device': 'CPU'}
+            encode_kwargs = {'normalize_embeddings': True}
+            ov = OpenVINOBgeEmbeddings(
+                model_name_or_path=model_name,
+                model_kwargs=model_kwargs,
+                encode_kwargs=encode_kwargs
+            )
+    """
+
+    query_instruction: str = DEFAULT_QUERY_BGE_INSTRUCTION_EN
+    """Instruction to use for embedding query."""
+    embed_instruction: str = ""
+    """Instruction to use for embedding document."""
+
+    def __init__(self, **kwargs: Any):
+        """Initialize the sentence_transformer."""
+        super().__init__(**kwargs)
+
+        if "-zh" in self.model_name_or_path:
+            self.query_instruction = DEFAULT_QUERY_BGE_INSTRUCTION_ZH
+
+    def embed_documents(self, texts: List[str]) -> List[List[float]]:
+        """Compute doc embeddings using a HuggingFace transformer model.
+
+        Args:
+            texts: The list of texts to embed.
+
+        Returns:
+            List of embeddings, one for each text.
+        """
+        texts = [self.embed_instruction + t.replace("\n", " ") for t in texts]
+        embeddings = self.encode(texts, **self.encode_kwargs)
+        return embeddings.tolist()
+
+    def embed_query(self, text: str) -> List[float]:
+        """Compute query embeddings using a HuggingFace transformer model.
+
+        Args:
+            text: The text to embed.
+
+        Returns:
+            Embeddings for the text.
+        """
+        text = text.replace("\n", " ")
+        embedding = self.encode(self.query_instruction + text, **self.encode_kwargs)
+        return embedding.tolist()

python/user_packages/Python313/site-packages/langchain_community/embeddings/optimum_intel.py

@@ -0,0 +1,208 @@
+from typing import Any, Dict, List, Optional
+
+from langchain_core.embeddings import Embeddings
+from pydantic import BaseModel, ConfigDict
+
+
+class QuantizedBiEncoderEmbeddings(BaseModel, Embeddings):
+    """Quantized bi-encoders embedding models.
+
+    Please ensure that you have installed optimum-intel and ipex.
+
+    Input:
+        model_name: str = Model name.
+        max_seq_len: int = The maximum sequence length for tokenization. (default 512)
+        pooling_strategy: str =
+            "mean" or "cls", pooling strategy for the final layer. (default "mean")
+        query_instruction: Optional[str] =
+            An instruction to add to the query before embedding. (default None)
+        document_instruction: Optional[str] =
+            An instruction to add to each document before embedding. (default None)
+        padding: Optional[bool] =
+            Whether to add padding during tokenization or not. (default True)
+        model_kwargs: Optional[Dict] =
+            Parameters to add to the model during initialization. (default {})
+        encode_kwargs: Optional[Dict] =
+            Parameters to add during the embedding forward pass. (default {})
+
+    Example:
+
+    from langchain_community.embeddings import QuantizedBiEncoderEmbeddings
+
+    model_name = "Intel/bge-small-en-v1.5-rag-int8-static"
+    encode_kwargs = {'normalize_embeddings': True}
+    hf = QuantizedBiEncoderEmbeddings(
+        model_name,
+        encode_kwargs=encode_kwargs,
+        query_instruction="Represent this sentence for searching relevant passages: "
+    )
+    """
+
+    def __init__(
+        self,
+        model_name: str,
+        max_seq_len: int = 512,
+        pooling_strategy: str = "mean",  # "mean" or "cls"
+        query_instruction: Optional[str] = None,
+        document_instruction: Optional[str] = None,
+        padding: bool = True,
+        model_kwargs: Optional[Dict] = None,
+        encode_kwargs: Optional[Dict] = None,
+        **kwargs: Any,
+    ) -> None:
+        super().__init__(**kwargs)
+        self.model_name_or_path = model_name
+        self.max_seq_len = max_seq_len
+        self.pooling = pooling_strategy
+        self.padding = padding
+        self.encode_kwargs = encode_kwargs or {}
+        self.model_kwargs = model_kwargs or {}
+
+        self.normalize = self.encode_kwargs.get("normalize_embeddings", False)
+        self.batch_size = self.encode_kwargs.get("batch_size", 32)
+
+        self.query_instruction = query_instruction
+        self.document_instruction = document_instruction
+
+        self.load_model()
+
+    def load_model(self) -> None:
+        try:
+            from transformers import AutoTokenizer
+        except ImportError as e:
+            raise ImportError(
+                "Unable to import transformers, please install with "
+                "`pip install -U transformers`."
+            ) from e
+        try:
+            from optimum.intel import IPEXModel
+
+            self.transformer_model = IPEXModel.from_pretrained(
+                self.model_name_or_path, **self.model_kwargs
+            )
+        except Exception as e:
+            raise Exception(
+                f"""
+Failed to load model {self.model_name_or_path}, due to the following error:
+{e}
+Please ensure that you have installed optimum-intel and ipex correctly,using:
+
+pip install optimum[neural-compressor]
+pip install intel_extension_for_pytorch
+
+For more information, please visit:
+* Install optimum-intel as shown here: https://github.com/huggingface/optimum-intel.
+* Install IPEX as shown here: https://intel.github.io/intel-extension-for-pytorch/index.html#installation?platform=cpu&version=v2.2.0%2Bcpu.
+"""
+            )
+        self.transformer_tokenizer = AutoTokenizer.from_pretrained(
+            pretrained_model_name_or_path=self.model_name_or_path,
+        )
+        self.transformer_model.eval()
+
+    model_config = ConfigDict(
+        extra="allow",
+        protected_namespaces=(),
+    )
+
+    def _embed(self, inputs: Any) -> Any:
+        try:
+            import torch
+        except ImportError as e:
+            raise ImportError(
+                "Unable to import torch, please install with `pip install -U torch`."
+            ) from e
+        with torch.inference_mode():
+            outputs = self.transformer_model(**inputs)
+            if self.pooling == "mean":
+                emb = self._mean_pooling(outputs, inputs["attention_mask"])
+            elif self.pooling == "cls":
+                emb = self._cls_pooling(outputs)
+            else:
+                raise ValueError("pooling method no supported")
+
+            if self.normalize:
+                emb = torch.nn.functional.normalize(emb, p=2, dim=1)
+            return emb
+
+    @staticmethod
+    def _cls_pooling(outputs: Any) -> Any:
+        if isinstance(outputs, dict):
+            token_embeddings = outputs["last_hidden_state"]
+        else:
+            token_embeddings = outputs[0]
+        return token_embeddings[:, 0]
+
+    @staticmethod
+    def _mean_pooling(outputs: Any, attention_mask: Any) -> Any:
+        try:
+            import torch
+        except ImportError as e:
+            raise ImportError(
+                "Unable to import torch, please install with `pip install -U torch`."
+            ) from e
+        if isinstance(outputs, dict):
+            token_embeddings = outputs["last_hidden_state"]
+        else:
+            # First element of model_output contains all token embeddings
+            token_embeddings = outputs[0]
+        input_mask_expanded = (
+            attention_mask.unsqueeze(-1).expand(token_embeddings.size()).float()
+        )
+        sum_embeddings = torch.sum(token_embeddings * input_mask_expanded, 1)
+        sum_mask = torch.clamp(input_mask_expanded.sum(1), min=1e-9)
+        return sum_embeddings / sum_mask
+
+    def _embed_text(self, texts: List[str]) -> List[List[float]]:
+        inputs = self.transformer_tokenizer(
+            texts,
+            max_length=self.max_seq_len,
+            truncation=True,
+            padding=self.padding,
+            return_tensors="pt",
+        )
+        return self._embed(inputs).tolist()
+
+    def embed_documents(self, texts: List[str]) -> List[List[float]]:
+        """Embed a list of text documents using the Optimized Embedder model.
+
+        Input:
+            texts: List[str] = List of text documents to embed.
+        Output:
+            List[List[float]] = The embeddings of each text document.
+        """
+        try:
+            import pandas as pd
+        except ImportError as e:
+            raise ImportError(
+                "Unable to import pandas, please install with `pip install -U pandas`."
+            ) from e
+        try:
+            from tqdm import tqdm
+        except ImportError as e:
+            raise ImportError(
+                "Unable to import tqdm, please install with `pip install -U tqdm`."
+            ) from e
+        docs = [
+            self.document_instruction + d if self.document_instruction else d
+            for d in texts
+        ]
+
+        # group into batches
+        text_list_df = pd.DataFrame(docs, columns=["texts"]).reset_index()
+
+        # assign each example with its batch
+        text_list_df["batch_index"] = text_list_df["index"] // self.batch_size
+
+        # create groups
+        batches = list(text_list_df.groupby(["batch_index"])["texts"].apply(list))
+
+        vectors = []
+        for batch in tqdm(batches, desc="Batches"):
+            vectors += self._embed_text(batch)
+        return vectors
+
+    def embed_query(self, text: str) -> List[float]:
+        if self.query_instruction:
+            text = self.query_instruction + text
+        return self._embed_text([text])[0]

python/user_packages/Python313/site-packages/langchain_community/embeddings/oracleai.py

@@ -0,0 +1,194 @@
+# Authors:
+#   Harichandan Roy (hroy)
+#   David Jiang (ddjiang)
+#
+# -----------------------------------------------------------------------------
+# oracleai.py
+# -----------------------------------------------------------------------------
+
+from __future__ import annotations
+
+import json
+import logging
+import traceback
+from typing import TYPE_CHECKING, Any, Dict, List, Optional
+
+from langchain_core.embeddings import Embeddings
+from pydantic import BaseModel, ConfigDict
+
+if TYPE_CHECKING:
+    from oracledb import Connection
+
+logger = logging.getLogger(__name__)
+
+"""OracleEmbeddings class"""
+
+
+class OracleEmbeddings(BaseModel, Embeddings):
+    """Get Embeddings"""
+
+    """Oracle Connection"""
+    conn: Any = None
+    """Embedding Parameters"""
+    params: Dict[str, Any]
+    """Proxy"""
+    proxy: Optional[str] = None
+
+    def __init__(self, **kwargs: Any):
+        super().__init__(**kwargs)
+
+    model_config = ConfigDict(
+        extra="forbid",
+    )
+
+    """
+    1 - user needs to have create procedure, 
+        create mining model, create any directory privilege.
+    2 - grant create procedure, create mining model, 
+        create any directory to <user>;
+    """
+
+    @staticmethod
+    def load_onnx_model(
+        conn: Connection, dir: str, onnx_file: str, model_name: str
+    ) -> None:
+        """Load an ONNX model to Oracle Database.
+        Args:
+            conn: Oracle Connection,
+            dir: Oracle Directory,
+            onnx_file: ONNX file name,
+            model_name: Name of the model.
+        """
+
+        try:
+            if conn is None or dir is None or onnx_file is None or model_name is None:
+                raise Exception("Invalid input")
+
+            cursor = conn.cursor()
+            cursor.execute(
+                """
+                begin
+                    dbms_data_mining.drop_model(model_name => :model, force => true);
+                    SYS.DBMS_VECTOR.load_onnx_model(:path, :filename, :model, 
+                        json('{"function" : "embedding", 
+                            "embeddingOutput" : "embedding", 
+                            "input": {"input": ["DATA"]}}'));
+                end;""",
+                path=dir,
+                filename=onnx_file,
+                model=model_name,
+            )
+
+            cursor.close()
+
+        except Exception as ex:
+            logger.info(f"An exception occurred :: {ex}")
+            traceback.print_exc()
+            cursor.close()
+            raise
+
+    def embed_documents(self, texts: List[str]) -> List[List[float]]:
+        """Compute doc embeddings using an OracleEmbeddings.
+        Args:
+            texts: The list of texts to embed.
+        Returns:
+            List of embeddings, one for each input text.
+        """
+
+        try:
+            import oracledb
+        except ImportError as e:
+            raise ImportError(
+                "Unable to import oracledb, please install with "
+                "`pip install -U oracledb`."
+            ) from e
+
+        if texts is None:
+            return None
+
+        embeddings: List[List[float]] = []
+        try:
+            # returns strings or bytes instead of a locator
+            oracledb.defaults.fetch_lobs = False
+            cursor = self.conn.cursor()
+
+            if self.proxy:
+                cursor.execute(
+                    "begin utl_http.set_proxy(:proxy); end;", proxy=self.proxy
+                )
+
+            chunks = []
+            for i, text in enumerate(texts, start=1):
+                chunk = {"chunk_id": i, "chunk_data": text}
+                chunks.append(json.dumps(chunk))
+
+            vector_array_type = self.conn.gettype("SYS.VECTOR_ARRAY_T")
+            inputs = vector_array_type.newobject(chunks)
+            cursor.execute(
+                "select t.* "
+                + "from dbms_vector_chain.utl_to_embeddings(:content, "
+                + "json(:params)) t",
+                content=inputs,
+                params=json.dumps(self.params),
+            )
+
+            for row in cursor:
+                if row is None:
+                    embeddings.append([])
+                else:
+                    rdata = json.loads(row[0])
+                    # dereference string as array
+                    vec = json.loads(rdata["embed_vector"])
+                    embeddings.append(vec)
+
+            cursor.close()
+            return embeddings
+        except Exception as ex:
+            logger.info(f"An exception occurred :: {ex}")
+            traceback.print_exc()
+            cursor.close()
+            raise
+
+    def embed_query(self, text: str) -> List[float]:
+        """Compute query embedding using an OracleEmbeddings.
+        Args:
+            text: The text to embed.
+        Returns:
+            Embedding for the text.
+        """
+        return self.embed_documents([text])[0]
+
+
+# uncomment the following code block to run the test
+
+"""
+# A sample unit test.
+
+import oracledb
+# get the Oracle connection 
+conn = oracledb.connect(
+    user="<user>",
+    password="<password>",
+    dsn="<hostname>/<service_name>",
+)
+print("Oracle connection is established...")
+
+# params 
+embedder_params = {"provider": "database", "model": "demo_model"}
+proxy = ""
+
+# instance
+embedder = OracleEmbeddings(conn=conn, params=embedder_params, proxy=proxy)
+
+docs = ["hello world!", "hi everyone!", "greetings!"]
+embeds = embedder.embed_documents(docs)
+print(f"Total Embeddings: {len(embeds)}")
+print(f"Embedding generated by OracleEmbeddings: {embeds[0]}\n")
+
+embed = embedder.embed_query("Hello World!")
+print(f"Embedding generated by OracleEmbeddings: {embed}")
+
+conn.close()
+print("Connection is closed.")
+
+"""

python/user_packages/Python313/site-packages/langchain_community/embeddings/ovhcloud.py

@@ -0,0 +1,115 @@
+import json
+import logging
+import time
+from typing import Any, List
+
+import requests
+from langchain_core.embeddings import Embeddings
+from pydantic import BaseModel, ConfigDict
+
+logger = logging.getLogger(__name__)
+
+
+class OVHCloudEmbeddings(BaseModel, Embeddings):
+    """
+    OVHcloud AI Endpoints Embeddings.
+    """
+
+    """ OVHcloud AI Endpoints Access Token"""
+    access_token: str = ""
+
+    """ OVHcloud AI Endpoints model name for embeddings generation"""
+    model_name: str = ""
+
+    """ OVHcloud AI Endpoints region"""
+    region: str = "kepler"
+
+    model_config = ConfigDict(extra="forbid", protected_namespaces=())
+
+    def __init__(self, **kwargs: Any):
+        super().__init__(**kwargs)
+        if self.access_token == "":
+            raise ValueError("Access token is required for OVHCloud embeddings.")
+        if self.model_name == "":
+            raise ValueError("Model name is required for OVHCloud embeddings.")
+        if self.region == "":
+            raise ValueError("Region is required for OVHCloud embeddings.")
+
+    def _generate_embedding(self, text: str) -> List[float]:
+        """Generate embeddings from OVHCLOUD AIE.
+        Args:
+            text (str): The text to embed.
+        Returns:
+            List[float]: Embeddings for the text.
+        """
+
+        return self._send_request_to_ai_endpoints("text/plain", text, "text2vec")
+
+    def embed_documents(self, texts: List[str]) -> List[List[float]]:
+        """Embed a list of documents.
+        Args:
+           texts (List[str]): The list of texts to embed.
+
+        Returns:
+           List[List[float]]: List of embeddings, one for each input text.
+
+        """
+
+        return self._send_request_to_ai_endpoints(
+            "application/json", json.dumps(texts), "batch_text2vec"
+        )
+
+    def embed_query(self, text: str) -> List[float]:
+        """Embed a single query text.
+        Args:
+            text (str): The text to embed.
+        Returns:
+            List[float]: Embeddings for the text.
+        """
+        return self._generate_embedding(text)
+
+    def _send_request_to_ai_endpoints(
+        self, contentType: str, payload: str, route: str
+    ) -> Any:
+        """Send a HTTPS request to OVHcloud AI Endpoints
+        Args:
+            contentType (str): The content type of the request, application/json or text/plain.
+            payload (str): The payload of the request.
+            route (str): The route of the request, batch_text2vec or text2vec.
+        """  # noqa: E501
+        headers = {
+            "content-type": contentType,
+            "Authorization": f"Bearer {self.access_token}",
+        }
+
+        session = requests.session()
+        while True:
+            response = session.post(
+                (
+                    f"https://{self.model_name}.endpoints.{self.region}"
+                    f".ai.cloud.ovh.net/api/{route}"
+                ),
+                headers=headers,
+                data=payload,
+            )
+            if response.status_code != 200:
+                if response.status_code == 429:
+                    """Rate limit exceeded, wait for reset"""
+                    reset_time = int(response.headers.get("RateLimit-Reset", 0))
+                    logger.info("Rate limit exceeded. Waiting %d seconds.", reset_time)
+                    if reset_time > 0:
+                        time.sleep(reset_time)
+                        continue
+                    else:
+                        """Rate limit reset time has passed, retry immediately"""
+                        continue
+                if response.status_code == 401:
+                    """ Unauthorized, retry with new token """
+                    raise ValueError("Unauthorized, retry with new token")
+                """ Handle other non-200 status codes """
+                raise ValueError(
+                    "Request failed with status code: {status_code}, {text}".format(
+                        status_code=response.status_code, text=response.text
+                    )
+                )
+            return response.json()

python/user_packages/Python313/site-packages/langchain_community/embeddings/premai.py

@@ -0,0 +1,130 @@
+from __future__ import annotations
+
+import logging
+from typing import Any, Callable, Dict, List, Optional, Union
+
+from langchain_core.embeddings import Embeddings
+from langchain_core.language_models.llms import create_base_retry_decorator
+from langchain_core.utils import get_from_dict_or_env, pre_init
+from pydantic import BaseModel, SecretStr
+
+logger = logging.getLogger(__name__)
+
+
+class PremAIEmbeddings(BaseModel, Embeddings):
+    """Prem's Embedding APIs"""
+
+    project_id: int
+    """The project ID in which the experiments or deployments are carried out. 
+    You can find all your projects here: https://app.premai.io/projects/"""
+
+    premai_api_key: Optional[SecretStr] = None
+    """Prem AI API Key. Get it here: https://app.premai.io/api_keys/"""
+
+    model: str
+    """The Embedding model to choose from"""
+
+    show_progress_bar: bool = False
+    """Whether to show a tqdm progress bar. Must have `tqdm` installed."""
+
+    max_retries: int = 1
+    """Max number of retries for tenacity"""
+
+    client: Any
+
+    @pre_init
+    def validate_environments(cls, values: Dict) -> Dict:
+        """Validate that the package is installed and that the API token is valid"""
+        try:
+            from premai import Prem
+        except ImportError as error:
+            raise ImportError(
+                "Could not import Prem Python package."
+                "Please install it with: `pip install premai`"
+            ) from error
+
+        try:
+            premai_api_key = get_from_dict_or_env(
+                values, "premai_api_key", "PREMAI_API_KEY"
+            )
+            values["client"] = Prem(api_key=premai_api_key)
+        except Exception as error:
+            raise ValueError("Your API Key is incorrect. Please try again.") from error
+        return values
+
+    def embed_query(self, text: str) -> List[float]:
+        """Embed query text"""
+        embeddings = embed_with_retry(
+            self, model=self.model, project_id=self.project_id, input=text
+        )
+        return embeddings.data[0].embedding
+
+    def embed_documents(self, texts: List[str]) -> List[List[float]]:
+        embeddings = embed_with_retry(
+            self, model=self.model, project_id=self.project_id, input=texts
+        ).data
+
+        return [embedding.embedding for embedding in embeddings]
+
+
+def create_prem_retry_decorator(
+    embedder: PremAIEmbeddings,
+    *,
+    max_retries: int = 1,
+) -> Callable[[Any], Any]:
+    """Create a retry decorator for PremAIEmbeddings.
+
+    Args:
+        embedder (PremAIEmbeddings): The PremAIEmbeddings instance
+        max_retries (int): The maximum number of retries
+
+    Returns:
+        Callable[[Any], Any]: The retry decorator
+    """
+    import premai.models
+
+    errors = [
+        premai.models.api_response_validation_error.APIResponseValidationError,
+        premai.models.conflict_error.ConflictError,
+        premai.models.model_not_found_error.ModelNotFoundError,
+        premai.models.permission_denied_error.PermissionDeniedError,
+        premai.models.provider_api_connection_error.ProviderAPIConnectionError,
+        premai.models.provider_api_status_error.ProviderAPIStatusError,
+        premai.models.provider_api_timeout_error.ProviderAPITimeoutError,
+        premai.models.provider_internal_server_error.ProviderInternalServerError,
+        premai.models.provider_not_found_error.ProviderNotFoundError,
+        premai.models.rate_limit_error.RateLimitError,
+        premai.models.unprocessable_entity_error.UnprocessableEntityError,
+        premai.models.validation_error.ValidationError,
+    ]
+
+    decorator = create_base_retry_decorator(
+        error_types=errors, max_retries=max_retries, run_manager=None
+    )
+    return decorator
+
+
+def embed_with_retry(
+    embedder: PremAIEmbeddings,
+    model: str,
+    project_id: int,
+    input: Union[str, List[str]],
+) -> Any:
+    """Using tenacity for retry in embedding calls"""
+    retry_decorator = create_prem_retry_decorator(
+        embedder, max_retries=embedder.max_retries
+    )
+
+    @retry_decorator
+    def _embed_with_retry(
+        embedder: PremAIEmbeddings,
+        project_id: int,
+        model: str,
+        input: Union[str, List[str]],
+    ) -> Any:
+        embedding_response = embedder.client.embeddings.create(
+            project_id=project_id, model=model, input=input
+        )
+        return embedding_response
+
+    return _embed_with_retry(embedder, project_id=project_id, model=model, input=input)

python/user_packages/Python313/site-packages/langchain_community/embeddings/sagemaker_endpoint.py

@@ -0,0 +1,210 @@
+from typing import Any, Dict, List, Optional
+
+from langchain_core.embeddings import Embeddings
+from langchain_core.utils import pre_init
+from pydantic import BaseModel, ConfigDict
+
+from langchain_community.llms.sagemaker_endpoint import ContentHandlerBase
+
+
+class EmbeddingsContentHandler(ContentHandlerBase[List[str], List[List[float]]]):
+    """Content handler for LLM class."""
+
+
+class SagemakerEndpointEmbeddings(BaseModel, Embeddings):
+    """Custom Sagemaker Inference Endpoints.
+
+    To use, you must supply the endpoint name from your deployed
+    Sagemaker model & the region where it is deployed.
+
+    To authenticate, the AWS client uses the following methods to
+    automatically load credentials:
+    https://boto3.amazonaws.com/v1/documentation/api/latest/guide/credentials.html
+
+    If a specific credential profile should be used, you must pass
+    the name of the profile from the ~/.aws/credentials file that is to be used.
+
+    Make sure the credentials / roles used have the required policies to
+    access the Sagemaker endpoint.
+    See: https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html
+    """
+
+    """
+    Example:
+        .. code-block:: python
+
+            from langchain_community.embeddings import SagemakerEndpointEmbeddings
+            endpoint_name = (
+                "my-endpoint-name"
+            )
+            region_name = (
+                "us-west-2"
+            )
+            credentials_profile_name = (
+                "default"
+            )
+            se = SagemakerEndpointEmbeddings(
+                endpoint_name=endpoint_name,
+                region_name=region_name,
+                credentials_profile_name=credentials_profile_name
+            )
+
+            #Use with boto3 client
+            client = boto3.client(
+                        "sagemaker-runtime",
+                        region_name=region_name
+                    )
+            se = SagemakerEndpointEmbeddings(
+                endpoint_name=endpoint_name,
+                client=client
+            )
+    """
+    client: Any = None
+
+    endpoint_name: str = ""
+    """The name of the endpoint from the deployed Sagemaker model.
+    Must be unique within an AWS Region."""
+
+    region_name: str = ""
+    """The aws region where the Sagemaker model is deployed, eg. `us-west-2`."""
+
+    credentials_profile_name: Optional[str] = None
+    """The name of the profile in the ~/.aws/credentials or ~/.aws/config files, which
+    has either access keys or role information specified.
+    If not specified, the default credential profile or, if on an EC2 instance,
+    credentials from IMDS will be used.
+    See: https://boto3.amazonaws.com/v1/documentation/api/latest/guide/credentials.html
+    """
+
+    content_handler: EmbeddingsContentHandler
+    """The content handler class that provides an input and
+    output transform functions to handle formats between LLM
+    and the endpoint.
+    """
+
+    """
+     Example:
+        .. code-block:: python
+
+        from langchain_community.embeddings.sagemaker_endpoint import EmbeddingsContentHandler
+
+        class ContentHandler(EmbeddingsContentHandler):
+                content_type = "application/json"
+                accepts = "application/json"
+
+                def transform_input(self, prompts: List[str], model_kwargs: Dict) -> bytes:
+                    input_str = json.dumps({prompts: prompts, **model_kwargs})
+                    return input_str.encode('utf-8')
+
+                def transform_output(self, output: bytes) -> List[List[float]]:
+                    response_json = json.loads(output.read().decode("utf-8"))
+                    return response_json["vectors"]
+    """  # noqa: E501
+
+    model_kwargs: Optional[Dict] = None
+    """Keyword arguments to pass to the model."""
+
+    endpoint_kwargs: Optional[Dict] = None
+    """Optional attributes passed to the invoke_endpoint
+    function. See `boto3`_. docs for more info.
+    .. _boto3: <https://boto3.amazonaws.com/v1/documentation/api/latest/index.html>
+    """
+
+    model_config = ConfigDict(
+        arbitrary_types_allowed=True, extra="forbid", protected_namespaces=()
+    )
+
+    @pre_init
+    def validate_environment(cls, values: Dict) -> Dict:
+        """Dont do anything if client provided externally"""
+        if values.get("client") is not None:
+            return values
+
+        """Validate that AWS credentials to and python package exists in environment."""
+        try:
+            import boto3
+
+            try:
+                if values["credentials_profile_name"] is not None:
+                    session = boto3.Session(
+                        profile_name=values["credentials_profile_name"]
+                    )
+                else:
+                    # use default credentials
+                    session = boto3.Session()
+
+                values["client"] = session.client(
+                    "sagemaker-runtime", region_name=values["region_name"]
+                )
+
+            except Exception as e:
+                raise ValueError(
+                    "Could not load credentials to authenticate with AWS client. "
+                    "Please check that credentials in the specified "
+                    f"profile name are valid. {e}"
+                ) from e
+
+        except ImportError:
+            raise ImportError(
+                "Could not import boto3 python package. "
+                "Please install it with `pip install boto3`."
+            )
+        return values
+
+    def _embedding_func(self, texts: List[str]) -> List[List[float]]:
+        """Call out to SageMaker Inference embedding endpoint."""
+        # replace newlines, which can negatively affect performance.
+        texts = list(map(lambda x: x.replace("\n", " "), texts))
+        _model_kwargs = self.model_kwargs or {}
+        _endpoint_kwargs = self.endpoint_kwargs or {}
+
+        body = self.content_handler.transform_input(texts, _model_kwargs)
+        content_type = self.content_handler.content_type
+        accepts = self.content_handler.accepts
+
+        # send request
+        try:
+            response = self.client.invoke_endpoint(
+                EndpointName=self.endpoint_name,
+                Body=body,
+                ContentType=content_type,
+                Accept=accepts,
+                **_endpoint_kwargs,
+            )
+        except Exception as e:
+            raise ValueError(f"Error raised by inference endpoint: {e}")
+
+        return self.content_handler.transform_output(response["Body"])
+
+    def embed_documents(
+        self, texts: List[str], chunk_size: int = 64
+    ) -> List[List[float]]:
+        """Compute doc embeddings using a SageMaker Inference Endpoint.
+
+        Args:
+            texts: The list of texts to embed.
+            chunk_size: The chunk size defines how many input texts will
+                be grouped together as request. If None, will use the
+                chunk size specified by the class.
+
+
+        Returns:
+            List of embeddings, one for each text.
+        """
+        results = []
+        _chunk_size = len(texts) if chunk_size > len(texts) else chunk_size
+        for i in range(0, len(texts), _chunk_size):
+            response = self._embedding_func(texts[i : i + _chunk_size])
+            results.extend(response)
+        return results
+
+    def embed_query(self, text: str) -> List[float]:
+        """Compute query embeddings using a SageMaker inference endpoint.
+
+        Args:
+            text: The text to embed.
+
+        Returns:
+            Embeddings for the text.
+        """
+        return self._embedding_func([text])[0]

python/user_packages/Python313/site-packages/langchain_community/embeddings/sambanova.py

@@ -0,0 +1,324 @@
+import json
+from typing import Dict, Generator, List, Optional
+
+import requests
+from langchain_core._api.deprecation import deprecated
+from langchain_core.embeddings import Embeddings
+from langchain_core.utils import get_from_dict_or_env, pre_init
+from pydantic import BaseModel, ConfigDict
+
+
+@deprecated(
+    since="0.3.16",
+    removal="1.0",
+    alternative_import="langchain_sambanova.SambaStudioEmbeddings",
+)
+class SambaStudioEmbeddings(BaseModel, Embeddings):
+    """SambaNova embedding models.
+
+    To use, you should have the environment variables
+    ``SAMBASTUDIO_EMBEDDINGS_BASE_URL``, ``SAMBASTUDIO_EMBEDDINGS_BASE_URI``
+    ``SAMBASTUDIO_EMBEDDINGS_PROJECT_ID``, ``SAMBASTUDIO_EMBEDDINGS_ENDPOINT_ID``,
+    ``SAMBASTUDIO_EMBEDDINGS_API_KEY``
+    set with your personal sambastudio variable or pass it as a named parameter
+    to the constructor.
+
+    Example:
+        .. code-block:: python
+
+            from langchain_community.embeddings import SambaStudioEmbeddings
+
+            embeddings = SambaStudioEmbeddings(sambastudio_embeddings_base_url=base_url,
+                                          sambastudio_embeddings_base_uri=base_uri,
+                                          sambastudio_embeddings_project_id=project_id,
+                                          sambastudio_embeddings_endpoint_id=endpoint_id,
+                                          sambastudio_embeddings_api_key=api_key,
+                                          batch_size=32)
+            (or)
+
+            embeddings = SambaStudioEmbeddings(batch_size=32)
+
+            (or)
+
+            # CoE example
+            embeddings = SambaStudioEmbeddings(
+                batch_size=1,
+                model_kwargs={
+                    'select_expert':'e5-mistral-7b-instruct'
+                }
+            )
+    """
+
+    sambastudio_embeddings_base_url: str = ""
+    """Base url to use"""
+
+    sambastudio_embeddings_base_uri: str = ""
+    """endpoint base uri"""
+
+    sambastudio_embeddings_project_id: str = ""
+    """Project id on sambastudio for model"""
+
+    sambastudio_embeddings_endpoint_id: str = ""
+    """endpoint id on sambastudio for model"""
+
+    sambastudio_embeddings_api_key: str = ""
+    """sambastudio api key"""
+
+    model_kwargs: dict = {}
+    """Key word arguments to pass to the model."""
+
+    batch_size: int = 32
+    """Batch size for the embedding models"""
+
+    model_config = ConfigDict(protected_namespaces=())
+
+    @pre_init
+    def validate_environment(cls, values: Dict) -> Dict:
+        """Validate that api key and python package exists in environment."""
+        values["sambastudio_embeddings_base_url"] = get_from_dict_or_env(
+            values, "sambastudio_embeddings_base_url", "SAMBASTUDIO_EMBEDDINGS_BASE_URL"
+        )
+        values["sambastudio_embeddings_base_uri"] = get_from_dict_or_env(
+            values,
+            "sambastudio_embeddings_base_uri",
+            "SAMBASTUDIO_EMBEDDINGS_BASE_URI",
+            default="api/predict/generic",
+        )
+        values["sambastudio_embeddings_project_id"] = get_from_dict_or_env(
+            values,
+            "sambastudio_embeddings_project_id",
+            "SAMBASTUDIO_EMBEDDINGS_PROJECT_ID",
+        )
+        values["sambastudio_embeddings_endpoint_id"] = get_from_dict_or_env(
+            values,
+            "sambastudio_embeddings_endpoint_id",
+            "SAMBASTUDIO_EMBEDDINGS_ENDPOINT_ID",
+        )
+        values["sambastudio_embeddings_api_key"] = get_from_dict_or_env(
+            values, "sambastudio_embeddings_api_key", "SAMBASTUDIO_EMBEDDINGS_API_KEY"
+        )
+        return values
+
+    def _get_tuning_params(self) -> str:
+        """
+        Get the tuning parameters to use when calling the model
+
+        Returns:
+            The tuning parameters as a JSON string.
+        """
+        if "api/v2/predict/generic" in self.sambastudio_embeddings_base_uri:
+            tuning_params_dict = self.model_kwargs
+        else:
+            tuning_params_dict = {
+                k: {"type": type(v).__name__, "value": str(v)}
+                for k, v in (self.model_kwargs.items())
+            }
+        tuning_params = json.dumps(tuning_params_dict)
+        return tuning_params
+
+    def _get_full_url(self, path: str) -> str:
+        """
+        Return the full API URL for a given path.
+
+        :param str path: the sub-path
+        :returns: the full API URL for the sub-path
+        :rtype: str
+        """
+        return f"{self.sambastudio_embeddings_base_url}/{self.sambastudio_embeddings_base_uri}/{path}"  # noqa: E501
+
+    def _iterate_over_batches(self, texts: List[str], batch_size: int) -> Generator:
+        """Generator for creating batches in the embed documents method
+        Args:
+            texts (List[str]): list of strings to embed
+            batch_size (int, optional): batch size to be used for the embedding model.
+            Will depend on the RDU endpoint used.
+        Yields:
+            List[str]: list (batch) of strings of size batch size
+        """
+        for i in range(0, len(texts), batch_size):
+            yield texts[i : i + batch_size]
+
+    def embed_documents(
+        self, texts: List[str], batch_size: Optional[int] = None
+    ) -> List[List[float]]:
+        """Returns a list of embeddings for the given sentences.
+        Args:
+            texts (`List[str]`): List of texts to encode
+            batch_size (`int`): Batch size for the encoding
+
+        Returns:
+            `List[np.ndarray]` or `List[tensor]`: List of embeddings
+            for the given sentences
+        """
+        if batch_size is None:
+            batch_size = self.batch_size
+        http_session = requests.Session()
+        url = self._get_full_url(
+            f"{self.sambastudio_embeddings_project_id}/{self.sambastudio_embeddings_endpoint_id}"
+        )
+        params = json.loads(self._get_tuning_params())
+        embeddings = []
+
+        if "api/predict/nlp" in self.sambastudio_embeddings_base_uri:
+            for batch in self._iterate_over_batches(texts, batch_size):
+                data = {"inputs": batch, "params": params}
+                response = http_session.post(
+                    url,
+                    headers={"key": self.sambastudio_embeddings_api_key},
+                    json=data,
+                )
+                if response.status_code != 200:
+                    raise RuntimeError(
+                        f"Sambanova /complete call failed with status code "
+                        f"{response.status_code}.\n Details: {response.text}"
+                    )
+                try:
+                    embedding = response.json()["data"]
+                    embeddings.extend(embedding)
+                except KeyError:
+                    raise KeyError(
+                        "'data' not found in endpoint response",
+                        response.json(),
+                    )
+
+        elif "api/v2/predict/generic" in self.sambastudio_embeddings_base_uri:
+            for batch in self._iterate_over_batches(texts, batch_size):
+                items = [
+                    {"id": f"item{i}", "value": item} for i, item in enumerate(batch)
+                ]
+                data = {"items": items, "params": params}
+                response = http_session.post(
+                    url,
+                    headers={"key": self.sambastudio_embeddings_api_key},
+                    json=data,
+                )
+                if response.status_code != 200:
+                    raise RuntimeError(
+                        f"Sambanova /complete call failed with status code "
+                        f"{response.status_code}.\n Details: {response.text}"
+                    )
+                try:
+                    embedding = [item["value"] for item in response.json()["items"]]
+                    embeddings.extend(embedding)
+                except KeyError:
+                    raise KeyError(
+                        "'items' not found in endpoint response",
+                        response.json(),
+                    )
+
+        elif "api/predict/generic" in self.sambastudio_embeddings_base_uri:
+            for batch in self._iterate_over_batches(texts, batch_size):
+                data = {"instances": batch, "params": params}
+                response = http_session.post(
+                    url,
+                    headers={"key": self.sambastudio_embeddings_api_key},
+                    json=data,
+                )
+                if response.status_code != 200:
+                    raise RuntimeError(
+                        f"Sambanova /complete call failed with status code "
+                        f"{response.status_code}.\n Details: {response.text}"
+                    )
+                try:
+                    if params.get("select_expert"):
+                        embedding = response.json()["predictions"]
+                    else:
+                        embedding = response.json()["predictions"]
+                    embeddings.extend(embedding)
+                except KeyError:
+                    raise KeyError(
+                        "'predictions' not found in endpoint response",
+                        response.json(),
+                    )
+
+        else:
+            raise ValueError(
+                f"handling of endpoint uri: {self.sambastudio_embeddings_base_uri} not implemented"  # noqa: E501
+            )
+
+        return embeddings
+
+    def embed_query(self, text: str) -> List[float]:
+        """Returns a list of embeddings for the given sentences.
+        Args:
+            sentences (`List[str]`): List of sentences to encode
+
+        Returns:
+            `List[np.ndarray]` or `List[tensor]`: List of embeddings
+            for the given sentences
+        """
+        http_session = requests.Session()
+        url = self._get_full_url(
+            f"{self.sambastudio_embeddings_project_id}/{self.sambastudio_embeddings_endpoint_id}"
+        )
+        params = json.loads(self._get_tuning_params())
+
+        if "api/predict/nlp" in self.sambastudio_embeddings_base_uri:
+            data = {"inputs": [text], "params": params}
+            response = http_session.post(
+                url,
+                headers={"key": self.sambastudio_embeddings_api_key},
+                json=data,
+            )
+            if response.status_code != 200:
+                raise RuntimeError(
+                    f"Sambanova /complete call failed with status code "
+                    f"{response.status_code}.\n Details: {response.text}"
+                )
+            try:
+                embedding = response.json()["data"][0]
+            except KeyError:
+                raise KeyError(
+                    "'data' not found in endpoint response",
+                    response.json(),
+                )
+
+        elif "api/v2/predict/generic" in self.sambastudio_embeddings_base_uri:
+            data = {"items": [{"id": "item0", "value": text}], "params": params}
+            response = http_session.post(
+                url,
+                headers={"key": self.sambastudio_embeddings_api_key},
+                json=data,
+            )
+            if response.status_code != 200:
+                raise RuntimeError(
+                    f"Sambanova /complete call failed with status code "
+                    f"{response.status_code}.\n Details: {response.text}"
+                )
+            try:
+                embedding = response.json()["items"][0]["value"]
+            except KeyError:
+                raise KeyError(
+                    "'items' not found in endpoint response",
+                    response.json(),
+                )
+
+        elif "api/predict/generic" in self.sambastudio_embeddings_base_uri:
+            data = {"instances": [text], "params": params}
+            response = http_session.post(
+                url,
+                headers={"key": self.sambastudio_embeddings_api_key},
+                json=data,
+            )
+            if response.status_code != 200:
+                raise RuntimeError(
+                    f"Sambanova /complete call failed with status code "
+                    f"{response.status_code}.\n Details: {response.text}"
+                )
+            try:
+                if params.get("select_expert"):
+                    embedding = response.json()["predictions"][0]
+                else:
+                    embedding = response.json()["predictions"][0]
+            except KeyError:
+                raise KeyError(
+                    "'predictions' not found in endpoint response",
+                    response.json(),
+                )
+
+        else:
+            raise ValueError(
+                f"handling of endpoint uri: {self.sambastudio_embeddings_base_uri} not implemented"  # noqa: E501
+            )
+
+        return embedding

python/user_packages/Python313/site-packages/langchain_community/embeddings/self_hosted.py

@@ -0,0 +1,101 @@
+from typing import Any, Callable, List
+
+from langchain_core.embeddings import Embeddings
+from pydantic import ConfigDict
+
+from langchain_community.llms.self_hosted import SelfHostedPipeline
+
+
+def _embed_documents(pipeline: Any, *args: Any, **kwargs: Any) -> List[List[float]]:
+    """Inference function to send to the remote hardware.
+
+    Accepts a sentence_transformer model_id and
+    returns a list of embeddings for each document in the batch.
+    """
+    return pipeline(*args, **kwargs)
+
+
+class SelfHostedEmbeddings(SelfHostedPipeline, Embeddings):
+    """Custom embedding models on self-hosted remote hardware.
+
+    Supported hardware includes auto-launched instances on AWS, GCP, Azure,
+    and Lambda, as well as servers specified
+    by IP address and SSH credentials (such as on-prem, or another
+    cloud like Paperspace, Coreweave, etc.).
+
+    To use, you should have the ``runhouse`` python package installed.
+
+    Example using a model load function:
+        .. code-block:: python
+
+            from langchain_community.embeddings import SelfHostedEmbeddings
+            from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline
+            import runhouse as rh
+
+            gpu = rh.cluster(name="rh-a10x", instance_type="A100:1")
+            def get_pipeline():
+                model_id = "facebook/bart-large"
+                tokenizer = AutoTokenizer.from_pretrained(model_id)
+                model = AutoModelForCausalLM.from_pretrained(model_id)
+                return pipeline("feature-extraction", model=model, tokenizer=tokenizer)
+            embeddings = SelfHostedEmbeddings(
+                model_load_fn=get_pipeline,
+                hardware=gpu
+                model_reqs=["./", "torch", "transformers"],
+            )
+    Example passing in a pipeline path:
+        .. code-block:: python
+
+            from langchain_community.embeddings import SelfHostedHFEmbeddings
+            import runhouse as rh
+            from transformers import pipeline
+
+            gpu = rh.cluster(name="rh-a10x", instance_type="A100:1")
+            pipeline = pipeline(model="bert-base-uncased", task="feature-extraction")
+            rh.blob(pickle.dumps(pipeline),
+                path="models/pipeline.pkl").save().to(gpu, path="models")
+            embeddings = SelfHostedHFEmbeddings.from_pipeline(
+                pipeline="models/pipeline.pkl",
+                hardware=gpu,
+                model_reqs=["./", "torch", "transformers"],
+            )
+    """
+
+    inference_fn: Callable = _embed_documents
+    """Inference function to extract the embeddings on the remote hardware."""
+    inference_kwargs: Any = None
+    """Any kwargs to pass to the model's inference function."""
+
+    model_config = ConfigDict(
+        extra="forbid",
+    )
+
+    def embed_documents(self, texts: List[str]) -> List[List[float]]:
+        """Compute doc embeddings using a HuggingFace transformer model.
+
+        Args:
+            texts: The list of texts to embed.s
+
+        Returns:
+            List of embeddings, one for each text.
+        """
+        texts = list(map(lambda x: x.replace("\n", " "), texts))
+        embeddings = self.client(self.pipeline_ref, texts)
+        if not isinstance(embeddings, list):
+            return embeddings.tolist()
+        return embeddings
+
+    def embed_query(self, text: str) -> List[float]:
+        """Compute query embeddings using a HuggingFace transformer model.
+
+        Args:
+            text: The text to embed.
+
+        Returns:
+            Embeddings for the text.
+        """
+        text = text.replace("\n", " ")
+        embeddings = self.client(self.pipeline_ref, text)
+        if not isinstance(embeddings, list):
+            return embeddings.tolist()
+        return embeddings

python/user_packages/Python313/site-packages/langchain_community/embeddings/self_hosted_hugging_face.py

@@ -0,0 +1,168 @@
+import importlib
+import logging
+from typing import Any, Callable, List, Optional
+
+from langchain_community.embeddings.self_hosted import SelfHostedEmbeddings
+
+DEFAULT_MODEL_NAME = "sentence-transformers/all-mpnet-base-v2"
+DEFAULT_INSTRUCT_MODEL = "hkunlp/instructor-large"
+DEFAULT_EMBED_INSTRUCTION = "Represent the document for retrieval: "
+DEFAULT_QUERY_INSTRUCTION = (
+    "Represent the question for retrieving supporting documents: "
+)
+
+logger = logging.getLogger(__name__)
+
+
+def _embed_documents(client: Any, *args: Any, **kwargs: Any) -> List[List[float]]:
+    """Inference function to send to the remote hardware.
+
+    Accepts a sentence_transformer model_id and
+    returns a list of embeddings for each document in the batch.
+    """
+    return client.encode(*args, **kwargs)
+
+
+def load_embedding_model(model_id: str, instruct: bool = False, device: int = 0) -> Any:
+    """Load the embedding model."""
+    if not instruct:
+        import sentence_transformers
+
+        client = sentence_transformers.SentenceTransformer(model_id)
+    else:
+        from InstructorEmbedding import INSTRUCTOR
+
+        client = INSTRUCTOR(model_id)
+
+    if importlib.util.find_spec("torch") is not None:
+        import torch
+
+        cuda_device_count = torch.cuda.device_count()
+        if device < -1 or (device >= cuda_device_count):
+            raise ValueError(
+                f"Got device=={device}, "
+                f"device is required to be within [-1, {cuda_device_count})"
+            )
+        if device < 0 and cuda_device_count > 0:
+            logger.warning(
+                "Device has %d GPUs available. "
+                "Provide device={deviceId} to `from_model_id` to use available"
+                "GPUs for execution. deviceId is -1 for CPU and "
+                "can be a positive integer associated with CUDA device id.",
+                cuda_device_count,
+            )
+
+        client = client.to(device)
+    return client
+
+
+class SelfHostedHuggingFaceEmbeddings(SelfHostedEmbeddings):
+    """HuggingFace embedding models on self-hosted remote hardware.
+
+    Supported hardware includes auto-launched instances on AWS, GCP, Azure,
+    and Lambda, as well as servers specified
+    by IP address and SSH credentials (such as on-prem, or another cloud
+    like Paperspace, Coreweave, etc.).
+
+    To use, you should have the ``runhouse`` python package installed.
+
+    Example:
+        .. code-block:: python
+
+            from langchain_community.embeddings import SelfHostedHuggingFaceEmbeddings
+            import runhouse as rh
+            model_id = "sentence-transformers/all-mpnet-base-v2"
+            gpu = rh.cluster(name="rh-a10x", instance_type="A100:1")
+            hf = SelfHostedHuggingFaceEmbeddings(model_id=model_id, hardware=gpu)
+    """
+
+    client: Any  #: :meta private:
+    model_id: str = DEFAULT_MODEL_NAME
+    """Model name to use."""
+    model_reqs: List[str] = ["./", "sentence_transformers", "torch"]
+    """Requirements to install on hardware to inference the model."""
+    hardware: Any
+    """Remote hardware to send the inference function to."""
+    model_load_fn: Callable = load_embedding_model
+    """Function to load the model remotely on the server."""
+    load_fn_kwargs: Optional[dict] = None
+    """Keyword arguments to pass to the model load function."""
+    inference_fn: Callable = _embed_documents
+    """Inference function to extract the embeddings."""
+
+    def __init__(self, **kwargs: Any):
+        """Initialize the remote inference function."""
+        load_fn_kwargs = kwargs.pop("load_fn_kwargs", {})
+        load_fn_kwargs["model_id"] = load_fn_kwargs.get("model_id", DEFAULT_MODEL_NAME)
+        load_fn_kwargs["instruct"] = load_fn_kwargs.get("instruct", False)
+        load_fn_kwargs["device"] = load_fn_kwargs.get("device", 0)
+        super().__init__(load_fn_kwargs=load_fn_kwargs, **kwargs)
+
+
+class SelfHostedHuggingFaceInstructEmbeddings(SelfHostedHuggingFaceEmbeddings):
+    """HuggingFace InstructEmbedding models on self-hosted remote hardware.
+
+    Supported hardware includes auto-launched instances on AWS, GCP, Azure,
+    and Lambda, as well as servers specified
+    by IP address and SSH credentials (such as on-prem, or another
+    cloud like Paperspace, Coreweave, etc.).
+
+    To use, you should have the ``runhouse`` python package installed.
+
+    Example:
+        .. code-block:: python
+
+            from langchain_community.embeddings import SelfHostedHuggingFaceInstructEmbeddings
+            import runhouse as rh
+            model_name = "hkunlp/instructor-large"
+            gpu = rh.cluster(name='rh-a10x', instance_type='A100:1')
+            hf = SelfHostedHuggingFaceInstructEmbeddings(
+                model_name=model_name, hardware=gpu)
+    """  # noqa: E501
+
+    model_id: str = DEFAULT_INSTRUCT_MODEL
+    """Model name to use."""
+    embed_instruction: str = DEFAULT_EMBED_INSTRUCTION
+    """Instruction to use for embedding documents."""
+    query_instruction: str = DEFAULT_QUERY_INSTRUCTION
+    """Instruction to use for embedding query."""
+    model_reqs: List[str] = ["./", "InstructorEmbedding", "torch"]
+    """Requirements to install on hardware to inference the model."""
+
+    def __init__(self, **kwargs: Any):
+        """Initialize the remote inference function."""
+        load_fn_kwargs = kwargs.pop("load_fn_kwargs", {})
+        load_fn_kwargs["model_id"] = load_fn_kwargs.get(
+            "model_id", DEFAULT_INSTRUCT_MODEL
+        )
+        load_fn_kwargs["instruct"] = load_fn_kwargs.get("instruct", True)
+        load_fn_kwargs["device"] = load_fn_kwargs.get("device", 0)
+        super().__init__(load_fn_kwargs=load_fn_kwargs, **kwargs)
+
+    def embed_documents(self, texts: List[str]) -> List[List[float]]:
+        """Compute doc embeddings using a HuggingFace instruct model.
+
+        Args:
+            texts: The list of texts to embed.
+
+        Returns:
+            List of embeddings, one for each text.
+        """
+        instruction_pairs = []
+        for text in texts:
+            instruction_pairs.append([self.embed_instruction, text])
+        embeddings = self.client(self.pipeline_ref, instruction_pairs)
+        return embeddings.tolist()
+
+    def embed_query(self, text: str) -> List[float]:
+        """Compute query embeddings using a HuggingFace instruct model.
+
+        Args:
+            text: The text to embed.
+
+        Returns:
+            Embeddings for the text.
+        """
+        instruction_pair = [self.query_instruction, text]
+        embedding = self.client(self.pipeline_ref, [instruction_pair])[0]
+        return embedding.tolist()

python/user_packages/Python313/site-packages/langchain_community/embeddings/sentence_transformer.py

@@ -0,0 +1,5 @@
+"""HuggingFace sentence_transformer embedding models."""
+
+from langchain_community.embeddings.huggingface import HuggingFaceEmbeddings
+
+SentenceTransformerEmbeddings = HuggingFaceEmbeddings

python/user_packages/Python313/site-packages/langchain_community/embeddings/solar.py

@@ -0,0 +1,142 @@
+from __future__ import annotations
+
+import logging
+from typing import Any, Callable, Dict, List, Optional
+
+import requests
+from langchain_core._api import deprecated
+from langchain_core.embeddings import Embeddings
+from langchain_core.utils import convert_to_secret_str, get_from_dict_or_env, pre_init
+from pydantic import BaseModel, ConfigDict, SecretStr
+from tenacity import (
+    before_sleep_log,
+    retry,
+    stop_after_attempt,
+    wait_exponential,
+)
+
+logger = logging.getLogger(__name__)
+
+
+def _create_retry_decorator() -> Callable[[Any], Any]:
+    """Returns a tenacity retry decorator."""
+
+    multiplier = 1
+    min_seconds = 1
+    max_seconds = 4
+    max_retries = 6
+
+    return retry(
+        reraise=True,
+        stop=stop_after_attempt(max_retries),
+        wait=wait_exponential(multiplier=multiplier, min=min_seconds, max=max_seconds),
+        before_sleep=before_sleep_log(logger, logging.WARNING),
+    )
+
+
+def embed_with_retry(embeddings: SolarEmbeddings, *args: Any, **kwargs: Any) -> Any:
+    """Use tenacity to retry the completion call."""
+    retry_decorator = _create_retry_decorator()
+
+    @retry_decorator
+    def _embed_with_retry(*args: Any, **kwargs: Any) -> Any:
+        return embeddings.embed(*args, **kwargs)
+
+    return _embed_with_retry(*args, **kwargs)
+
+
+@deprecated(
+    since="0.0.34", removal="1.0", alternative_import="langchain_upstage.ChatUpstage"
+)
+class SolarEmbeddings(BaseModel, Embeddings):
+    """Solar's embedding service.
+
+    To use, you should have the environment variable``SOLAR_API_KEY`` set
+    with your API token, or pass it as a named parameter to the constructor.
+
+    Example:
+        .. code-block:: python
+
+            from langchain_community.embeddings import SolarEmbeddings
+            embeddings = SolarEmbeddings()
+
+            query_text = "This is a test query."
+            query_result = embeddings.embed_query(query_text)
+
+            document_text = "This is a test document."
+            document_result = embeddings.embed_documents([document_text])
+
+    """
+
+    endpoint_url: str = "https://api.upstage.ai/v1/solar/embeddings"
+    """Endpoint URL to use."""
+    model: str = "embedding-query"
+    """Embeddings model name to use."""
+    solar_api_key: Optional[SecretStr] = None
+    """API Key for Solar API."""
+
+    model_config = ConfigDict(
+        extra="forbid",
+    )
+
+    @pre_init
+    def validate_environment(cls, values: Dict) -> Dict:
+        """Validate api key exists in environment."""
+        solar_api_key = convert_to_secret_str(
+            get_from_dict_or_env(values, "solar_api_key", "SOLAR_API_KEY")
+        )
+        values["solar_api_key"] = solar_api_key
+        return values
+
+    def embed(
+        self,
+        text: str,
+    ) -> List[List[float]]:
+        payload = {
+            "model": self.model,
+            "input": text,
+        }
+
+        # HTTP headers for authorization
+        headers = {
+            "Authorization": f"Bearer {self.solar_api_key.get_secret_value()}",  # type: ignore[union-attr]
+            "Content-Type": "application/json",
+        }
+
+        # send request
+        response = requests.post(self.endpoint_url, headers=headers, json=payload)
+        parsed_response = response.json()
+
+        # check for errors
+        if len(parsed_response["data"]) == 0:
+            raise ValueError(
+                f"Solar API returned an error: {parsed_response['base_resp']}"
+            )
+
+        embedding = parsed_response["data"][0]["embedding"]
+
+        return embedding
+
+    def embed_documents(self, texts: List[str]) -> List[List[float]]:
+        """Embed documents using a Solar embedding endpoint.
+
+        Args:
+            texts: The list of texts to embed.
+
+        Returns:
+            List of embeddings, one for each text.
+        """
+        embeddings = [embed_with_retry(self, text=text) for text in texts]
+        return embeddings
+
+    def embed_query(self, text: str) -> List[float]:
+        """Embed a query using a Solar embedding endpoint.
+
+        Args:
+            text: The text to embed.
+
+        Returns:
+            Embeddings for the text.
+        """
+        embedding = embed_with_retry(self, text=text)
+        return embedding

python/user_packages/Python313/site-packages/langchain_community/embeddings/spacy_embeddings.py

@@ -0,0 +1,116 @@
+import importlib.util
+from typing import Any, Dict, List, Optional
+
+from langchain_core.embeddings import Embeddings
+from pydantic import BaseModel, ConfigDict, model_validator
+
+
+class SpacyEmbeddings(BaseModel, Embeddings):
+    """Embeddings by spaCy models.
+
+    Attributes:
+        model_name (str): Name of a spaCy model.
+        nlp (Any): The spaCy model loaded into memory.
+
+    Methods:
+        embed_documents(texts: List[str]) -> List[List[float]]:
+            Generates embeddings for a list of documents.
+        embed_query(text: str) -> List[float]:
+            Generates an embedding for a single piece of text.
+    """
+
+    model_name: str = "en_core_web_sm"
+    nlp: Optional[Any] = None
+
+    model_config = ConfigDict(extra="forbid", protected_namespaces=())
+
+    @model_validator(mode="before")
+    @classmethod
+    def validate_environment(cls, values: Dict) -> Any:
+        """
+        Validates that the spaCy package and the model are installed.
+
+        Args:
+            values (Dict): The values provided to the class constructor.
+
+        Returns:
+            The validated values.
+
+        Raises:
+            ValueError: If the spaCy package or the
+            model are not installed.
+        """
+        if values.get("model_name") is None:
+            values["model_name"] = "en_core_web_sm"
+
+        model_name = values.get("model_name")
+
+        # Check if the spaCy package is installed
+        if importlib.util.find_spec("spacy") is None:
+            raise ValueError(
+                "SpaCy package not found. Please install it with `pip install spacy`."
+            )
+        try:
+            # Try to load the spaCy model
+            import spacy
+
+            values["nlp"] = spacy.load(model_name)
+        except OSError:
+            # If the model is not found, raise a ValueError
+            raise ValueError(
+                f"SpaCy model '{model_name}' not found. "
+                f"Please install it with"
+                f" `python -m spacy download {model_name}`"
+                "or provide a valid spaCy model name."
+            )
+        return values  # Return the validated values
+
+    def embed_documents(self, texts: List[str]) -> List[List[float]]:
+        """
+        Generates embeddings for a list of documents.
+
+        Args:
+            texts (List[str]): The documents to generate embeddings for.
+
+        Returns:
+            A list of embeddings, one for each document.
+        """
+        return [self.nlp(text).vector.tolist() for text in texts]  # type: ignore[misc]
+
+    def embed_query(self, text: str) -> List[float]:
+        """
+        Generates an embedding for a single piece of text.
+
+        Args:
+            text (str): The text to generate an embedding for.
+
+        Returns:
+            The embedding for the text.
+        """
+        return self.nlp(text).vector.tolist()  # type: ignore[misc]
+
+    async def aembed_documents(self, texts: List[str]) -> List[List[float]]:
+        """
+        Asynchronously generates embeddings for a list of documents.
+        This method is not implemented and raises a NotImplementedError.
+
+        Args:
+            texts (List[str]): The documents to generate embeddings for.
+
+        Raises:
+            NotImplementedError: This method is not implemented.
+        """
+        raise NotImplementedError("Asynchronous embedding generation is not supported.")
+
+    async def aembed_query(self, text: str) -> List[float]:
+        """
+        Asynchronously generates an embedding for a single piece of text.
+        This method is not implemented and raises a NotImplementedError.
+
+        Args:
+            text (str): The text to generate an embedding for.
+
+        Raises:
+            NotImplementedError: This method is not implemented.
+        """
+        raise NotImplementedError("Asynchronous embedding generation is not supported.")

python/user_packages/Python313/site-packages/langchain_community/embeddings/sparkllm.py

@@ -0,0 +1,276 @@
+import base64
+import hashlib
+import hmac
+import json
+import logging
+from datetime import datetime
+from time import mktime
+from typing import Any, Dict, List, Literal, Optional
+from urllib.parse import urlencode
+from wsgiref.handlers import format_date_time
+
+import numpy as np
+import requests
+from langchain_core.embeddings import Embeddings
+from langchain_core.utils import (
+    secret_from_env,
+)
+from numpy import ndarray
+from pydantic import BaseModel, ConfigDict, Field, SecretStr
+
+# SparkLLMTextEmbeddings is an embedding model provided by iFLYTEK Co., Ltd.. (https://iflytek.com/en/).
+
+# Official Website: https://www.xfyun.cn/doc/spark/Embedding_api.html
+# Developers need to create an application in the console first, use the appid, APIKey,
+# and APISecret provided in the application for authentication,
+# and generate an authentication URL for handshake.
+# You can get one by registering at https://console.xfyun.cn/services/bm3.
+# SparkLLMTextEmbeddings support 2K token window and preduces vectors with
+# 2560 dimensions.
+
+logger = logging.getLogger(__name__)
+
+
+class Url:
+    """URL class for parsing the URL."""
+
+    def __init__(self, host: str, path: str, schema: str) -> None:
+        self.host = host
+        self.path = path
+        self.schema = schema
+        pass
+
+
+class SparkLLMTextEmbeddings(BaseModel, Embeddings):
+    """SparkLLM embedding model integration.
+
+    Setup:
+        To use, you should have the environment variable "SPARK_APP_ID","SPARK_API_KEY"
+        and "SPARK_API_SECRET" set your APP_ID, API_KEY and API_SECRET or pass it
+        as a name parameter to the constructor.
+
+        .. code-block:: bash
+
+            export SPARK_APP_ID="your-api-id"
+            export SPARK_API_KEY="your-api-key"
+            export SPARK_API_SECRET="your-api-secret"
+
+    Key init args — completion params:
+        api_key: Optional[str]
+            Automatically inferred from env var `SPARK_API_KEY` if not provided.
+        app_id: Optional[str]
+            Automatically inferred from env var `SPARK_APP_ID` if not provided.
+        api_secret: Optional[str]
+            Automatically inferred from env var `SPARK_API_SECRET` if not provided.
+        base_url: Optional[str]
+            Base URL path for API requests.
+
+    See full list of supported init args and their descriptions in the params section.
+
+    Instantiate:
+
+        .. code-block:: python
+
+            from langchain_community.embeddings import SparkLLMTextEmbeddings
+
+            embed = SparkLLMTextEmbeddings(
+                api_key="...",
+                app_id="...",
+                api_secret="...",
+                # other
+            )
+
+    Embed single text:
+        .. code-block:: python
+
+            input_text = "The meaning of life is 42"
+            embed.embed_query(input_text)
+
+        .. code-block:: python
+
+            [-0.4912109375, 0.60595703125, 0.658203125, 0.3037109375, 0.6591796875, 0.60302734375, ...]
+
+    Embed multiple text:
+        .. code-block:: python
+
+            input_texts = ["This is a test query1.", "This is a test query2."]
+            embed.embed_documents(input_texts)
+
+        .. code-block:: python
+
+            [
+                [-0.1962890625, 0.94677734375, 0.7998046875, -0.1971435546875, 0.445556640625, 0.54638671875, ...],
+                [  -0.44970703125, 0.06585693359375, 0.7421875, -0.474609375, 0.62353515625, 1.0478515625, ...],
+            ]
+    """  # noqa: E501
+
+    spark_app_id: SecretStr = Field(
+        alias="app_id", default_factory=secret_from_env("SPARK_APP_ID")
+    )
+    """Automatically inferred from env var `SPARK_APP_ID` if not provided."""
+    spark_api_key: Optional[SecretStr] = Field(
+        alias="api_key", default_factory=secret_from_env("SPARK_API_KEY", default=None)
+    )
+    """Automatically inferred from env var `SPARK_API_KEY` if not provided."""
+    spark_api_secret: Optional[SecretStr] = Field(
+        alias="api_secret",
+        default_factory=secret_from_env("SPARK_API_SECRET", default=None),
+    )
+    """Automatically inferred from env var `SPARK_API_SECRET` if not provided."""
+    base_url: str = Field(default="https://emb-cn-huabei-1.xf-yun.com/")
+    """Base URL path for API requests"""
+    domain: Literal["para", "query"] = Field(default="para")
+    """This parameter is used for which Embedding this time belongs to.
+    If "para"(default), it belongs to document Embedding. 
+    If "query", it belongs to query Embedding."""
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+    )
+
+    def _embed(self, texts: List[str], host: str) -> Optional[List[List[float]]]:
+        """Internal method to call Spark Embedding API and return embeddings.
+
+        Args:
+            texts: A list of texts to embed.
+            host: Base URL path for API requests
+
+        Returns:
+            A list of list of floats representing the embeddings,
+            or list with value None if an error occurs.
+        """
+        app_id = ""
+        api_key = ""
+        api_secret = ""
+        if self.spark_app_id:
+            app_id = self.spark_app_id.get_secret_value()
+        if self.spark_api_key:
+            api_key = self.spark_api_key.get_secret_value()
+        if self.spark_api_secret:
+            api_secret = self.spark_api_secret.get_secret_value()
+        url = self._assemble_ws_auth_url(
+            request_url=host,
+            method="POST",
+            api_key=api_key,
+            api_secret=api_secret,
+        )
+        embed_result: list = []
+        for text in texts:
+            query_context = {"messages": [{"content": text, "role": "user"}]}
+            content = self._get_body(app_id, query_context)
+            response = requests.post(
+                url, json=content, headers={"content-type": "application/json"}
+            ).text
+            res_arr = self._parser_message(response)
+            if res_arr is not None:
+                embed_result.append(res_arr.tolist())
+            else:
+                embed_result.append(None)
+        return embed_result
+
+    def embed_documents(self, texts: List[str]) -> Optional[List[List[float]]]:  # type: ignore[override]
+        """Public method to get embeddings for a list of documents.
+
+        Args:
+            texts: The list of texts to embed.
+
+        Returns:
+            A list of embeddings, one for each text, or None if an error occurs.
+        """
+        return self._embed(texts, self.base_url)
+
+    def embed_query(self, text: str) -> Optional[List[float]]:  # type: ignore[override]
+        """Public method to get embedding for a single query text.
+
+        Args:
+            text: The text to embed.
+
+        Returns:
+            Embeddings for the text, or None if an error occurs.
+        """
+        result = self._embed([text], self.base_url)
+        return result[0] if result is not None else None
+
+    @staticmethod
+    def _assemble_ws_auth_url(
+        request_url: str, method: str = "GET", api_key: str = "", api_secret: str = ""
+    ) -> str:
+        u = SparkLLMTextEmbeddings._parse_url(request_url)
+        host = u.host
+        path = u.path
+        now = datetime.now()
+        date = format_date_time(mktime(now.timetuple()))
+        signature_origin = "host: {}\ndate: {}\n{} {} HTTP/1.1".format(
+            host, date, method, path
+        )
+        signature_sha = hmac.new(
+            api_secret.encode("utf-8"),
+            signature_origin.encode("utf-8"),
+            digestmod=hashlib.sha256,
+        ).digest()
+        signature_sha_str = base64.b64encode(signature_sha).decode(encoding="utf-8")
+        authorization_origin = (
+            'api_key="%s", algorithm="%s", headers="%s", signature="%s"'
+            % (api_key, "hmac-sha256", "host date request-line", signature_sha_str)
+        )
+        authorization = base64.b64encode(authorization_origin.encode("utf-8")).decode(
+            encoding="utf-8"
+        )
+        values = {"host": host, "date": date, "authorization": authorization}
+
+        return request_url + "?" + urlencode(values)
+
+    @staticmethod
+    def _parse_url(request_url: str) -> Url:
+        stidx = request_url.index("://")
+        host = request_url[stidx + 3 :]
+        schema = request_url[: stidx + 3]
+        edidx = host.index("/")
+        if edidx <= 0:
+            raise AssembleHeaderException("invalid request url:" + request_url)
+        path = host[edidx:]
+        host = host[:edidx]
+        u = Url(host, path, schema)
+        return u
+
+    def _get_body(self, appid: str, text: dict) -> Dict[str, Any]:
+        body = {
+            "header": {"app_id": appid, "uid": "39769795890", "status": 3},
+            "parameter": {
+                "emb": {"domain": self.domain, "feature": {"encoding": "utf8"}}
+            },
+            "payload": {
+                "messages": {
+                    "text": base64.b64encode(json.dumps(text).encode("utf-8")).decode()
+                }
+            },
+        }
+        return body
+
+    @staticmethod
+    def _parser_message(
+        message: str,
+    ) -> Optional[ndarray]:
+        data = json.loads(message)
+        code = data["header"]["code"]
+        if code != 0:
+            logger.warning(f"Request error: {code}, {data}")
+            return None
+        else:
+            text_base = data["payload"]["feature"]["text"]
+            text_data = base64.b64decode(text_base)
+            dt = np.dtype(np.float32)
+            dt = dt.newbyteorder("<")
+            text = np.frombuffer(text_data, dtype=dt)
+            if len(text) > 2560:
+                array = text[:2560]
+            else:
+                array = text
+            return array
+
+
+class AssembleHeaderException(Exception):
+    """Exception raised for errors in the header assembly."""
+
+    def __init__(self, msg: str) -> None:
+        self.message = msg

python/user_packages/Python313/site-packages/langchain_community/embeddings/tensorflow_hub.py

@@ -0,0 +1,75 @@
+from typing import Any, List
+
+from langchain_core.embeddings import Embeddings
+from pydantic import BaseModel, ConfigDict
+
+DEFAULT_MODEL_URL = "https://tfhub.dev/google/universal-sentence-encoder-multilingual/3"
+
+
+class TensorflowHubEmbeddings(BaseModel, Embeddings):
+    """TensorflowHub embedding models.
+
+    To use, you should have the ``tensorflow_text`` python package installed.
+
+    Example:
+        .. code-block:: python
+
+            from langchain_community.embeddings import TensorflowHubEmbeddings
+            url = "https://tfhub.dev/google/universal-sentence-encoder-multilingual/3"
+            tf = TensorflowHubEmbeddings(model_url=url)
+    """
+
+    embed: Any = None  #: :meta private:
+    model_url: str = DEFAULT_MODEL_URL
+    """Model name to use."""
+
+    def __init__(self, **kwargs: Any):
+        """Initialize the tensorflow_hub and tensorflow_text."""
+        super().__init__(**kwargs)
+        try:
+            import tensorflow_hub
+        except ImportError:
+            raise ImportError(
+                "Could not import tensorflow-hub python package. "
+                "Please install it with `pip install tensorflow-hub``."
+            )
+        try:
+            import tensorflow_text  # noqa
+        except ImportError:
+            raise ImportError(
+                "Could not import tensorflow_text python package. "
+                "Please install it with `pip install tensorflow_text``."
+            )
+
+        self.embed = tensorflow_hub.load(self.model_url)
+
+    model_config = ConfigDict(
+        extra="forbid",
+        protected_namespaces=(),
+    )
+
+    def embed_documents(self, texts: List[str]) -> List[List[float]]:
+        """Compute doc embeddings using a TensorflowHub embedding model.
+
+        Args:
+            texts: The list of texts to embed.
+
+        Returns:
+            List of embeddings, one for each text.
+        """
+        texts = list(map(lambda x: x.replace("\n", " "), texts))
+        embeddings = self.embed(texts).numpy()
+        return embeddings.tolist()
+
+    def embed_query(self, text: str) -> List[float]:
+        """Compute query embeddings using a TensorflowHub embedding model.
+
+        Args:
+            text: The text to embed.
+
+        Returns:
+            Embeddings for the text.
+        """
+        text = text.replace("\n", " ")
+        embedding = self.embed([text]).numpy()[0]
+        return embedding.tolist()

python/user_packages/Python313/site-packages/langchain_community/embeddings/text2vec.py

@@ -0,0 +1,81 @@
+"""Wrapper around text2vec embedding models."""
+
+from typing import Any, List, Optional
+
+from langchain_core.embeddings import Embeddings
+from pydantic import BaseModel, ConfigDict
+
+
+class Text2vecEmbeddings(Embeddings, BaseModel):
+    """text2vec embedding models.
+
+    Install text2vec first, run 'pip install -U text2vec'.
+    The github repository for text2vec is : https://github.com/shibing624/text2vec
+
+    Example:
+        .. code-block:: python
+
+            from langchain_community.embeddings.text2vec import Text2vecEmbeddings
+
+            embedding = Text2vecEmbeddings()
+            embedding.embed_documents([
+                "This is a CoSENT(Cosine Sentence) model.",
+                "It maps sentences to a 768 dimensional dense vector space.",
+            ])
+            embedding.embed_query(
+                "It can be used for text matching or semantic search."
+            )
+    """
+
+    model_name_or_path: Optional[str] = None
+    encoder_type: Any = "MEAN"
+    max_seq_length: int = 256
+    device: Optional[str] = None
+    model: Any = None
+
+    model_config = ConfigDict(protected_namespaces=())
+
+    def __init__(
+        self,
+        *,
+        model: Any = None,
+        model_name_or_path: Optional[str] = None,
+        **kwargs: Any,
+    ):
+        try:
+            from text2vec import SentenceModel
+        except ImportError as e:
+            raise ImportError(
+                "Unable to import text2vec, please install with "
+                "`pip install -U text2vec`."
+            ) from e
+
+        model_kwargs = {}
+        if model_name_or_path is not None:
+            model_kwargs["model_name_or_path"] = model_name_or_path
+        model = model or SentenceModel(**model_kwargs, **kwargs)
+        super().__init__(model=model, model_name_or_path=model_name_or_path, **kwargs)
+
+    def embed_documents(self, texts: List[str]) -> List[List[float]]:
+        """Embed documents using the text2vec embeddings model.
+
+        Args:
+            texts: The list of texts to embed.
+
+        Returns:
+            List of embeddings, one for each text.
+        """
+
+        return self.model.encode(texts)
+
+    def embed_query(self, text: str) -> List[float]:
+        """Embed a query using the text2vec embeddings model.
+
+        Args:
+            text: The text to embed.
+
+        Returns:
+            Embeddings for the text.
+        """
+
+        return self.model.encode(text)

python/user_packages/Python313/site-packages/langchain_community/embeddings/textembed.py

@@ -0,0 +1,350 @@
+"""
+TextEmbed: Embedding Inference Server
+
+TextEmbed provides a high-throughput, low-latency solution for serving embeddings.
+It supports various sentence-transformer models.
+Now, it includes the ability to deploy image embedding models.
+TextEmbed offers flexibility and scalability for diverse applications.
+
+TextEmbed is maintained by Keval Dekivadiya and is licensed under the Apache-2.0 license.
+"""  # noqa: E501
+
+import asyncio
+from concurrent.futures import ThreadPoolExecutor
+from typing import Any, Callable, Dict, List, Optional, Tuple, Union
+
+import aiohttp
+import numpy as np
+import requests
+from langchain_core.embeddings import Embeddings
+from langchain_core.utils import from_env, secret_from_env
+from pydantic import BaseModel, ConfigDict, Field, SecretStr, model_validator
+from typing_extensions import Self
+
+__all__ = ["TextEmbedEmbeddings"]
+
+
+class TextEmbedEmbeddings(BaseModel, Embeddings):
+    """
+    A class to handle embedding requests to the TextEmbed API.
+
+    Attributes:
+        model : The TextEmbed model ID to use for embeddings.
+        api_url : The base URL for the TextEmbed API.
+        api_key : The API key for authenticating with the TextEmbed API.
+        client : The TextEmbed client instance.
+
+    Example:
+        .. code-block:: python
+
+            from langchain_community.embeddings import TextEmbedEmbeddings
+
+            embeddings = TextEmbedEmbeddings(
+                model="sentence-transformers/clip-ViT-B-32",
+                api_url="http://localhost:8000/v1",
+                api_key="<API_KEY>"
+            )
+
+    For more information: https://github.com/kevaldekivadiya2415/textembed/blob/main/docs/setup.md
+    """  # noqa: E501
+
+    model: str
+    """Underlying TextEmbed model id."""
+
+    api_url: str = Field(
+        default_factory=from_env(
+            "TEXTEMBED_API_URL", default="http://localhost:8000/v1"
+        )
+    )
+    """Endpoint URL to use."""
+
+    api_key: SecretStr = Field(default_factory=secret_from_env("TEXTEMBED_API_KEY"))
+    """API Key for authentication"""
+
+    client: Any = None
+    """TextEmbed client."""
+
+    model_config = ConfigDict(
+        extra="forbid",
+    )
+
+    @model_validator(mode="after")
+    def validate_environment(self) -> Self:
+        """Validate that api key and URL exist in the environment."""
+        self.client = AsyncOpenAITextEmbedEmbeddingClient(
+            host=self.api_url, api_key=self.api_key.get_secret_value()
+        )
+        return self
+
+    def embed_documents(self, texts: List[str]) -> List[List[float]]:
+        """Call out to TextEmbed's embedding endpoint.
+
+        Args:
+            texts (List[str]): The list of texts to embed.
+
+        Returns:
+            List[List[float]]: List of embeddings, one for each text.
+        """
+        embeddings = self.client.embed(
+            model=self.model,
+            texts=texts,
+        )
+        return embeddings
+
+    async def aembed_documents(self, texts: List[str]) -> List[List[float]]:
+        """Async call out to TextEmbed's embedding endpoint.
+
+        Args:
+            texts (List[str]): The list of texts to embed.
+
+        Returns:
+            List[List[float]]: List of embeddings, one for each text.
+        """
+        embeddings = await self.client.aembed(
+            model=self.model,
+            texts=texts,
+        )
+        return embeddings
+
+    def embed_query(self, text: str) -> List[float]:
+        """Call out to TextEmbed's embedding endpoint for a single query.
+
+        Args:
+            text (str): The text to embed.
+
+        Returns:
+            List[float]: Embeddings for the text.
+        """
+        return self.embed_documents([text])[0]
+
+    async def aembed_query(self, text: str) -> List[float]:
+        """Async call out to TextEmbed's embedding endpoint for a single query.
+
+        Args:
+            text (str): The text to embed.
+
+        Returns:
+            List[float]: Embeddings for the text.
+        """
+        embeddings = await self.aembed_documents([text])
+        return embeddings[0]
+
+
+class AsyncOpenAITextEmbedEmbeddingClient:
+    """
+    A client to handle synchronous and asynchronous requests to the TextEmbed API.
+
+    Attributes:
+        host (str): The base URL for the TextEmbed API.
+        api_key (str): The API key for authenticating with the TextEmbed API.
+        aiosession (Optional[aiohttp.ClientSession]): The aiohttp session for async requests.
+        _batch_size (int): Maximum batch size for a single request.
+    """  # noqa: E501
+
+    def __init__(
+        self,
+        host: str = "http://localhost:8000/v1",
+        api_key: Union[str, None] = None,
+        aiosession: Optional[aiohttp.ClientSession] = None,
+    ) -> None:
+        self.host = host
+        self.api_key = api_key
+        self.aiosession = aiosession
+
+        if self.host is None or len(self.host) < 3:
+            raise ValueError("Parameter `host` must be set to a valid URL")
+        self._batch_size = 256
+
+    @staticmethod
+    def _permute(
+        texts: List[str], sorter: Callable = len
+    ) -> Tuple[List[str], Callable]:
+        """
+        Sorts texts in ascending order and provides a function to restore the original order.
+
+        Args:
+            texts (List[str]): List of texts to sort.
+            sorter (Callable, optional): Sorting function, defaults to length.
+
+        Returns:
+            Tuple[List[str], Callable]: Sorted texts and a function to restore original order.
+        """  # noqa: E501
+        if len(texts) == 1:
+            return texts, lambda t: t
+        length_sorted_idx = np.argsort([-sorter(sen) for sen in texts])
+        texts_sorted = [texts[idx] for idx in length_sorted_idx]
+
+        return texts_sorted, lambda unsorted_embeddings: [
+            unsorted_embeddings[idx] for idx in np.argsort(length_sorted_idx)
+        ]
+
+    def _batch(self, texts: List[str]) -> List[List[str]]:
+        """
+        Splits a list of texts into batches of size max `self._batch_size`.
+
+        Args:
+            texts (List[str]): List of texts to split.
+
+        Returns:
+            List[List[str]]: List of batches of texts.
+        """
+        if len(texts) == 1:
+            return [texts]
+        batches = []
+        for start_index in range(0, len(texts), self._batch_size):
+            batches.append(texts[start_index : start_index + self._batch_size])
+        return batches
+
+    @staticmethod
+    def _unbatch(batch_of_texts: List[List[Any]]) -> List[Any]:
+        """
+        Merges batches of texts into a single list.
+
+        Args:
+            batch_of_texts (List[List[Any]]): List of batches of texts.
+
+        Returns:
+            List[Any]: Merged list of texts.
+        """
+        if len(batch_of_texts) == 1 and len(batch_of_texts[0]) == 1:
+            return batch_of_texts[0]
+        texts = []
+        for sublist in batch_of_texts:
+            texts.extend(sublist)
+        return texts
+
+    def _kwargs_post_request(self, model: str, texts: List[str]) -> Dict[str, Any]:
+        """
+        Builds the kwargs for the POST request, used by sync method.
+
+        Args:
+            model (str): The model to use for embedding.
+            texts (List[str]): List of texts to embed.
+
+        Returns:
+            Dict[str, Any]: Dictionary of POST request parameters.
+        """
+        return dict(
+            url=f"{self.host}/embedding",
+            headers={
+                "accept": "application/json",
+                "content-type": "application/json",
+                "Authorization": f"Bearer {self.api_key}",
+            },
+            json=dict(
+                input=texts,
+                model=model,
+            ),
+        )
+
+    def _sync_request_embed(
+        self, model: str, batch_texts: List[str]
+    ) -> List[List[float]]:
+        """
+        Sends a synchronous request to the embedding endpoint.
+
+        Args:
+            model (str): The model to use for embedding.
+            batch_texts (List[str]): Batch of texts to embed.
+
+        Returns:
+            List[List[float]]: List of embeddings for the batch.
+
+        Raises:
+            Exception: If the response status is not 200.
+        """
+        response = requests.post(
+            **self._kwargs_post_request(model=model, texts=batch_texts)
+        )
+        if response.status_code != 200:
+            raise Exception(
+                f"TextEmbed responded with an unexpected status message "
+                f"{response.status_code}: {response.text}"
+            )
+        return [e["embedding"] for e in response.json()["data"]]
+
+    def embed(self, model: str, texts: List[str]) -> List[List[float]]:
+        """
+        Embeds a list of texts synchronously.
+
+        Args:
+            model (str): The model to use for embedding.
+            texts (List[str]): List of texts to embed.
+
+        Returns:
+            List[List[float]]: List of embeddings for the texts.
+        """
+        perm_texts, unpermute_func = self._permute(texts)
+        perm_texts_batched = self._batch(perm_texts)
+
+        # Request
+        map_args = (
+            self._sync_request_embed,
+            [model] * len(perm_texts_batched),
+            perm_texts_batched,
+        )
+        if len(perm_texts_batched) == 1:
+            embeddings_batch_perm = list(map(*map_args))
+        else:
+            with ThreadPoolExecutor(32) as p:
+                embeddings_batch_perm = list(p.map(*map_args))
+
+        embeddings_perm = self._unbatch(embeddings_batch_perm)
+        embeddings = unpermute_func(embeddings_perm)
+        return embeddings
+
+    async def _async_request(
+        self, session: aiohttp.ClientSession, **kwargs: Dict[str, Any]
+    ) -> List[List[float]]:
+        """
+        Sends an asynchronous request to the embedding endpoint.
+
+        Args:
+            session (aiohttp.ClientSession): The aiohttp session for the request.
+            kwargs (Dict[str, Any]): Dictionary of POST request parameters.
+
+        Returns:
+            List[List[float]]: List of embeddings for the request.
+
+        Raises:
+            Exception: If the response status is not 200.
+        """
+        async with session.post(**kwargs) as response:  # type: ignore[arg-type]
+            if response.status != 200:
+                raise Exception(
+                    f"TextEmbed responded with an unexpected status message "
+                    f"{response.status}: {response.text}"
+                )
+            embedding = (await response.json())["data"]
+            return [e["embedding"] for e in embedding]
+
+    async def aembed(self, model: str, texts: List[str]) -> List[List[float]]:
+        """
+        Embeds a list of texts asynchronously.
+
+        Args:
+            model (str): The model to use for embedding.
+            texts (List[str]): List of texts to embed.
+
+        Returns:
+            List[List[float]]: List of embeddings for the texts.
+        """
+        perm_texts, unpermute_func = self._permute(texts)
+        perm_texts_batched = self._batch(perm_texts)
+
+        async with aiohttp.ClientSession(
+            connector=aiohttp.TCPConnector(limit=32)
+        ) as session:
+            embeddings_batch_perm = await asyncio.gather(
+                *[
+                    self._async_request(
+                        session=session,
+                        **self._kwargs_post_request(model=model, texts=t),
+                    )
+                    for t in perm_texts_batched
+                ]
+            )
+
+        embeddings_perm = self._unbatch(embeddings_batch_perm)
+        embeddings = unpermute_func(embeddings_perm)
+        return embeddings

python/user_packages/Python313/site-packages/langchain_community/embeddings/titan_takeoff.py

@@ -0,0 +1,210 @@
+from enum import Enum
+from typing import Any, Dict, List, Optional, Set, Union
+
+from langchain_core.embeddings import Embeddings
+from pydantic import BaseModel, ConfigDict
+
+
+class TakeoffEmbeddingException(Exception):
+    """Custom exception for interfacing with Takeoff Embedding class."""
+
+
+class MissingConsumerGroup(TakeoffEmbeddingException):
+    """Exception raised when no consumer group is provided on initialization of
+    TitanTakeoffEmbed or in embed request."""
+
+
+class Device(str, Enum):
+    """Device to use for inference, cuda or cpu."""
+
+    cuda = "cuda"
+    cpu = "cpu"
+
+
+class ReaderConfig(BaseModel):
+    """Configuration for the reader to be deployed in Takeoff."""
+
+    model_config = ConfigDict(
+        protected_namespaces=(),
+    )
+
+    model_name: str
+    """The name of the model to use"""
+
+    device: Device = Device.cuda
+    """The device to use for inference, cuda or cpu"""
+
+    consumer_group: str = "primary"
+    """The consumer group to place the reader into"""
+
+
+class TitanTakeoffEmbed(Embeddings):
+    """Interface with Takeoff Inference API for embedding models.
+
+    Use it to send embedding requests and to deploy embedding
+    readers with Takeoff.
+
+    Examples:
+        This is an example how to deploy an embedding model and send requests.
+
+        .. code-block:: python
+            # Import the TitanTakeoffEmbed class from community package
+            import time
+            from langchain_community.embeddings import TitanTakeoffEmbed
+
+            # Specify the embedding reader you'd like to deploy
+            reader_1 = {
+                "model_name": "avsolatorio/GIST-large-Embedding-v0",
+                "device": "cpu",
+                "consumer_group": "embed"
+            }
+
+            # For every reader you pass into models arg Takeoff will spin up a reader
+            # according to the specs you provide. If you don't specify the arg no models
+            # are spun up and it assumes you have already done this separately.
+            embed = TitanTakeoffEmbed(models=[reader_1])
+
+            # Wait for the reader to be deployed, time needed depends on the model size
+            # and your internet speed
+            time.sleep(60)
+
+            # Returns the embedded query, ie a List[float], sent to `embed` consumer
+            # group where we just spun up the embedding reader
+            print(embed.embed_query(
+                "Where can I see football?", consumer_group="embed"
+            ))
+
+            # Returns a List of embeddings, ie a List[List[float]], sent to `embed`
+            # consumer group where we just spun up the embedding reader
+            print(embed.embed_document(
+                ["Document1", "Document2"],
+                consumer_group="embed"
+            ))
+    """
+
+    base_url: str = "http://localhost"
+    """The base URL of the Titan Takeoff (Pro) server. Default = "http://localhost"."""
+
+    port: int = 3000
+    """The port of the Titan Takeoff (Pro) server. Default = 3000."""
+
+    mgmt_port: int = 3001
+    """The management port of the Titan Takeoff (Pro) server. Default = 3001."""
+
+    client: Any = None
+    """Takeoff Client Python SDK used to interact with Takeoff API"""
+
+    embed_consumer_groups: Set[str] = set()
+    """The consumer groups in Takeoff which contain embedding models"""
+
+    def __init__(
+        self,
+        base_url: str = "http://localhost",
+        port: int = 3000,
+        mgmt_port: int = 3001,
+        models: List[ReaderConfig] = [],
+    ):
+        """Initialize the Titan Takeoff embedding wrapper.
+
+        Args:
+            base_url (str, optional): The base url where Takeoff Inference Server is
+            listening. Defaults to "http://localhost".
+            port (int, optional): What port is Takeoff Inference API listening on.
+            Defaults to 3000.
+            mgmt_port (int, optional): What port is Takeoff Management API listening on.
+            Defaults to 3001.
+            models (List[ReaderConfig], optional): Any readers you'd like to spin up on.
+            Defaults to [].
+
+        Raises:
+            ImportError: If you haven't installed takeoff-client, you will get an
+            ImportError. To remedy run `pip install 'takeoff-client==0.4.0'`
+        """
+        self.base_url = base_url
+        self.port = port
+        self.mgmt_port = mgmt_port
+        try:
+            from takeoff_client import TakeoffClient
+        except ImportError:
+            raise ImportError(
+                "takeoff-client is required for TitanTakeoff. "
+                "Please install it with `pip install 'takeoff-client==0.4.0'`."
+            )
+        self.client = TakeoffClient(
+            self.base_url, port=self.port, mgmt_port=self.mgmt_port
+        )
+        for model in models:
+            self.client.create_reader(model)
+            if isinstance(model, dict):
+                self.embed_consumer_groups.add(model.get("consumer_group"))
+            else:
+                self.embed_consumer_groups.add(model.consumer_group)
+        super(TitanTakeoffEmbed, self).__init__()
+
+    def _embed(
+        self, input: Union[List[str], str], consumer_group: Optional[str]
+    ) -> Dict[str, Any]:
+        """Embed text.
+
+        Args:
+            input (Union[List[str], str]): prompt/document or list of prompts/documents
+            to embed
+            consumer_group (Optional[str]): what consumer group to send the embedding
+            request to. If not specified and there is only one
+            consumer group specified during initialization, it will be used. If there
+            are multiple consumer groups specified during initialization, you must
+            specify which one to use.
+
+        Raises:
+            MissingConsumerGroup: The consumer group can not be inferred from the
+            initialization and must be specified with request.
+
+        Returns:
+            Dict[str, Any]: Result of query, {"result": List[List[float]]} or
+            {"result": List[float]}
+        """
+        if not consumer_group:
+            if len(self.embed_consumer_groups) == 1:
+                consumer_group = list(self.embed_consumer_groups)[0]
+            elif len(self.embed_consumer_groups) > 1:
+                raise MissingConsumerGroup(
+                    "TakeoffEmbedding was initialized with multiple embedding reader"
+                    "groups, you must specify which one to use."
+                )
+            else:
+                raise MissingConsumerGroup(
+                    "You must specify what consumer group you want to send embedding"
+                    "response to as TitanTakeoffEmbed was not initialized with an "
+                    "embedding reader."
+                )
+        return self.client.embed(input, consumer_group)
+
+    def embed_documents(
+        self, texts: List[str], consumer_group: Optional[str] = None
+    ) -> List[List[float]]:
+        """Embed documents.
+
+        Args:
+            texts (List[str]): List of prompts/documents to embed
+            consumer_group (Optional[str], optional): Consumer group to send request
+            to containing embedding model. Defaults to None.
+
+        Returns:
+            List[List[float]]: List of embeddings
+        """
+        return self._embed(texts, consumer_group)["result"]
+
+    def embed_query(
+        self, text: str, consumer_group: Optional[str] = None
+    ) -> List[float]:
+        """Embed query.
+
+        Args:
+            text (str): Prompt/document to embed
+            consumer_group (Optional[str], optional): Consumer group to send request
+            to containing embedding model. Defaults to None.
+
+        Returns:
+            List[float]: Embedding
+        """
+        return self._embed(text, consumer_group)["result"]

python/user_packages/Python313/site-packages/langchain_community/embeddings/vertexai.py

@@ -0,0 +1,361 @@
+import logging
+import re
+import string
+import threading
+from concurrent.futures import ThreadPoolExecutor, wait
+from typing import Any, Dict, List, Literal, Optional, Tuple
+
+from langchain_core._api.deprecation import deprecated
+from langchain_core.embeddings import Embeddings
+from langchain_core.language_models.llms import create_base_retry_decorator
+from langchain_core.utils import pre_init
+
+from langchain_community.llms.vertexai import _VertexAICommon
+from langchain_community.utilities.vertexai import raise_vertex_import_error
+
+logger = logging.getLogger(__name__)
+
+_MAX_TOKENS_PER_BATCH = 20000
+_MAX_BATCH_SIZE = 250
+_MIN_BATCH_SIZE = 5
+
+
+@deprecated(
+    since="0.0.12",
+    removal="1.0",
+    alternative_import="langchain_google_vertexai.VertexAIEmbeddings",
+)
+class VertexAIEmbeddings(_VertexAICommon, Embeddings):
+    """Google Cloud VertexAI embedding models."""
+
+    # Instance context
+    instance: Dict[str, Any] = {}  #: :meta private:
+    show_progress_bar: bool = False
+    """Whether to show a tqdm progress bar. Must have `tqdm` installed."""
+
+    @pre_init
+    def validate_environment(cls, values: Dict) -> Dict:
+        """Validates that the python package exists in environment."""
+        cls._try_init_vertexai(values)
+        if values["model_name"] == "textembedding-gecko-default":
+            logger.warning(
+                "Model_name will become a required arg for VertexAIEmbeddings "
+                "starting from Feb-01-2024. Currently the default is set to "
+                "textembedding-gecko@001"
+            )
+            values["model_name"] = "textembedding-gecko@001"
+        try:
+            from vertexai.language_models import TextEmbeddingModel
+        except ImportError:
+            raise_vertex_import_error()
+        values["client"] = TextEmbeddingModel.from_pretrained(values["model_name"])
+        return values
+
+    def __init__(
+        self,
+        # the default value would be removed after Feb-01-2024
+        model_name: str = "textembedding-gecko-default",
+        project: Optional[str] = None,
+        location: str = "us-central1",
+        request_parallelism: int = 5,
+        max_retries: int = 6,
+        credentials: Optional[Any] = None,
+        **kwargs: Any,
+    ):
+        """Initialize the sentence_transformer."""
+        super().__init__(
+            project=project,
+            location=location,
+            credentials=credentials,
+            request_parallelism=request_parallelism,
+            max_retries=max_retries,
+            model_name=model_name,
+            **kwargs,
+        )
+        self.instance["max_batch_size"] = kwargs.get("max_batch_size", _MAX_BATCH_SIZE)
+        self.instance["batch_size"] = self.instance["max_batch_size"]
+        self.instance["min_batch_size"] = kwargs.get("min_batch_size", _MIN_BATCH_SIZE)
+        self.instance["min_good_batch_size"] = self.instance["min_batch_size"]
+        self.instance["lock"] = threading.Lock()
+        self.instance["batch_size_validated"] = False
+        self.instance["task_executor"] = ThreadPoolExecutor(
+            max_workers=request_parallelism
+        )
+        self.instance[
+            "embeddings_task_type_supported"
+        ] = not self.client._endpoint_name.endswith("/textembedding-gecko@001")
+
+    @staticmethod
+    def _split_by_punctuation(text: str) -> List[str]:
+        """Splits a string by punctuation and whitespace characters."""
+        split_by = string.punctuation + "\t\n "
+        pattern = f"([{split_by}])"
+        # Using re.split to split the text based on the pattern
+        return [segment for segment in re.split(pattern, text) if segment]
+
+    @staticmethod
+    def _prepare_batches(texts: List[str], batch_size: int) -> List[List[str]]:
+        """Splits texts in batches based on current maximum batch size
+        and maximum tokens per request.
+        """
+        text_index = 0
+        texts_len = len(texts)
+        batch_token_len = 0
+        batches: List[List[str]] = []
+        current_batch: List[str] = []
+        if texts_len == 0:
+            return []
+        while text_index < texts_len:
+            current_text = texts[text_index]
+            # Number of tokens per a text is conservatively estimated
+            # as 2 times number of words, punctuation and whitespace characters.
+            # Using `count_tokens` API will make batching too expensive.
+            # Utilizing a tokenizer, would add a dependency that would not
+            # necessarily be reused by the application using this class.
+            current_text_token_cnt = (
+                len(VertexAIEmbeddings._split_by_punctuation(current_text)) * 2
+            )
+            end_of_batch = False
+            if current_text_token_cnt > _MAX_TOKENS_PER_BATCH:
+                # Current text is too big even for a single batch.
+                # Such request will fail, but we still make a batch
+                # so that the app can get the error from the API.
+                if len(current_batch) > 0:
+                    # Adding current batch if not empty.
+                    batches.append(current_batch)
+                current_batch = [current_text]
+                text_index += 1
+                end_of_batch = True
+            elif (
+                batch_token_len + current_text_token_cnt > _MAX_TOKENS_PER_BATCH
+                or len(current_batch) == batch_size
+            ):
+                end_of_batch = True
+            else:
+                if text_index == texts_len - 1:
+                    # Last element - even though the batch may be not big,
+                    # we still need to make it.
+                    end_of_batch = True
+                batch_token_len += current_text_token_cnt
+                current_batch.append(current_text)
+                text_index += 1
+            if end_of_batch:
+                batches.append(current_batch)
+                current_batch = []
+                batch_token_len = 0
+        return batches
+
+    def _get_embeddings_with_retry(
+        self, texts: List[str], embeddings_type: Optional[str] = None
+    ) -> List[List[float]]:
+        """Makes a Vertex AI model request with retry logic."""
+        from google.api_core.exceptions import (
+            Aborted,
+            DeadlineExceeded,
+            ResourceExhausted,
+            ServiceUnavailable,
+        )
+
+        errors = [
+            ResourceExhausted,
+            ServiceUnavailable,
+            Aborted,
+            DeadlineExceeded,
+        ]
+        retry_decorator = create_base_retry_decorator(
+            error_types=errors,
+            max_retries=self.max_retries,
+        )
+
+        @retry_decorator
+        def _completion_with_retry(texts_to_process: List[str]) -> Any:
+            if embeddings_type and self.instance["embeddings_task_type_supported"]:
+                from vertexai.language_models import TextEmbeddingInput
+
+                requests = [
+                    TextEmbeddingInput(text=t, task_type=embeddings_type)
+                    for t in texts_to_process
+                ]
+            else:
+                requests = texts_to_process
+            embeddings = self.client.get_embeddings(requests)
+            return [embs.values for embs in embeddings]
+
+        return _completion_with_retry(texts)
+
+    def _prepare_and_validate_batches(
+        self, texts: List[str], embeddings_type: Optional[str] = None
+    ) -> Tuple[List[List[float]], List[List[str]]]:
+        """Prepares text batches with one-time validation of batch size.
+        Batch size varies between GCP regions and individual project quotas.
+        # Returns embeddings of the first text batch that went through,
+        # and text batches for the rest of the texts.
+        """
+        from google.api_core.exceptions import InvalidArgument
+
+        batches = VertexAIEmbeddings._prepare_batches(
+            texts, self.instance["batch_size"]
+        )
+        # If batch size if less or equal to one that went through before,
+        # then keep batches as they are.
+        if len(batches[0]) <= self.instance["min_good_batch_size"]:
+            return [], batches
+        with self.instance["lock"]:
+            # If largest possible batch size was validated
+            # while waiting for the lock, then check for rebuilding
+            # our batches, and return.
+            if self.instance["batch_size_validated"]:
+                if len(batches[0]) <= self.instance["batch_size"]:
+                    return [], batches
+                else:
+                    return [], VertexAIEmbeddings._prepare_batches(
+                        texts, self.instance["batch_size"]
+                    )
+            # Figure out largest possible batch size by trying to push
+            # batches and lowering their size in half after every failure.
+            first_batch = batches[0]
+            first_result = []
+            had_failure = False
+            while True:
+                try:
+                    first_result = self._get_embeddings_with_retry(
+                        first_batch, embeddings_type
+                    )
+                    break
+                except InvalidArgument:
+                    had_failure = True
+                    first_batch_len = len(first_batch)
+                    if first_batch_len == self.instance["min_batch_size"]:
+                        raise
+                    first_batch_len = max(
+                        self.instance["min_batch_size"], int(first_batch_len / 2)
+                    )
+                    first_batch = first_batch[:first_batch_len]
+            first_batch_len = len(first_batch)
+            self.instance["min_good_batch_size"] = max(
+                self.instance["min_good_batch_size"], first_batch_len
+            )
+            # If had a failure and recovered
+            # or went through with the max size, then it's a legit batch size.
+            if had_failure or first_batch_len == self.instance["max_batch_size"]:
+                self.instance["batch_size"] = first_batch_len
+                self.instance["batch_size_validated"] = True
+                # If batch size was updated,
+                # rebuild batches with the new batch size
+                # (texts that went through are excluded here).
+                if first_batch_len != self.instance["max_batch_size"]:
+                    batches = VertexAIEmbeddings._prepare_batches(
+                        texts[first_batch_len:], self.instance["batch_size"]
+                    )
+            else:
+                # Still figuring out max batch size.
+                batches = batches[1:]
+        # Returning embeddings of the first text batch that went through,
+        # and text batches for the rest of texts.
+        return first_result, batches
+
+    def embed(
+        self,
+        texts: List[str],
+        batch_size: int = 0,
+        embeddings_task_type: Optional[
+            Literal[
+                "RETRIEVAL_QUERY",
+                "RETRIEVAL_DOCUMENT",
+                "SEMANTIC_SIMILARITY",
+                "CLASSIFICATION",
+                "CLUSTERING",
+            ]
+        ] = None,
+    ) -> List[List[float]]:
+        """Embed a list of strings.
+
+        Args:
+            texts: List[str] The list of strings to embed.
+            batch_size: [int] The batch size of embeddings to send to the model.
+                If zero, then the largest batch size will be detected dynamically
+                at the first request, starting from 250, down to 5.
+            embeddings_task_type: [str] optional embeddings task type,
+                one of the following
+                    RETRIEVAL_QUERY	- Text is a query
+                                      in a search/retrieval setting.
+                    RETRIEVAL_DOCUMENT - Text is a document
+                                         in a search/retrieval setting.
+                    SEMANTIC_SIMILARITY - Embeddings will be used
+                                          for Semantic Textual Similarity (STS).
+                    CLASSIFICATION - Embeddings will be used for classification.
+                    CLUSTERING - Embeddings will be used for clustering.
+
+        Returns:
+            List of embeddings, one for each text.
+        """
+        if len(texts) == 0:
+            return []
+        embeddings: List[List[float]] = []
+        first_batch_result: List[List[float]] = []
+        if batch_size > 0:
+            # Fixed batch size.
+            batches = VertexAIEmbeddings._prepare_batches(texts, batch_size)
+        else:
+            # Dynamic batch size, starting from 250 at the first call.
+            first_batch_result, batches = self._prepare_and_validate_batches(
+                texts, embeddings_task_type
+            )
+        # First batch result may have some embeddings already.
+        # In such case, batches have texts that were not processed yet.
+        embeddings.extend(first_batch_result)
+        tasks = []
+        if self.show_progress_bar:
+            try:
+                from tqdm import tqdm
+
+                iter_ = tqdm(batches, desc="VertexAIEmbeddings")
+            except ImportError:
+                logger.warning(
+                    "Unable to show progress bar because tqdm could not be imported. "
+                    "Please install with `pip install tqdm`."
+                )
+                iter_ = batches
+        else:
+            iter_ = batches
+        for batch in iter_:
+            tasks.append(
+                self.instance["task_executor"].submit(
+                    self._get_embeddings_with_retry,
+                    texts=batch,
+                    embeddings_type=embeddings_task_type,
+                )
+            )
+        if len(tasks) > 0:
+            wait(tasks)
+        for t in tasks:
+            embeddings.extend(t.result())
+        return embeddings
+
+    def embed_documents(
+        self, texts: List[str], batch_size: int = 0
+    ) -> List[List[float]]:
+        """Embed a list of documents.
+
+        Args:
+            texts: List[str] The list of texts to embed.
+            batch_size: [int] The batch size of embeddings to send to the model.
+                If zero, then the largest batch size will be detected dynamically
+                at the first request, starting from 250, down to 5.
+
+        Returns:
+            List of embeddings, one for each text.
+        """
+        return self.embed(texts, batch_size, "RETRIEVAL_DOCUMENT")
+
+    def embed_query(self, text: str) -> List[float]:
+        """Embed a text.
+
+        Args:
+            text: The text to embed.
+
+        Returns:
+            Embedding for the text.
+        """
+        embeddings = self.embed([text], 1, "RETRIEVAL_QUERY")
+        return embeddings[0]

python/user_packages/Python313/site-packages/langchain_community/embeddings/volcengine.py

@@ -0,0 +1,128 @@
+from __future__ import annotations
+
+import logging
+from typing import Any, Dict, List, Optional
+
+from langchain_core.embeddings import Embeddings
+from langchain_core.utils import get_from_dict_or_env, pre_init
+from pydantic import BaseModel
+
+logger = logging.getLogger(__name__)
+
+
+class VolcanoEmbeddings(BaseModel, Embeddings):
+    """`Volcengine Embeddings` embedding models."""
+
+    volcano_ak: Optional[str] = None
+    """volcano access key
+    learn more from: https://www.volcengine.com/docs/6459/76491#ak-sk"""
+
+    volcano_sk: Optional[str] = None
+    """volcano secret key
+    learn more from: https://www.volcengine.com/docs/6459/76491#ak-sk"""
+
+    host: str = "maas-api.ml-platform-cn-beijing.volces.com"
+    """host
+    learn more from https://www.volcengine.com/docs/82379/1174746"""
+    region: str = "cn-beijing"
+    """region
+    learn more from https://www.volcengine.com/docs/82379/1174746"""
+
+    model: str = "bge-large-zh"
+    """Model name
+    you could get from https://www.volcengine.com/docs/82379/1174746
+    for now, we support bge_large_zh
+    """
+
+    version: str = "1.0"
+    """ model version """
+
+    chunk_size: int = 100
+    """Chunk size when multiple texts are input"""
+
+    client: Any
+    """volcano client"""
+
+    @pre_init
+    def validate_environment(cls, values: Dict) -> Dict:
+        """
+        Validate whether volcano_ak and volcano_sk in the environment variables or
+        configuration file are available or not.
+
+        init volcano embedding client with `ak`, `sk`, `host`, `region`
+
+        Args:
+
+            values: a dictionary containing configuration information, must include the
+            fields of volcano_ak and volcano_sk
+        Returns:
+
+            a dictionary containing configuration information. If volcano_ak and
+            volcano_sk are not provided in the environment variables or configuration
+            file,the original values will be returned; otherwise, values containing
+            volcano_ak and volcano_sk will be returned.
+        Raises:
+
+            ValueError: volcengine package not found, please install it with
+            `pip install volcengine`
+        """
+        values["volcano_ak"] = get_from_dict_or_env(
+            values,
+            "volcano_ak",
+            "VOLC_ACCESSKEY",
+        )
+        values["volcano_sk"] = get_from_dict_or_env(
+            values,
+            "volcano_sk",
+            "VOLC_SECRETKEY",
+        )
+
+        try:
+            from volcengine.maas import MaasService
+
+            client = MaasService(values["host"], values["region"])
+            client.set_ak(values["volcano_ak"])
+            client.set_sk(values["volcano_sk"])
+            values["client"] = client
+        except ImportError:
+            raise ImportError(
+                "volcengine package not found, please install it with "
+                "`pip install volcengine`"
+            )
+        return values
+
+    def embed_query(self, text: str) -> List[float]:
+        return self.embed_documents([text])[0]
+
+    def embed_documents(self, texts: List[str]) -> List[List[float]]:
+        """
+        Embeds a list of text documents using the AutoVOT algorithm.
+
+        Args:
+            texts (List[str]): A list of text documents to embed.
+
+        Returns:
+            List[List[float]]: A list of embeddings for each document in the input list.
+                            Each embedding is represented as a list of float values.
+        """
+        text_in_chunks = [
+            texts[i : i + self.chunk_size]
+            for i in range(0, len(texts), self.chunk_size)
+        ]
+        lst = []
+        for chunk in text_in_chunks:
+            req = {
+                "model": {
+                    "name": self.model,
+                    "version": self.version,
+                },
+                "input": chunk,
+            }
+            try:
+                from volcengine.maas import MaasException
+
+                resp = self.client.embeddings(req)
+                lst.extend([res["embedding"] for res in resp["data"]])
+            except MaasException as e:
+                raise ValueError(f"embed by volcengine Error: {e}")
+        return lst

python/user_packages/Python313/site-packages/langchain_community/embeddings/voyageai.py

@@ -0,0 +1,230 @@
+from __future__ import annotations
+
+import json
+import logging
+from typing import (
+    Any,
+    Callable,
+    Dict,
+    List,
+    Optional,
+    Tuple,
+    Union,
+    cast,
+)
+
+import requests
+from langchain_core._api.deprecation import deprecated
+from langchain_core.embeddings import Embeddings
+from langchain_core.utils import convert_to_secret_str, get_from_dict_or_env
+from pydantic import BaseModel, ConfigDict, SecretStr, model_validator
+from tenacity import (
+    before_sleep_log,
+    retry,
+    stop_after_attempt,
+    wait_exponential,
+)
+
+logger = logging.getLogger(__name__)
+
+
+def _create_retry_decorator(embeddings: VoyageEmbeddings) -> Callable[[Any], Any]:
+    min_seconds = 4
+    max_seconds = 10
+    # Wait 2^x * 1 second between each retry starting with
+    # 4 seconds, then up to 10 seconds, then 10 seconds afterwards
+    return retry(
+        reraise=True,
+        stop=stop_after_attempt(embeddings.max_retries),
+        wait=wait_exponential(multiplier=1, min=min_seconds, max=max_seconds),
+        before_sleep=before_sleep_log(logger, logging.WARNING),
+    )
+
+
+def _check_response(response: dict) -> dict:
+    if "data" not in response:
+        raise RuntimeError(f"Voyage API Error. Message: {json.dumps(response)}")
+    return response
+
+
+def embed_with_retry(embeddings: VoyageEmbeddings, **kwargs: Any) -> Any:
+    """Use tenacity to retry the embedding call."""
+    retry_decorator = _create_retry_decorator(embeddings)
+
+    @retry_decorator
+    def _embed_with_retry(**kwargs: Any) -> Any:
+        response = requests.post(**kwargs)
+        return _check_response(response.json())
+
+    return _embed_with_retry(**kwargs)
+
+
+@deprecated(
+    since="0.0.29",
+    removal="1.0",
+    alternative_import="langchain_voyageai.VoyageAIEmbeddings",
+)
+class VoyageEmbeddings(BaseModel, Embeddings):
+    """Voyage embedding models.
+
+    To use, you should have the environment variable ``VOYAGE_API_KEY`` set with
+    your API key or pass it as a named parameter to the constructor.
+
+    Example:
+        .. code-block:: python
+
+            from langchain_community.embeddings import VoyageEmbeddings
+
+            voyage = VoyageEmbeddings(voyage_api_key="your-api-key", model="voyage-2")
+            text = "This is a test query."
+            query_result = voyage.embed_query(text)
+    """
+
+    model: str
+    voyage_api_base: str = "https://api.voyageai.com/v1/embeddings"
+    voyage_api_key: Optional[SecretStr] = None
+    batch_size: int
+    """Maximum number of texts to embed in each API request."""
+    max_retries: int = 6
+    """Maximum number of retries to make when generating."""
+    request_timeout: Optional[Union[float, Tuple[float, float]]] = None
+    """Timeout in seconds for the API request."""
+    show_progress_bar: bool = False
+    """Whether to show a progress bar when embedding. Must have tqdm installed if set 
+        to True."""
+    truncation: bool = True
+    """Whether to truncate the input texts to fit within the context length.
+    
+        If True, over-length input texts will be truncated to fit within the context 
+        length, before vectorized by the embedding model. If False, an error will be 
+        raised if any given text exceeds the context length."""
+
+    model_config = ConfigDict(
+        extra="forbid",
+    )
+
+    @model_validator(mode="before")
+    @classmethod
+    def validate_environment(cls, values: Dict) -> Any:
+        """Validate that api key and python package exists in environment."""
+        values["voyage_api_key"] = convert_to_secret_str(
+            get_from_dict_or_env(values, "voyage_api_key", "VOYAGE_API_KEY")
+        )
+
+        if "model" not in values:
+            values["model"] = "voyage-01"
+            logger.warning(
+                "model will become a required arg for VoyageAIEmbeddings, "
+                "we recommend to specify it when using this class. "
+                "Currently the default is set to voyage-01."
+            )
+
+        if "batch_size" not in values:
+            values["batch_size"] = (
+                72
+                if "model" in values and (values["model"] in ["voyage-2", "voyage-02"])
+                else 7
+            )
+
+        return values
+
+    def _invocation_params(
+        self, input: List[str], input_type: Optional[str] = None
+    ) -> Dict:
+        api_key = cast(SecretStr, self.voyage_api_key).get_secret_value()
+        params: Dict = {
+            "url": self.voyage_api_base,
+            "headers": {"Authorization": f"Bearer {api_key}"},
+            "json": {
+                "model": self.model,
+                "input": input,
+                "input_type": input_type,
+                "truncation": self.truncation,
+            },
+            "timeout": self.request_timeout,
+        }
+        return params
+
+    def _get_embeddings(
+        self,
+        texts: List[str],
+        batch_size: Optional[int] = None,
+        input_type: Optional[str] = None,
+    ) -> List[List[float]]:
+        embeddings: List[List[float]] = []
+
+        if batch_size is None:
+            batch_size = self.batch_size
+
+        if self.show_progress_bar:
+            try:
+                from tqdm.auto import tqdm
+            except ImportError as e:
+                raise ImportError(
+                    "Must have tqdm installed if `show_progress_bar` is set to True. "
+                    "Please install with `pip install tqdm`."
+                ) from e
+
+            _iter = tqdm(range(0, len(texts), batch_size))
+        else:
+            _iter = range(0, len(texts), batch_size)
+
+        if input_type and input_type not in ["query", "document"]:
+            raise ValueError(
+                f"input_type {input_type} is invalid. Options: None, 'query', "
+                "'document'."
+            )
+
+        for i in _iter:
+            response = embed_with_retry(
+                self,
+                **self._invocation_params(
+                    input=texts[i : i + batch_size], input_type=input_type
+                ),
+            )
+            embeddings.extend(r["embedding"] for r in response["data"])
+
+        return embeddings
+
+    def embed_documents(self, texts: List[str]) -> List[List[float]]:
+        """Call out to Voyage Embedding endpoint for embedding search docs.
+
+        Args:
+            texts: The list of texts to embed.
+
+        Returns:
+            List of embeddings, one for each text.
+        """
+        return self._get_embeddings(
+            texts, batch_size=self.batch_size, input_type="document"
+        )
+
+    def embed_query(self, text: str) -> List[float]:
+        """Call out to Voyage Embedding endpoint for embedding query text.
+
+        Args:
+            text: The text to embed.
+
+        Returns:
+            Embedding for the text.
+        """
+        return self._get_embeddings(
+            [text], batch_size=self.batch_size, input_type="query"
+        )[0]
+
+    def embed_general_texts(
+        self, texts: List[str], *, input_type: Optional[str] = None
+    ) -> List[List[float]]:
+        """Call out to Voyage Embedding endpoint for embedding general text.
+
+        Args:
+            texts: The list of texts to embed.
+            input_type: Type of the input text. Default to None, meaning the type is
+                unspecified. Other options: query, document.
+
+        Returns:
+            Embedding for the text.
+        """
+        return self._get_embeddings(
+            texts, batch_size=self.batch_size, input_type=input_type
+        )

python/user_packages/Python313/site-packages/langchain_community/embeddings/xinference.py

@@ -0,0 +1,139 @@
+"""Wrapper around Xinference embedding models."""
+
+from typing import Any, List, Optional
+
+from langchain_core.embeddings import Embeddings
+
+
+class XinferenceEmbeddings(Embeddings):
+    """Xinference embedding models.
+
+    To use, you should have the xinference library installed:
+
+    .. code-block:: bash
+
+        pip install xinference
+
+    If you're simply using the services provided by Xinference, you can utilize the xinference_client package:
+
+    .. code-block:: bash
+
+        pip install xinference_client
+
+    Check out: https://github.com/xorbitsai/inference
+    To run, you need to start a Xinference supervisor on one server and Xinference workers on the other servers.
+
+    Example:
+        To start a local instance of Xinference, run
+
+        .. code-block:: bash
+
+           $ xinference
+
+        You can also deploy Xinference in a distributed cluster. Here are the steps:
+
+        Starting the supervisor:
+
+        .. code-block:: bash
+
+           $ xinference-supervisor
+
+        If you're simply using the services provided by Xinference, you can utilize the xinference_client package:
+
+        .. code-block:: bash
+
+            pip install xinference_client
+
+        Starting the worker:
+
+        .. code-block:: bash
+
+           $ xinference-worker
+
+    Then, launch a model using command line interface (CLI).
+
+    Example:
+
+    .. code-block:: bash
+
+       $ xinference launch -n orca -s 3 -q q4_0
+
+    It will return a model UID. Then you can use Xinference Embedding with LangChain.
+
+    Example:
+
+    .. code-block:: python
+
+        from langchain_community.embeddings import XinferenceEmbeddings
+
+        xinference = XinferenceEmbeddings(
+            server_url="http://0.0.0.0:9997",
+            model_uid = {model_uid} # replace model_uid with the model UID return from launching the model
+        )
+
+    """  # noqa: E501
+
+    client: Any
+    server_url: Optional[str]
+    """URL of the xinference server"""
+    model_uid: Optional[str]
+    """UID of the launched model"""
+
+    def __init__(
+        self, server_url: Optional[str] = None, model_uid: Optional[str] = None
+    ):
+        try:
+            from xinference.client import RESTfulClient
+        except ImportError:
+            try:
+                from xinference_client import RESTfulClient
+            except ImportError as e:
+                raise ImportError(
+                    "Could not import RESTfulClient from xinference. Please install it"
+                    " with `pip install xinference` or `pip install xinference_client`."
+                ) from e
+
+        super().__init__()
+
+        if server_url is None:
+            raise ValueError("Please provide server URL")
+
+        if model_uid is None:
+            raise ValueError("Please provide the model UID")
+
+        self.server_url = server_url
+
+        self.model_uid = model_uid
+
+        self.client = RESTfulClient(server_url)
+
+    def embed_documents(self, texts: List[str]) -> List[List[float]]:
+        """Embed a list of documents using Xinference.
+        Args:
+            texts: The list of texts to embed.
+        Returns:
+            List of embeddings, one for each text.
+        """
+
+        model = self.client.get_model(self.model_uid)
+
+        embeddings = [
+            model.create_embedding(text)["data"][0]["embedding"] for text in texts
+        ]
+        return [list(map(float, e)) for e in embeddings]
+
+    def embed_query(self, text: str) -> List[float]:
+        """Embed a query of documents using Xinference.
+        Args:
+            text: The text to embed.
+        Returns:
+            Embeddings for the text.
+        """
+
+        model = self.client.get_model(self.model_uid)
+
+        embedding_res = model.create_embedding(text)
+
+        embedding = embedding_res["data"][0]["embedding"]
+
+        return list(map(float, embedding))

python/user_packages/Python313/site-packages/langchain_community/embeddings/yandex.py

@@ -0,0 +1,214 @@
+"""Wrapper around YandexGPT embedding models."""
+
+from __future__ import annotations
+
+import logging
+import time
+from typing import Any, Callable, Dict, List, Sequence
+
+from langchain_core.embeddings import Embeddings
+from langchain_core.utils import convert_to_secret_str, get_from_dict_or_env, pre_init
+from pydantic import BaseModel, ConfigDict, Field, SecretStr
+from tenacity import (
+    before_sleep_log,
+    retry,
+    retry_if_exception_type,
+    stop_after_attempt,
+    wait_exponential,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class YandexGPTEmbeddings(BaseModel, Embeddings):
+    """YandexGPT Embeddings models.
+
+    To use, you should have the ``yandexcloud`` python package installed.
+
+    There are two authentication options for the service account
+    with the ``ai.languageModels.user`` role:
+        - You can specify the token in a constructor parameter `iam_token`
+        or in an environment variable `YC_IAM_TOKEN`.
+        - You can specify the key in a constructor parameter `api_key`
+        or in an environment variable `YC_API_KEY`.
+
+    To use the default model specify the folder ID in a parameter `folder_id`
+    or in an environment variable `YC_FOLDER_ID`.
+
+    Example:
+        .. code-block:: python
+
+            from langchain_community.embeddings.yandex import YandexGPTEmbeddings
+            embeddings = YandexGPTEmbeddings(iam_token="t1.9eu...", folder_id=<folder-id>)
+    """  # noqa: E501
+
+    iam_token: SecretStr = ""  # type: ignore[assignment]
+    """Yandex Cloud IAM token for service account
+    with the `ai.languageModels.user` role"""
+    api_key: SecretStr = ""  # type: ignore[assignment]
+    """Yandex Cloud Api Key for service account
+    with the `ai.languageModels.user` role"""
+    model_uri: str = Field(default="", alias="query_model_uri")
+    """Query model uri to use."""
+    doc_model_uri: str = ""
+    """Doc model uri to use."""
+    folder_id: str = ""
+    """Yandex Cloud folder ID"""
+    doc_model_name: str = "text-search-doc"
+    """Doc model name to use."""
+    model_name: str = Field(default="text-search-query", alias="query_model_name")
+    """Query model name to use."""
+    model_version: str = "latest"
+    """Model version to use."""
+    url: str = "llm.api.cloud.yandex.net:443"
+    """The url of the API."""
+    max_retries: int = 6
+    """Maximum number of retries to make when generating."""
+    sleep_interval: float = 0.0
+    """Delay between API requests"""
+    disable_request_logging: bool = False
+    """YandexGPT API logs all request data by default. 
+    If you provide personal data, confidential information, disable logging."""
+    grpc_metadata: Sequence
+
+    model_config = ConfigDict(populate_by_name=True, protected_namespaces=())
+
+    @pre_init
+    def validate_environment(cls, values: Dict) -> Dict:
+        """Validate that iam token exists in environment."""
+
+        iam_token = convert_to_secret_str(
+            get_from_dict_or_env(values, "iam_token", "YC_IAM_TOKEN", "")
+        )
+        values["iam_token"] = iam_token
+        api_key = convert_to_secret_str(
+            get_from_dict_or_env(values, "api_key", "YC_API_KEY", "")
+        )
+        values["api_key"] = api_key
+        folder_id = get_from_dict_or_env(values, "folder_id", "YC_FOLDER_ID", "")
+        values["folder_id"] = folder_id
+        if api_key.get_secret_value() == "" and iam_token.get_secret_value() == "":
+            raise ValueError("Either 'YC_API_KEY' or 'YC_IAM_TOKEN' must be provided.")
+        if values["iam_token"]:
+            values["grpc_metadata"] = [
+                ("authorization", f"Bearer {values['iam_token'].get_secret_value()}")
+            ]
+            if values["folder_id"]:
+                values["grpc_metadata"].append(("x-folder-id", values["folder_id"]))
+        else:
+            values["grpc_metadata"] = [
+                ("authorization", f"Api-Key {values['api_key'].get_secret_value()}"),
+            ]
+
+        if not values.get("doc_model_uri"):
+            if values["folder_id"] == "":
+                raise ValueError("'doc_model_uri' or 'folder_id' must be provided.")
+            values["doc_model_uri"] = (
+                f"emb://{values['folder_id']}/{values['doc_model_name']}/{values['model_version']}"
+            )
+        if not values.get("model_uri"):
+            if values["folder_id"] == "":
+                raise ValueError("'model_uri' or 'folder_id' must be provided.")
+            values["model_uri"] = (
+                f"emb://{values['folder_id']}/{values['model_name']}/{values['model_version']}"
+            )
+        if values["disable_request_logging"]:
+            values["grpc_metadata"].append(
+                (
+                    "x-data-logging-enabled",
+                    "false",
+                )
+            )
+        return values
+
+    def embed_documents(self, texts: List[str]) -> List[List[float]]:
+        """Embed documents using a YandexGPT embeddings models.
+
+        Args:
+            texts: The list of texts to embed.
+
+        Returns:
+            List of embeddings, one for each text.
+        """
+
+        return _embed_with_retry(self, texts=texts)
+
+    def embed_query(self, text: str) -> List[float]:
+        """Embed a query using a YandexGPT embeddings models.
+
+        Args:
+            text: The text to embed.
+
+        Returns:
+            Embeddings for the text.
+        """
+        return _embed_with_retry(self, texts=[text], embed_query=True)[0]
+
+
+def _create_retry_decorator(llm: YandexGPTEmbeddings) -> Callable[[Any], Any]:
+    from grpc import RpcError
+
+    min_seconds = 1
+    max_seconds = 60
+    return retry(
+        reraise=True,
+        stop=stop_after_attempt(llm.max_retries),
+        wait=wait_exponential(multiplier=1, min=min_seconds, max=max_seconds),
+        retry=(retry_if_exception_type((RpcError))),
+        before_sleep=before_sleep_log(logger, logging.WARNING),
+    )
+
+
+def _embed_with_retry(llm: YandexGPTEmbeddings, **kwargs: Any) -> list[list[float]]:
+    """Use tenacity to retry the embedding call."""
+    retry_decorator = _create_retry_decorator(llm)
+
+    @retry_decorator
+    def _completion_with_retry(**_kwargs: Any) -> list[list[float]]:
+        return _make_request(llm, **_kwargs)
+
+    return _completion_with_retry(**kwargs)
+
+
+def _make_request(
+    self: YandexGPTEmbeddings, texts: List[str], **kwargs: Any
+) -> list[list[float]]:
+    try:
+        import grpc
+
+        try:
+            from yandex.cloud.ai.foundation_models.v1.embedding.embedding_service_pb2 import (  # noqa: E501
+                TextEmbeddingRequest,
+            )
+            from yandex.cloud.ai.foundation_models.v1.embedding.embedding_service_pb2_grpc import (  # noqa: E501
+                EmbeddingsServiceStub,
+            )
+        except ModuleNotFoundError:
+            from yandex.cloud.ai.foundation_models.v1.foundation_models_service_pb2 import (  # noqa: E501
+                TextEmbeddingRequest,
+            )
+            from yandex.cloud.ai.foundation_models.v1.foundation_models_service_pb2_grpc import (  # noqa: E501
+                EmbeddingsServiceStub,
+            )
+    except ImportError as e:
+        raise ImportError(
+            "Please install YandexCloud SDK  with `pip install yandexcloud` \
+            or upgrade it to recent version."
+        ) from e
+    result = []
+    channel_credentials = grpc.ssl_channel_credentials()
+    channel = grpc.secure_channel(self.url, channel_credentials)
+    # Use the query model if embed_query is True
+    if kwargs.get("embed_query"):
+        model_uri = self.model_uri
+    else:
+        model_uri = self.doc_model_uri
+
+    for text in texts:
+        request = TextEmbeddingRequest(model_uri=model_uri, text=text)
+        stub = EmbeddingsServiceStub(channel)
+        res = stub.TextEmbedding(request, metadata=self.grpc_metadata)
+        result.append(list(res.embedding))
+        time.sleep(self.sleep_interval)
+
+    return result

python/user_packages/Python313/site-packages/langchain_community/embeddings/zhipuai.py

@@ -0,0 +1,128 @@
+from typing import Any, Dict, List, Optional
+
+from langchain_core.embeddings import Embeddings
+from langchain_core.utils import get_from_dict_or_env
+from pydantic import BaseModel, Field, model_validator
+
+
+class ZhipuAIEmbeddings(BaseModel, Embeddings):
+    """ZhipuAI embedding model integration.
+
+    Setup:
+
+        To use, you should have the ``zhipuai`` python package installed, and the
+        environment variable ``ZHIPU_API_KEY`` set with your API KEY.
+
+        More instructions about ZhipuAi Embeddings, you can get it
+        from  https://open.bigmodel.cn/dev/api#vector
+
+        .. code-block:: bash
+
+            pip install -U zhipuai
+            export ZHIPU_API_KEY="your-api-key"
+
+    Key init args — completion params:
+        model: Optional[str]
+            Name of ZhipuAI model to use.
+        api_key: str
+            Automatically inferred from env var `ZHIPU_API_KEY` if not provided.
+
+    See full list of supported init args and their descriptions in the params section.
+
+    Instantiate:
+
+        .. code-block:: python
+
+            from langchain_community.embeddings import ZhipuAIEmbeddings
+
+            embed = ZhipuAIEmbeddings(
+                model="embedding-2",
+                # api_key="...",
+            )
+
+    Embed single text:
+        .. code-block:: python
+
+            input_text = "The meaning of life is 42"
+            embed.embed_query(input_text)
+
+        .. code-block:: python
+
+            [-0.003832892, 0.049372625, -0.035413884, -0.019301128, 0.0068899863, 0.01248398, -0.022153955, 0.006623926, 0.00778216, 0.009558191, ...]
+
+
+    Embed multiple text:
+        .. code-block:: python
+
+            input_texts = ["This is a test query1.", "This is a test query2."]
+            embed.embed_documents(input_texts)
+
+        .. code-block:: python
+
+            [
+                [0.0083934665, 0.037985895, -0.06684559, -0.039616987, 0.015481004, -0.023952313, ...],
+                [-0.02713102, -0.005470169, 0.032321047, 0.042484466, 0.023290444, 0.02170547, ...]
+            ]
+    """  # noqa: E501
+
+    client: Any = Field(default=None, exclude=True)  #: :meta private:
+    model: str = Field(default="embedding-2")
+    """Model name"""
+    api_key: str
+    """Automatically inferred from env var `ZHIPU_API_KEY` if not provided."""
+    dimensions: Optional[int] = None
+    """The number of dimensions the resulting output embeddings should have.
+
+    Only supported in `embedding-3` and later models.
+    """
+
+    @model_validator(mode="before")
+    @classmethod
+    def validate_environment(cls, values: Dict) -> Any:
+        """Validate that auth token exists in environment."""
+        values["api_key"] = get_from_dict_or_env(values, "api_key", "ZHIPUAI_API_KEY")
+        try:
+            from zhipuai import ZhipuAI
+
+            values["client"] = ZhipuAI(api_key=values["api_key"])
+        except ImportError:
+            raise ImportError(
+                "Could not import zhipuai python package."
+                "Please install it with `pip install zhipuai`."
+            )
+        return values
+
+    def embed_query(self, text: str) -> List[float]:
+        """
+        Embeds a text using the AutoVOT algorithm.
+
+        Args:
+            text: A text to embed.
+
+        Returns:
+            Input document's embedded list.
+        """
+        resp = self.embed_documents([text])
+        return resp[0]
+
+    def embed_documents(self, texts: List[str]) -> List[List[float]]:
+        """
+        Embeds a list of text documents using the AutoVOT algorithm.
+
+        Args:
+            texts: A list of text documents to embed.
+
+        Returns:
+            A list of embeddings for each document in the input list.
+            Each embedding is represented as a list of float values.
+        """
+        if self.dimensions is not None:
+            resp = self.client.embeddings.create(
+                model=self.model,
+                input=texts,
+                dimensions=self.dimensions,
+            )
+        else:
+            resp = self.client.embeddings.create(model=self.model, input=texts)
+        embeddings = [r.embedding for r in resp.data]
+        return embeddings

python/user_packages/Python313/site-packages/langchain_community/example_selectors/__init__.py

@@ -0,0 +1,18 @@
+"""**Example selector** implements logic for selecting examples to include them
+in prompts.
+This allows us to select examples that are most relevant to the input.
+
+There could be multiple strategies for selecting examples. For example, one could
+select examples based on the similarity of the input to the examples. Another
+strategy could be to select examples based on the diversity of the examples.
+"""
+
+from langchain_community.example_selectors.ngram_overlap import (
+    NGramOverlapExampleSelector,
+    ngram_overlap_score,
+)
+
+__all__ = [
+    "NGramOverlapExampleSelector",
+    "ngram_overlap_score",
+]

python/user_packages/Python313/site-packages/langchain_community/example_selectors/ngram_overlap.py

@@ -0,0 +1,116 @@
+"""Select and order examples based on ngram overlap score (sentence_bleu score).
+
+https://www.nltk.org/_modules/nltk/translate/bleu_score.html
+https://aclanthology.org/P02-1040.pdf
+"""
+
+from typing import Any, Dict, List
+
+import numpy as np
+from langchain_core.example_selectors import BaseExampleSelector
+from langchain_core.prompts import PromptTemplate
+from pydantic import BaseModel, model_validator
+
+
+def ngram_overlap_score(source: List[str], example: List[str]) -> float:
+    """Compute ngram overlap score of source and example as sentence_bleu score
+    from NLTK package.
+
+    Use sentence_bleu with method1 smoothing function and auto reweighting.
+    Return float value between 0.0 and 1.0 inclusive.
+    https://www.nltk.org/_modules/nltk/translate/bleu_score.html
+    https://aclanthology.org/P02-1040.pdf
+    """
+    from nltk.translate.bleu_score import (
+        SmoothingFunction,
+        sentence_bleu,
+    )
+
+    hypotheses = source[0].split()
+    references = [s.split() for s in example]
+
+    return float(
+        sentence_bleu(
+            references,
+            hypotheses,
+            smoothing_function=SmoothingFunction().method1,
+            auto_reweigh=True,
+        )
+    )
+
+
+class NGramOverlapExampleSelector(BaseExampleSelector, BaseModel):
+    """Select and order examples based on ngram overlap score (sentence_bleu score
+    from NLTK package).
+
+    https://www.nltk.org/_modules/nltk/translate/bleu_score.html
+    https://aclanthology.org/P02-1040.pdf
+    """
+
+    examples: List[dict]
+    """A list of the examples that the prompt template expects."""
+
+    example_prompt: PromptTemplate
+    """Prompt template used to format the examples."""
+
+    threshold: float = -1.0
+    """Threshold at which algorithm stops. Set to -1.0 by default.
+
+    For negative threshold:
+    select_examples sorts examples by ngram_overlap_score, but excludes none.
+    For threshold greater than 1.0:
+    select_examples excludes all examples, and returns an empty list.
+    For threshold equal to 0.0:
+    select_examples sorts examples by ngram_overlap_score,
+    and excludes examples with no ngram overlap with input.
+    """
+
+    @model_validator(mode="before")
+    @classmethod
+    def check_dependencies(cls, values: Dict) -> Any:
+        """Check that valid dependencies exist."""
+        try:
+            from nltk.translate.bleu_score import (  # noqa: F401
+                SmoothingFunction,
+                sentence_bleu,
+            )
+        except ImportError as e:
+            raise ImportError(
+                "Not all the correct dependencies for this ExampleSelect exist."
+                "Please install nltk with `pip install nltk`."
+            ) from e
+
+        return values
+
+    def add_example(self, example: Dict[str, str]) -> None:
+        """Add new example to list."""
+        self.examples.append(example)
+
+    def select_examples(self, input_variables: Dict[str, str]) -> List[dict]:
+        """Return list of examples sorted by ngram_overlap_score with input.
+
+        Descending order.
+        Excludes any examples with ngram_overlap_score less than or equal to threshold.
+        """
+        inputs = list(input_variables.values())
+        examples = []
+        k = len(self.examples)
+        score = [0.0] * k
+        first_prompt_template_key = self.example_prompt.input_variables[0]
+
+        for i in range(k):
+            score[i] = ngram_overlap_score(
+                inputs, [self.examples[i][first_prompt_template_key]]
+            )
+
+        while True:
+            arg_max = np.argmax(score)
+            if (score[arg_max] < self.threshold) or abs(
+                score[arg_max] - self.threshold
+            ) < 1e-9:
+                break
+
+            examples.append(self.examples[arg_max])
+            score[arg_max] = self.threshold - 1.0
+
+        return examples

python/user_packages/Python313/site-packages/langchain_community/graph_vectorstores/__init__.py

@@ -0,0 +1,157 @@
+""".. title:: Graph Vector Store
+
+Graph Vector Store
+==================
+
+Sometimes embedding models don't capture all the important relationships between
+documents.
+Graph Vector Stores are an extension to both vector stores and retrievers that allow
+documents to be explicitly connected to each other.
+
+Graph vector store retrievers use both vector similarity and links to find documents
+related to an unstructured query.
+
+Graphs allow linking between documents.
+Each document identifies tags that link to and from it.
+For example, a paragraph of text may be linked to URLs based on the anchor tags in
+it's content and linked from the URL(s) it is published at.
+
+`Link extractors <langchain_community.graph_vectorstores.extractors.link_extractor.LinkExtractor>`
+can be used to extract links from documents.
+
+Example::
+
+    graph_vector_store = CassandraGraphVectorStore()
+    link_extractor = HtmlLinkExtractor()
+    links = link_extractor.extract_one(HtmlInput(document.page_content, "http://mysite"))
+    add_links(document, links)
+    graph_vector_store.add_document(document)
+
+.. seealso::
+
+    - :class:`How to use a graph vector store as a retriever <langchain_community.graph_vectorstores.base.GraphVectorStoreRetriever>`
+    - :class:`How to create links between documents <langchain_community.graph_vectorstores.links.Link>`
+    - :class:`How to link Documents on hyperlinks in HTML <langchain_community.graph_vectorstores.extractors.html_link_extractor.HtmlLinkExtractor>`
+    - :class:`How to link Documents on common keywords (using KeyBERT) <langchain_community.graph_vectorstores.extractors.keybert_link_extractor.KeybertLinkExtractor>`
+    - :class:`How to link Documents on common named entities (using GliNER) <langchain_community.graph_vectorstores.extractors.gliner_link_extractor.GLiNERLinkExtractor>`
+    - `langchain-jieba: link extraction tailored for Chinese language <https://github.com/cqzyys/langchain-jieba>`_
+
+Get started
+-----------
+
+We chunk the State of the Union text and split it into documents::
+
+    from langchain_community.document_loaders import TextLoader
+    from langchain_text_splitters import CharacterTextSplitter
+
+    raw_documents = TextLoader("state_of_the_union.txt").load()
+    text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)
+    documents = text_splitter.split_documents(raw_documents)
+
+Links can be added to documents manually but it's easier to use a
+:class:`~langchain_community.graph_vectorstores.extractors.link_extractor.LinkExtractor`.
+Several common link extractors are available and you can build your own.
+For this guide, we'll use the
+:class:`~langchain_community.graph_vectorstores.extractors.keybert_link_extractor.KeybertLinkExtractor`
+which uses the KeyBERT model to tag documents with keywords and uses these keywords to
+create links between documents::
+
+    from langchain_community.graph_vectorstores.extractors import KeybertLinkExtractor
+    from langchain_community.graph_vectorstores.links import add_links
+
+    extractor = KeybertLinkExtractor()
+
+    for doc in documents:
+        add_links(doc, extractor.extract_one(doc))
+
+Create the graph vector store and add documents
+-----------------------------------------------
+
+We'll use an Apache Cassandra or Astra DB database as an example.
+We create a
+:class:`~langchain_community.graph_vectorstores.cassandra.CassandraGraphVectorStore`
+from the documents and an :class:`~langchain_openai.embeddings.base.OpenAIEmbeddings`
+model::
+
+    import cassio
+    from langchain_community.graph_vectorstores import CassandraGraphVectorStore
+    from langchain_openai import OpenAIEmbeddings
+
+    # Initialize cassio and the Cassandra session from the environment variables
+    cassio.init(auto=True)
+
+    store = CassandraGraphVectorStore.from_documents(
+        embedding=OpenAIEmbeddings(),
+        documents=documents,
+    )
+
+
+Similarity search
+-----------------
+
+If we don't traverse the graph, a graph vector store behaves like a regular vector
+store.
+So all methods available in a vector store are also available in a graph vector store.
+The :meth:`~langchain_community.graph_vectorstores.base.GraphVectorStore.similarity_search`
+method returns documents similar to a query without considering
+the links between documents::
+
+    docs = store.similarity_search(
+        "What did the president say about Ketanji Brown Jackson?"
+    )
+
+Traversal search
+----------------
+
+The :meth:`~langchain_community.graph_vectorstores.base.GraphVectorStore.traversal_search`
+method returns documents similar to a query considering the links
+between documents. It first does a similarity search and then traverses the graph to
+find linked documents::
+
+    docs = list(
+        store.traversal_search("What did the president say about Ketanji Brown Jackson?")
+    )
+
+Async methods
+-------------
+
+The graph vector store has async versions of the methods prefixed with ``a``::
+
+    docs = [
+        doc
+        async for doc in store.atraversal_search(
+            "What did the president say about Ketanji Brown Jackson?"
+        )
+    ]
+
+Graph vector store retriever
+----------------------------
+
+The graph vector store can be converted to a retriever.
+It is similar to the vector store retriever but it also has traversal search methods
+such as ``traversal`` and ``mmr_traversal``::
+
+    retriever = store.as_retriever(search_type="mmr_traversal")
+    docs = retriever.invoke("What did the president say about Ketanji Brown Jackson?")
+
+"""  # noqa: E501
+
+from langchain_community.graph_vectorstores.base import (
+    GraphVectorStore,
+    GraphVectorStoreRetriever,
+    Node,
+)
+from langchain_community.graph_vectorstores.cassandra import CassandraGraphVectorStore
+from langchain_community.graph_vectorstores.links import (
+    Link,
+)
+from langchain_community.graph_vectorstores.mmr_helper import MmrHelper
+
+__all__ = [
+    "GraphVectorStore",
+    "GraphVectorStoreRetriever",
+    "Node",
+    "Link",
+    "CassandraGraphVectorStore",
+    "MmrHelper",
+]

python/user_packages/Python313/site-packages/langchain_community/graph_vectorstores/base.py

@@ -0,0 +1,917 @@
+from __future__ import annotations
+
+import logging
+from abc import abstractmethod
+from collections.abc import AsyncIterable, Collection, Iterable, Iterator
+from typing import (
+    Any,
+    ClassVar,
+    Optional,
+    Sequence,
+    cast,
+)
+
+from langchain_core._api import deprecated
+from langchain_core.callbacks import (
+    AsyncCallbackManagerForRetrieverRun,
+    CallbackManagerForRetrieverRun,
+)
+from langchain_core.documents import Document
+from langchain_core.load import Serializable
+from langchain_core.runnables import run_in_executor
+from langchain_core.vectorstores import VectorStore, VectorStoreRetriever
+from pydantic import Field
+
+from langchain_community.graph_vectorstores.links import METADATA_LINKS_KEY, Link
+
+logger = logging.getLogger(__name__)
+
+
+def _has_next(iterator: Iterator) -> bool:
+    """Checks if the iterator has more elements.
+    Warning: consumes an element from the iterator"""
+    sentinel = object()
+    return next(iterator, sentinel) is not sentinel
+
+
+DEPRECATION_ADDENDUM = (
+    "See https://datastax.github.io/graph-rag/guide/migration/"
+    "#from-langchain-graphvectorstore for migration instructions."
+)
+
+
+@deprecated(
+    since="0.3.21",
+    removal="0.5",
+    addendum=DEPRECATION_ADDENDUM,
+)
+class Node(Serializable):
+    """Node in the GraphVectorStore.
+
+    Edges exist from nodes with an outgoing link to nodes with a matching incoming link.
+
+    For instance two nodes `a` and `b` connected over a hyperlink ``https://some-url``
+    would look like:
+
+    .. code-block:: python
+
+        [
+            Node(
+                id="a",
+                text="some text a",
+                links= [
+                    Link(kind="hyperlink", tag="https://some-url", direction="incoming")
+                ],
+            ),
+            Node(
+                id="b",
+                text="some text b",
+                links= [
+                    Link(kind="hyperlink", tag="https://some-url", direction="outgoing")
+                ],
+            )
+        ]
+    """
+
+    id: Optional[str] = None
+    """Unique ID for the node. Will be generated by the GraphVectorStore if not set."""
+    text: str
+    """Text contained by the node."""
+    metadata: dict = Field(default_factory=dict)
+    """Metadata for the node."""
+    links: list[Link] = Field(default_factory=list)
+    """Links associated with the node."""
+
+
+def _texts_to_nodes(
+    texts: Iterable[str],
+    metadatas: Optional[Iterable[dict]],
+    ids: Optional[Iterable[str]],
+) -> Iterator[Node]:
+    metadatas_it = iter(metadatas) if metadatas else None
+    ids_it = iter(ids) if ids else None
+    for text in texts:
+        try:
+            _metadata = next(metadatas_it).copy() if metadatas_it else {}
+        except StopIteration as e:
+            raise ValueError("texts iterable longer than metadatas") from e
+        try:
+            _id = next(ids_it) if ids_it else None
+        except StopIteration as e:
+            raise ValueError("texts iterable longer than ids") from e
+
+        links = _metadata.pop(METADATA_LINKS_KEY, [])
+        if not isinstance(links, list):
+            links = list(links)
+        yield Node(
+            id=_id,
+            metadata=_metadata,
+            text=text,
+            links=links,
+        )
+    if ids_it and _has_next(ids_it):
+        raise ValueError("ids iterable longer than texts")
+    if metadatas_it and _has_next(metadatas_it):
+        raise ValueError("metadatas iterable longer than texts")
+
+
+def _documents_to_nodes(documents: Iterable[Document]) -> Iterator[Node]:
+    for doc in documents:
+        metadata = doc.metadata.copy()
+        links = metadata.pop(METADATA_LINKS_KEY, [])
+        if not isinstance(links, list):
+            links = list(links)
+        yield Node(
+            id=doc.id,
+            metadata=metadata,
+            text=doc.page_content,
+            links=links,
+        )
+
+
+@deprecated(
+    since="0.3.21",
+    removal="0.5",
+    addendum=DEPRECATION_ADDENDUM,
+)
+def nodes_to_documents(nodes: Iterable[Node]) -> Iterator[Document]:
+    """Convert nodes to documents.
+
+    Args:
+        nodes: The nodes to convert to documents.
+    Returns:
+        The documents generated from the nodes.
+    """
+    for node in nodes:
+        metadata = node.metadata.copy()
+        metadata[METADATA_LINKS_KEY] = [
+            # Convert the core `Link` (from the node) back to the local `Link`.
+            Link(kind=link.kind, direction=link.direction, tag=link.tag)
+            for link in node.links
+        ]
+
+        yield Document(
+            id=node.id,
+            page_content=node.text,
+            metadata=metadata,
+        )
+
+
+@deprecated(
+    since="0.3.21",
+    removal="0.5",
+    addendum=DEPRECATION_ADDENDUM,
+)
+class GraphVectorStore(VectorStore):
+    """A hybrid vector-and-graph graph store.
+
+    Document chunks support vector-similarity search as well as edges linking
+    chunks based on structural and semantic properties.
+
+    .. versionadded:: 0.3.1
+    """
+
+    @abstractmethod
+    def add_nodes(
+        self,
+        nodes: Iterable[Node],
+        **kwargs: Any,
+    ) -> Iterable[str]:
+        """Add nodes to the graph store.
+
+        Args:
+            nodes: the nodes to add.
+            **kwargs: Additional keyword arguments.
+        """
+
+    async def aadd_nodes(
+        self,
+        nodes: Iterable[Node],
+        **kwargs: Any,
+    ) -> AsyncIterable[str]:
+        """Add nodes to the graph store.
+
+        Args:
+            nodes: the nodes to add.
+            **kwargs: Additional keyword arguments.
+        """
+        iterator = iter(await run_in_executor(None, self.add_nodes, nodes, **kwargs))
+        done = object()
+        while True:
+            doc = await run_in_executor(None, next, iterator, done)
+            if doc is done:
+                break
+            yield doc  # type: ignore[misc]
+
+    def add_texts(
+        self,
+        texts: Iterable[str],
+        metadatas: Optional[Iterable[dict]] = None,
+        *,
+        ids: Optional[Iterable[str]] = None,
+        **kwargs: Any,
+    ) -> list[str]:
+        """Run more texts through the embeddings and add to the vector store.
+
+        The Links present in the metadata field `links` will be extracted to create
+        the `Node` links.
+
+        Eg if nodes `a` and `b` are connected over a hyperlink `https://some-url`, the
+        function call would look like:
+
+        .. code-block:: python
+
+            store.add_texts(
+                ids=["a", "b"],
+                texts=["some text a", "some text b"],
+                metadatas=[
+                    {
+                        "links": [
+                            Link.incoming(kind="hyperlink", tag="https://some-url")
+                        ]
+                    },
+                    {
+                        "links": [
+                            Link.outgoing(kind="hyperlink", tag="https://some-url")
+                        ]
+                    },
+                ],
+            )
+
+        Args:
+            texts: Iterable of strings to add to the vector store.
+            metadatas: Optional list of metadatas associated with the texts.
+                The metadata key `links` shall be an iterable of
+                :py:class:`~langchain_community.graph_vectorstores.links.Link`.
+            ids: Optional list of IDs associated with the texts.
+            **kwargs: vector store specific parameters.
+
+        Returns:
+            List of ids from adding the texts into the vector store.
+        """
+        nodes = _texts_to_nodes(texts, metadatas, ids)
+        return list(self.add_nodes(nodes, **kwargs))
+
+    async def aadd_texts(
+        self,
+        texts: Iterable[str],
+        metadatas: Optional[Iterable[dict]] = None,
+        *,
+        ids: Optional[Iterable[str]] = None,
+        **kwargs: Any,
+    ) -> list[str]:
+        """Run more texts through the embeddings and add to the vector store.
+
+        The Links present in the metadata field `links` will be extracted to create
+        the `Node` links.
+
+        Eg if nodes `a` and `b` are connected over a hyperlink `https://some-url`, the
+        function call would look like:
+
+        .. code-block:: python
+
+            await store.aadd_texts(
+                ids=["a", "b"],
+                texts=["some text a", "some text b"],
+                metadatas=[
+                    {
+                        "links": [
+                            Link.incoming(kind="hyperlink", tag="https://some-url")
+                        ]
+                    },
+                    {
+                        "links": [
+                            Link.outgoing(kind="hyperlink", tag="https://some-url")
+                        ]
+                    },
+                ],
+            )
+
+        Args:
+            texts: Iterable of strings to add to the vector store.
+            metadatas: Optional list of metadatas associated with the texts.
+                The metadata key `links` shall be an iterable of
+                :py:class:`~langchain_community.graph_vectorstores.links.Link`.
+            ids: Optional list of IDs associated with the texts.
+            **kwargs: vector store specific parameters.
+
+        Returns:
+            List of ids from adding the texts into the vector store.
+        """
+        nodes = _texts_to_nodes(texts, metadatas, ids)
+        return [_id async for _id in self.aadd_nodes(nodes, **kwargs)]
+
+    def add_documents(
+        self,
+        documents: Iterable[Document],
+        **kwargs: Any,
+    ) -> list[str]:
+        """Run more documents through the embeddings and add to the vector store.
+
+        The Links present in the document metadata field `links` will be extracted to
+        create the `Node` links.
+
+        Eg if nodes `a` and `b` are connected over a hyperlink `https://some-url`, the
+        function call would look like:
+
+        .. code-block:: python
+
+            store.add_documents(
+                [
+                    Document(
+                        id="a",
+                        page_content="some text a",
+                        metadata={
+                            "links": [
+                                Link.incoming(kind="hyperlink", tag="http://some-url")
+                            ]
+                        }
+                    ),
+                    Document(
+                        id="b",
+                        page_content="some text b",
+                        metadata={
+                            "links": [
+                                Link.outgoing(kind="hyperlink", tag="http://some-url")
+                            ]
+                        }
+                    ),
+                ]
+
+            )
+
+        Args:
+            documents: Documents to add to the vector store.
+                The document's metadata key `links` shall be an iterable of
+                :py:class:`~langchain_community.graph_vectorstores.links.Link`.
+
+        Returns:
+            List of IDs of the added texts.
+        """
+        nodes = _documents_to_nodes(documents)
+        return list(self.add_nodes(nodes, **kwargs))
+
+    async def aadd_documents(
+        self,
+        documents: Iterable[Document],
+        **kwargs: Any,
+    ) -> list[str]:
+        """Run more documents through the embeddings and add to the vector store.
+
+        The Links present in the document metadata field `links` will be extracted to
+        create the `Node` links.
+
+        Eg if nodes `a` and `b` are connected over a hyperlink `https://some-url`, the
+        function call would look like:
+
+        .. code-block:: python
+
+            store.add_documents(
+                [
+                    Document(
+                        id="a",
+                        page_content="some text a",
+                        metadata={
+                            "links": [
+                                Link.incoming(kind="hyperlink", tag="http://some-url")
+                            ]
+                        }
+                    ),
+                    Document(
+                        id="b",
+                        page_content="some text b",
+                        metadata={
+                            "links": [
+                                Link.outgoing(kind="hyperlink", tag="http://some-url")
+                            ]
+                        }
+                    ),
+                ]
+
+            )
+
+        Args:
+            documents: Documents to add to the vector store.
+                The document's metadata key `links` shall be an iterable of
+                :py:class:`~langchain_community.graph_vectorstores.links.Link`.
+
+        Returns:
+            List of IDs of the added texts.
+        """
+        nodes = _documents_to_nodes(documents)
+        return [_id async for _id in self.aadd_nodes(nodes, **kwargs)]
+
+    @abstractmethod
+    def traversal_search(
+        self,
+        query: str,
+        *,
+        k: int = 4,
+        depth: int = 1,
+        filter: dict[str, Any] | None = None,  # noqa: A002
+        **kwargs: Any,
+    ) -> Iterable[Document]:
+        """Retrieve documents from traversing this graph store.
+
+        First, `k` nodes are retrieved using a search for each `query` string.
+        Then, additional nodes are discovered up to the given `depth` from those
+        starting nodes.
+
+        Args:
+            query: The query string.
+            k: The number of Documents to return from the initial search.
+                Defaults to 4. Applies to each of the query strings.
+            depth: The maximum depth of edges to traverse. Defaults to 1.
+            filter: Optional metadata to filter the results.
+            **kwargs: Additional keyword arguments.
+        Returns:
+            Collection of retrieved documents.
+        """
+
+    async def atraversal_search(
+        self,
+        query: str,
+        *,
+        k: int = 4,
+        depth: int = 1,
+        filter: dict[str, Any] | None = None,  # noqa: A002
+        **kwargs: Any,
+    ) -> AsyncIterable[Document]:
+        """Retrieve documents from traversing this graph store.
+
+        First, `k` nodes are retrieved using a search for each `query` string.
+        Then, additional nodes are discovered up to the given `depth` from those
+        starting nodes.
+
+        Args:
+            query: The query string.
+            k: The number of Documents to return from the initial search.
+                Defaults to 4. Applies to each of the query strings.
+            depth: The maximum depth of edges to traverse. Defaults to 1.
+            filter: Optional metadata to filter the results.
+            **kwargs: Additional keyword arguments.
+        Returns:
+            Collection of retrieved documents.
+        """
+        iterator = iter(
+            await run_in_executor(
+                None,
+                self.traversal_search,
+                query,
+                k=k,
+                depth=depth,
+                filter=filter,
+                **kwargs,
+            )
+        )
+        done = object()
+        while True:
+            doc = await run_in_executor(None, next, iterator, done)
+            if doc is done:
+                break
+            yield doc  # type: ignore[misc]
+
+    @abstractmethod
+    def mmr_traversal_search(
+        self,
+        query: str,
+        *,
+        initial_roots: Sequence[str] = (),
+        k: int = 4,
+        depth: int = 2,
+        fetch_k: int = 100,
+        adjacent_k: int = 10,
+        lambda_mult: float = 0.5,
+        score_threshold: float = float("-inf"),
+        filter: dict[str, Any] | None = None,  # noqa: A002
+        **kwargs: Any,
+    ) -> Iterable[Document]:
+        """Retrieve documents from this graph store using MMR-traversal.
+
+        This strategy first retrieves the top `fetch_k` results by similarity to
+        the question. It then selects the top `k` results based on
+        maximum-marginal relevance using the given `lambda_mult`.
+
+        At each step, it considers the (remaining) documents from `fetch_k` as
+        well as any documents connected by edges to a selected document
+        retrieved based on similarity (a "root").
+
+        Args:
+            query: The query string to search for.
+            initial_roots: Optional list of document IDs to use for initializing search.
+                The top `adjacent_k` nodes adjacent to each initial root will be
+                included in the set of initial candidates. To fetch only in the
+                neighborhood of these nodes, set `fetch_k = 0`.
+            k: Number of Documents to return. Defaults to 4.
+            fetch_k: Number of Documents to fetch via similarity.
+                Defaults to 100.
+            adjacent_k: Number of adjacent Documents to fetch.
+                Defaults to 10.
+            depth: Maximum depth of a node (number of edges) from a node
+                retrieved via similarity. Defaults to 2.
+            lambda_mult: Number between 0 and 1 that determines the degree
+                of diversity among the results with 0 corresponding to maximum
+                diversity and 1 to minimum diversity. Defaults to 0.5.
+            score_threshold: Only documents with a score greater than or equal
+                this threshold will be chosen. Defaults to negative infinity.
+            filter: Optional metadata to filter the results.
+            **kwargs: Additional keyword arguments.
+        """
+
+    async def ammr_traversal_search(
+        self,
+        query: str,
+        *,
+        initial_roots: Sequence[str] = (),
+        k: int = 4,
+        depth: int = 2,
+        fetch_k: int = 100,
+        adjacent_k: int = 10,
+        lambda_mult: float = 0.5,
+        score_threshold: float = float("-inf"),
+        filter: dict[str, Any] | None = None,  # noqa: A002
+        **kwargs: Any,
+    ) -> AsyncIterable[Document]:
+        """Retrieve documents from this graph store using MMR-traversal.
+
+        This strategy first retrieves the top `fetch_k` results by similarity to
+        the question. It then selects the top `k` results based on
+        maximum-marginal relevance using the given `lambda_mult`.
+
+        At each step, it considers the (remaining) documents from `fetch_k` as
+        well as any documents connected by edges to a selected document
+        retrieved based on similarity (a "root").
+
+        Args:
+            query: The query string to search for.
+            initial_roots: Optional list of document IDs to use for initializing search.
+                The top `adjacent_k` nodes adjacent to each initial root will be
+                included in the set of initial candidates. To fetch only in the
+                neighborhood of these nodes, set `fetch_k = 0`.
+            k: Number of Documents to return. Defaults to 4.
+            fetch_k: Number of Documents to fetch via similarity.
+                Defaults to 100.
+            adjacent_k: Number of adjacent Documents to fetch.
+                Defaults to 10.
+            depth: Maximum depth of a node (number of edges) from a node
+                retrieved via similarity. Defaults to 2.
+            lambda_mult: Number between 0 and 1 that determines the degree
+                of diversity among the results with 0 corresponding to maximum
+                diversity and 1 to minimum diversity. Defaults to 0.5.
+            score_threshold: Only documents with a score greater than or equal
+                this threshold will be chosen. Defaults to negative infinity.
+            filter: Optional metadata to filter the results.
+            **kwargs: Additional keyword arguments.
+        """
+        iterator = iter(
+            await run_in_executor(
+                None,
+                self.mmr_traversal_search,
+                query,
+                initial_roots=initial_roots,
+                k=k,
+                fetch_k=fetch_k,
+                adjacent_k=adjacent_k,
+                depth=depth,
+                lambda_mult=lambda_mult,
+                score_threshold=score_threshold,
+                filter=filter,
+                **kwargs,
+            )
+        )
+        done = object()
+        while True:
+            doc = await run_in_executor(None, next, iterator, done)
+            if doc is done:
+                break
+            yield doc  # type: ignore[misc]
+
+    def similarity_search(
+        self, query: str, k: int = 4, **kwargs: Any
+    ) -> list[Document]:
+        return list(self.traversal_search(query, k=k, depth=0))
+
+    def max_marginal_relevance_search(
+        self,
+        query: str,
+        k: int = 4,
+        fetch_k: int = 20,
+        lambda_mult: float = 0.5,
+        **kwargs: Any,
+    ) -> list[Document]:
+        if kwargs.get("depth", 0) > 0:
+            logger.warning(
+                "'mmr' search started with depth > 0. "
+                "Maybe you meant to do a 'mmr_traversal' search?"
+            )
+        return list(
+            self.mmr_traversal_search(
+                query, k=k, fetch_k=fetch_k, lambda_mult=lambda_mult, depth=0
+            )
+        )
+
+    async def asimilarity_search(
+        self, query: str, k: int = 4, **kwargs: Any
+    ) -> list[Document]:
+        return [doc async for doc in self.atraversal_search(query, k=k, depth=0)]
+
+    def search(self, query: str, search_type: str, **kwargs: Any) -> list[Document]:
+        if search_type == "similarity":
+            return self.similarity_search(query, **kwargs)
+        elif search_type == "similarity_score_threshold":
+            docs_and_similarities = self.similarity_search_with_relevance_scores(
+                query, **kwargs
+            )
+            return [doc for doc, _ in docs_and_similarities]
+        elif search_type == "mmr":
+            return self.max_marginal_relevance_search(query, **kwargs)
+        elif search_type == "traversal":
+            return list(self.traversal_search(query, **kwargs))
+        elif search_type == "mmr_traversal":
+            return list(self.mmr_traversal_search(query, **kwargs))
+        else:
+            raise ValueError(
+                f"search_type of {search_type} not allowed. Expected "
+                "search_type to be 'similarity', 'similarity_score_threshold', "
+                "'mmr', 'traversal', or 'mmr_traversal'."
+            )
+
+    async def asearch(
+        self, query: str, search_type: str, **kwargs: Any
+    ) -> list[Document]:
+        if search_type == "similarity":
+            return await self.asimilarity_search(query, **kwargs)
+        elif search_type == "similarity_score_threshold":
+            docs_and_similarities = await self.asimilarity_search_with_relevance_scores(
+                query, **kwargs
+            )
+            return [doc for doc, _ in docs_and_similarities]
+        elif search_type == "mmr":
+            return await self.amax_marginal_relevance_search(query, **kwargs)
+        elif search_type == "traversal":
+            return [doc async for doc in self.atraversal_search(query, **kwargs)]
+        elif search_type == "mmr_traversal":
+            return [doc async for doc in self.ammr_traversal_search(query, **kwargs)]
+        else:
+            raise ValueError(
+                f"search_type of {search_type} not allowed. Expected "
+                "search_type to be 'similarity', 'similarity_score_threshold', "
+                "'mmr', 'traversal', or 'mmr_traversal'."
+            )
+
+    def as_retriever(self, **kwargs: Any) -> GraphVectorStoreRetriever:
+        """Return GraphVectorStoreRetriever initialized from this GraphVectorStore.
+
+        Args:
+            **kwargs: Keyword arguments to pass to the search function.
+                Can include:
+
+                - search_type (Optional[str]): Defines the type of search that
+                  the Retriever should perform.
+                  Can be ``traversal`` (default), ``similarity``, ``mmr``,
+                   ``mmr_traversal``, or ``similarity_score_threshold``.
+                - search_kwargs (Optional[Dict]): Keyword arguments to pass to the
+                  search function. Can include things like:
+
+                  - k(int): Amount of documents to return (Default: 4).
+                  - depth(int): The maximum depth of edges to traverse (Default: 1).
+                    Only applies to search_type: ``traversal`` and ``mmr_traversal``.
+                  - score_threshold(float): Minimum relevance threshold
+                    for similarity_score_threshold.
+                  - fetch_k(int): Amount of documents to pass to MMR algorithm
+                    (Default: 20).
+                  - lambda_mult(float): Diversity of results returned by MMR;
+                    1 for minimum diversity and 0 for maximum. (Default: 0.5).
+        Returns:
+            Retriever for this GraphVectorStore.
+
+        Examples:
+
+        .. code-block:: python
+
+            # Retrieve documents traversing edges
+            docsearch.as_retriever(
+                search_type="traversal",
+                search_kwargs={'k': 6, 'depth': 2}
+            )
+
+            # Retrieve documents with higher diversity
+            # Useful if your dataset has many similar documents
+            docsearch.as_retriever(
+                search_type="mmr_traversal",
+                search_kwargs={'k': 6, 'lambda_mult': 0.25, 'depth': 2}
+            )
+
+            # Fetch more documents for the MMR algorithm to consider
+            # But only return the top 5
+            docsearch.as_retriever(
+                search_type="mmr_traversal",
+                search_kwargs={'k': 5, 'fetch_k': 50, 'depth': 2}
+            )
+
+            # Only retrieve documents that have a relevance score
+            # Above a certain threshold
+            docsearch.as_retriever(
+                search_type="similarity_score_threshold",
+                search_kwargs={'score_threshold': 0.8}
+            )
+
+            # Only get the single most similar document from the dataset
+            docsearch.as_retriever(search_kwargs={'k': 1})
+
+        """
+        return GraphVectorStoreRetriever(vectorstore=self, **kwargs)
+
+
+@deprecated(
+    since="0.3.21",
+    removal="0.5",
+    addendum=DEPRECATION_ADDENDUM,
+)
+class GraphVectorStoreRetriever(VectorStoreRetriever):
+    """Retriever for GraphVectorStore.
+
+    A graph vector store retriever is a retriever that uses a graph vector store to
+    retrieve documents.
+    It is similar to a vector store retriever, except that it uses both vector
+    similarity and graph connections to retrieve documents.
+    It uses the search methods implemented by a graph vector store, like traversal
+    search and MMR traversal search, to query the texts in the graph vector store.
+
+    Example::
+
+        store = CassandraGraphVectorStore(...)
+        retriever = store.as_retriever()
+        retriever.invoke("What is ...")
+
+    .. seealso::
+
+        :mod:`How to use a graph vector store <langchain_community.graph_vectorstores>`
+
+    How to use a graph vector store as a retriever
+    ==============================================
+
+    Creating a retriever from a graph vector store
+    ----------------------------------------------
+
+    You can build a retriever from a graph vector store using its
+    :meth:`~langchain_community.graph_vectorstores.base.GraphVectorStore.as_retriever`
+    method.
+
+    First we instantiate a graph vector store.
+    We will use a store backed by Cassandra
+    :class:`~langchain_community.graph_vectorstores.cassandra.CassandraGraphVectorStore`
+    graph vector store::
+
+        from langchain_community.document_loaders import TextLoader
+        from langchain_community.graph_vectorstores import CassandraGraphVectorStore
+        from langchain_community.graph_vectorstores.extractors import (
+            KeybertLinkExtractor,
+            LinkExtractorTransformer,
+        )
+        from langchain_openai import OpenAIEmbeddings
+        from langchain_text_splitters import CharacterTextSplitter
+
+        loader = TextLoader("state_of_the_union.txt")
+        documents = loader.load()
+
+        text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0)
+        texts = text_splitter.split_documents(documents)
+
+        pipeline = LinkExtractorTransformer([KeybertLinkExtractor()])
+        pipeline.transform_documents(texts)
+        embeddings = OpenAIEmbeddings()
+        graph_vectorstore = CassandraGraphVectorStore.from_documents(texts, embeddings)
+
+    We can then instantiate a retriever::
+
+        retriever = graph_vectorstore.as_retriever()
+
+    This creates a retriever (specifically a ``GraphVectorStoreRetriever``), which we
+    can use in the usual way::
+
+        docs = retriever.invoke("what did the president say about ketanji brown jackson?")
+
+    Maximum marginal relevance traversal retrieval
+    ----------------------------------------------
+
+    By default, the graph vector store retriever uses similarity search, then expands
+    the retrieved set by following a fixed number of graph edges.
+    If the underlying graph vector store supports maximum marginal relevance traversal,
+    you can specify that as the search type.
+
+    MMR-traversal is a retrieval method combining MMR and graph traversal.
+    The strategy first retrieves the top fetch_k results by similarity to the question.
+    It then iteratively expands the set of fetched documents by following adjacent_k
+    graph edges and selects the top k results based on maximum-marginal relevance using
+    the given ``lambda_mult``::
+
+        retriever = graph_vectorstore.as_retriever(search_type="mmr_traversal")
+
+    Passing search parameters
+    -------------------------
+
+    We can pass parameters to the underlying graph vector store's search methods using
+    ``search_kwargs``.
+
+    Specifying graph traversal depth
+    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+    For example, we can set the graph traversal depth to only return documents
+    reachable through a given number of graph edges::
+
+        retriever = graph_vectorstore.as_retriever(search_kwargs={"depth": 3})
+
+    Specifying MMR parameters
+    ^^^^^^^^^^^^^^^^^^^^^^^^^
+
+    When using search type ``mmr_traversal``, several parameters of the MMR algorithm
+    can be configured.
+
+    The ``fetch_k`` parameter determines how many documents are fetched using vector
+    similarity and ``adjacent_k`` parameter determines how many documents are fetched
+    using graph edges.
+    The ``lambda_mult`` parameter controls how the MMR re-ranking weights similarity to
+    the query string vs diversity among the retrieved documents as fetched documents
+    are selected for the set of ``k`` final results::
+
+        retriever = graph_vectorstore.as_retriever(
+            search_type="mmr",
+            search_kwargs={"fetch_k": 20, "adjacent_k": 20, "lambda_mult": 0.25},
+        )
+
+    Specifying top k
+    ^^^^^^^^^^^^^^^^
+
+    We can also limit the number of documents ``k`` returned by the retriever.
+
+    Note that if ``depth`` is greater than zero, the retriever may return more documents
+    than is specified by ``k``, since both the original ``k`` documents retrieved using
+    vector similarity and any documents connected via graph edges will be returned::
+
+        retriever = graph_vectorstore.as_retriever(search_kwargs={"k": 1})
+
+    Similarity score threshold retrieval
+    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+    For example, we can set a similarity score threshold and only return documents with
+    a score above that threshold::
+
+        retriever = graph_vectorstore.as_retriever(search_kwargs={"score_threshold": 0.5})
+    """  # noqa: E501
+
+    vectorstore: VectorStore
+    """VectorStore to use for retrieval."""
+    search_type: str = "traversal"
+    """Type of search to perform. Defaults to "traversal"."""
+    allowed_search_types: ClassVar[Collection[str]] = (
+        "similarity",
+        "similarity_score_threshold",
+        "mmr",
+        "traversal",
+        "mmr_traversal",
+    )
+
+    @property
+    def graph_vectorstore(self) -> GraphVectorStore:
+        return cast(GraphVectorStore, self.vectorstore)
+
+    def _get_relevant_documents(
+        self, query: str, *, run_manager: CallbackManagerForRetrieverRun, **kwargs: Any
+    ) -> list[Document]:
+        if self.search_type == "traversal":
+            return list(
+                self.graph_vectorstore.traversal_search(query, **self.search_kwargs)
+            )
+        elif self.search_type == "mmr_traversal":
+            return list(
+                self.graph_vectorstore.mmr_traversal_search(query, **self.search_kwargs)
+            )
+        else:
+            return super()._get_relevant_documents(query, run_manager=run_manager)
+
+    async def _aget_relevant_documents(
+        self,
+        query: str,
+        *,
+        run_manager: AsyncCallbackManagerForRetrieverRun,
+        **kwargs: Any,
+    ) -> list[Document]:
+        if self.search_type == "traversal":
+            return [
+                doc
+                async for doc in self.graph_vectorstore.atraversal_search(
+                    query, **self.search_kwargs
+                )
+            ]
+        elif self.search_type == "mmr_traversal":
+            return [
+                doc
+                async for doc in self.graph_vectorstore.ammr_traversal_search(
+                    query, **self.search_kwargs
+                )
+            ]
+        else:
+            return await super()._aget_relevant_documents(
+                query, run_manager=run_manager
+            )