langchain 0.3.27__py3-none-any.whl → 1.0.0__py3-none-any.whl

langchain/embeddings/tensorflow_hub.py

@@ -1,23 +0,0 @@
-from typing import TYPE_CHECKING, Any
-
-from langchain._api import create_importer
-
-if TYPE_CHECKING:
-    from langchain_community.embeddings import TensorflowHubEmbeddings
-
-# Create a way to dynamically look up deprecated imports.
-# Used to consolidate logic for raising deprecation warnings and
-# handling optional imports.
-DEPRECATED_LOOKUP = {"TensorflowHubEmbeddings": "langchain_community.embeddings"}
-
-_import_attribute = create_importer(__package__, deprecated_lookups=DEPRECATED_LOOKUP)
-
-
-def __getattr__(name: str) -> Any:
-    """Look up attributes dynamically."""
-    return _import_attribute(name)
-
-
-__all__ = [
-    "TensorflowHubEmbeddings",
-]

langchain/embeddings/vertexai.py

@@ -1,23 +0,0 @@
-from typing import TYPE_CHECKING, Any
-
-from langchain._api import create_importer
-
-if TYPE_CHECKING:
-    from langchain_community.embeddings import VertexAIEmbeddings
-
-# Create a way to dynamically look up deprecated imports.
-# Used to consolidate logic for raising deprecation warnings and
-# handling optional imports.
-DEPRECATED_LOOKUP = {"VertexAIEmbeddings": "langchain_community.embeddings"}
-
-_import_attribute = create_importer(__package__, deprecated_lookups=DEPRECATED_LOOKUP)
-
-
-def __getattr__(name: str) -> Any:
-    """Look up attributes dynamically."""
-    return _import_attribute(name)
-
-
-__all__ = [
-    "VertexAIEmbeddings",
-]

langchain/embeddings/voyageai.py

@@ -1,23 +0,0 @@
-from typing import TYPE_CHECKING, Any
-
-from langchain._api import create_importer
-
-if TYPE_CHECKING:
-    from langchain_community.embeddings import VoyageEmbeddings
-
-# Create a way to dynamically look up deprecated imports.
-# Used to consolidate logic for raising deprecation warnings and
-# handling optional imports.
-DEPRECATED_LOOKUP = {"VoyageEmbeddings": "langchain_community.embeddings"}
-
-_import_attribute = create_importer(__package__, deprecated_lookups=DEPRECATED_LOOKUP)
-
-
-def __getattr__(name: str) -> Any:
-    """Look up attributes dynamically."""
-    return _import_attribute(name)
-
-
-__all__ = [
-    "VoyageEmbeddings",
-]

langchain/embeddings/xinference.py

@@ -1,23 +0,0 @@
-from typing import TYPE_CHECKING, Any
-
-from langchain._api import create_importer
-
-if TYPE_CHECKING:
-    from langchain_community.embeddings import XinferenceEmbeddings
-
-# Create a way to dynamically look up deprecated imports.
-# Used to consolidate logic for raising deprecation warnings and
-# handling optional imports.
-DEPRECATED_LOOKUP = {"XinferenceEmbeddings": "langchain_community.embeddings"}
-
-_import_attribute = create_importer(__package__, deprecated_lookups=DEPRECATED_LOOKUP)
-
-
-def __getattr__(name: str) -> Any:
-    """Look up attributes dynamically."""
-    return _import_attribute(name)
-
-
-__all__ = [
-    "XinferenceEmbeddings",
-]

langchain/env.py

@@ -1,17 +0,0 @@
-import platform
-from functools import lru_cache
-
-
-@lru_cache(maxsize=1)
-def get_runtime_environment() -> dict:
-    """Get information about the LangChain runtime environment."""
-    # Lazy import to avoid circular imports
-    from langchain import __version__
-
-    return {
-        "library_version": __version__,
-        "library": "langchain",
-        "platform": platform.platform(),
-        "runtime": "python",
-        "runtime_version": platform.python_version(),
-    }

langchain/evaluation/__init__.py

@@ -1,128 +0,0 @@
-"""**Evaluation** chains for grading LLM and Chain outputs.
-
-This module contains off-the-shelf evaluation chains for grading the output of
-LangChain primitives such as language models and chains.
-
-**Loading an evaluator**
-
-To load an evaluator, you can use the :func:`load_evaluators <langchain.evaluation.loading.load_evaluators>` or
-:func:`load_evaluator <langchain.evaluation.loading.load_evaluator>` functions with the
-names of the evaluators to load.
-
-.. code-block:: python
-
-    from langchain.evaluation import load_evaluator
-
-    evaluator = load_evaluator("qa")
-    evaluator.evaluate_strings(
-        prediction="We sold more than 40,000 units last week",
-        input="How many units did we sell last week?",
-        reference="We sold 32,378 units",
-    )
-
-The evaluator must be one of :class:`EvaluatorType <langchain.evaluation.schema.EvaluatorType>`.
-
-**Datasets**
-
-To load one of the LangChain HuggingFace datasets, you can use the :func:`load_dataset <langchain.evaluation.loading.load_dataset>` function with the
-name of the dataset to load.
-
-.. code-block:: python
-
-        from langchain.evaluation import load_dataset
-        ds = load_dataset("llm-math")
-
-**Some common use cases for evaluation include:**
-
-- Grading the accuracy of a response against ground truth answers: :class:`QAEvalChain <langchain.evaluation.qa.eval_chain.QAEvalChain>`
-- Comparing the output of two models: :class:`PairwiseStringEvalChain <langchain.evaluation.comparison.eval_chain.PairwiseStringEvalChain>` or :class:`LabeledPairwiseStringEvalChain <langchain.evaluation.comparison.eval_chain.LabeledPairwiseStringEvalChain>` when there is additionally a reference label.
-- Judging the efficacy of an agent's tool usage: :class:`TrajectoryEvalChain <langchain.evaluation.agents.trajectory_eval_chain.TrajectoryEvalChain>`
-- Checking whether an output complies with a set of criteria: :class:`CriteriaEvalChain <langchain.evaluation.criteria.eval_chain.CriteriaEvalChain>` or :class:`LabeledCriteriaEvalChain <langchain.evaluation.criteria.eval_chain.LabeledCriteriaEvalChain>` when there is additionally a reference label.
-- Computing semantic difference between a prediction and reference: :class:`EmbeddingDistanceEvalChain <langchain.evaluation.embedding_distance.base.EmbeddingDistanceEvalChain>` or between two predictions: :class:`PairwiseEmbeddingDistanceEvalChain <langchain.evaluation.embedding_distance.base.PairwiseEmbeddingDistanceEvalChain>`
-- Measuring the string distance between a prediction and reference :class:`StringDistanceEvalChain <langchain.evaluation.string_distance.base.StringDistanceEvalChain>` or between two predictions :class:`PairwiseStringDistanceEvalChain <langchain.evaluation.string_distance.base.PairwiseStringDistanceEvalChain>`
-
-**Low-level API**
-
-These evaluators implement one of the following interfaces:
-
-- :class:`StringEvaluator <langchain.evaluation.schema.StringEvaluator>`: Evaluate a prediction string against a reference label and/or input context.
-- :class:`PairwiseStringEvaluator <langchain.evaluation.schema.PairwiseStringEvaluator>`: Evaluate two prediction strings against each other. Useful for scoring preferences, measuring similarity between two chain or llm agents, or comparing outputs on similar inputs.
-- :class:`AgentTrajectoryEvaluator <langchain.evaluation.schema.AgentTrajectoryEvaluator>` Evaluate the full sequence of actions taken by an agent.
-
-These interfaces enable easier composability and usage within a higher level evaluation framework.
-
-"""  # noqa: E501
-
-from langchain.evaluation.agents import TrajectoryEvalChain
-from langchain.evaluation.comparison import (
-    LabeledPairwiseStringEvalChain,
-    PairwiseStringEvalChain,
-)
-from langchain.evaluation.criteria import (
-    Criteria,
-    CriteriaEvalChain,
-    LabeledCriteriaEvalChain,
-)
-from langchain.evaluation.embedding_distance import (
-    EmbeddingDistance,
-    EmbeddingDistanceEvalChain,
-    PairwiseEmbeddingDistanceEvalChain,
-)
-from langchain.evaluation.exact_match.base import ExactMatchStringEvaluator
-from langchain.evaluation.loading import load_dataset, load_evaluator, load_evaluators
-from langchain.evaluation.parsing.base import (
-    JsonEqualityEvaluator,
-    JsonValidityEvaluator,
-)
-from langchain.evaluation.parsing.json_distance import JsonEditDistanceEvaluator
-from langchain.evaluation.parsing.json_schema import JsonSchemaEvaluator
-from langchain.evaluation.qa import ContextQAEvalChain, CotQAEvalChain, QAEvalChain
-from langchain.evaluation.regex_match.base import RegexMatchStringEvaluator
-from langchain.evaluation.schema import (
-    AgentTrajectoryEvaluator,
-    EvaluatorType,
-    PairwiseStringEvaluator,
-    StringEvaluator,
-)
-from langchain.evaluation.scoring import (
-    LabeledScoreStringEvalChain,
-    ScoreStringEvalChain,
-)
-from langchain.evaluation.string_distance import (
-    PairwiseStringDistanceEvalChain,
-    StringDistance,
-    StringDistanceEvalChain,
-)
-
-__all__ = [
-    "AgentTrajectoryEvaluator",
-    "ContextQAEvalChain",
-    "CotQAEvalChain",
-    "Criteria",
-    "CriteriaEvalChain",
-    "EmbeddingDistance",
-    "EmbeddingDistanceEvalChain",
-    "EvaluatorType",
-    "ExactMatchStringEvaluator",
-    "JsonEditDistanceEvaluator",
-    "JsonEqualityEvaluator",
-    "JsonSchemaEvaluator",
-    "JsonValidityEvaluator",
-    "LabeledCriteriaEvalChain",
-    "LabeledPairwiseStringEvalChain",
-    "LabeledScoreStringEvalChain",
-    "PairwiseEmbeddingDistanceEvalChain",
-    "PairwiseStringDistanceEvalChain",
-    "PairwiseStringEvalChain",
-    "PairwiseStringEvaluator",
-    "QAEvalChain",
-    "RegexMatchStringEvaluator",
-    "ScoreStringEvalChain",
-    "StringDistance",
-    "StringDistanceEvalChain",
-    "StringEvaluator",
-    "TrajectoryEvalChain",
-    "load_dataset",
-    "load_evaluator",
-    "load_evaluators",
-]

langchain/evaluation/agents/__init__.py

@@ -1,5 +0,0 @@
-"""Chains for evaluating ReAct style agents."""
-
-from langchain.evaluation.agents.trajectory_eval_chain import TrajectoryEvalChain
-
-__all__ = ["TrajectoryEvalChain"]

langchain/evaluation/agents/trajectory_eval_chain.py

@@ -1,415 +0,0 @@
-"""A chain for evaluating ReAct style agents.
-
-This chain is used to evaluate ReAct style agents by reasoning about
-the sequence of actions taken and their outcomes. It uses a language model
-chain (LLMChain) to generate the reasoning and scores.
-"""
-
-import re
-from collections.abc import Sequence
-from typing import (
-    Any,
-    Optional,
-    TypedDict,
-    Union,
-    cast,
-)
-
-from langchain_core.agents import AgentAction
-from langchain_core.callbacks import Callbacks
-from langchain_core.callbacks.manager import (
-    AsyncCallbackManagerForChainRun,
-    CallbackManagerForChainRun,
-)
-from langchain_core.exceptions import OutputParserException
-from langchain_core.language_models import BaseLanguageModel
-from langchain_core.language_models.chat_models import BaseChatModel
-from langchain_core.output_parsers import BaseOutputParser
-from langchain_core.tools import BaseTool
-from pydantic import ConfigDict, Field
-from typing_extensions import override
-
-from langchain.chains.llm import LLMChain
-from langchain.evaluation.agents.trajectory_eval_prompt import (
-    EVAL_CHAT_PROMPT,
-    TOOL_FREE_EVAL_CHAT_PROMPT,
-)
-from langchain.evaluation.schema import AgentTrajectoryEvaluator, LLMEvalChain
-
-_MAX_SCORE = 5
-
-
-class TrajectoryEval(TypedDict):
-    """A named tuple containing the score and reasoning for a trajectory."""
-
-    score: float
-    """The score for the trajectory, normalized from 0 to 1."""
-    reasoning: str
-    """The reasoning for the score."""
-
-
-class TrajectoryOutputParser(BaseOutputParser):
-    """Trajectory output parser."""
-
-    @property
-    def _type(self) -> str:
-        return "agent_trajectory"
-
-    def parse(self, text: str) -> TrajectoryEval:
-        """Parse the output text and extract the score and reasoning.
-
-        Args:
-            text (str): The output text to parse.
-
-        Returns:
-            TrajectoryEval: A named tuple containing the normalized score and reasoning.
-
-        Raises:
-            OutputParserException: If the score is not found in the output text or
-                if the LLM's score is not a digit in the range 1-5.
-        """
-        if "Score:" not in text:
-            msg = f"Could not find score in model eval output: {text}"
-            raise OutputParserException(msg)
-
-        reasoning, score_str = text.split("Score: ", maxsplit=1)
-
-        reasoning, score_str = reasoning.strip(), score_str.strip()
-
-        # Use regex to extract the score.
-        # This will get the number in the string, even if it is a float or more than 10.
-        # E.g. "Score: 1" will return 1, "Score: 3.5" will return 3.5, and
-        # "Score: 10" will return 10.
-        # The score should be an integer digit in the range 1-5.
-        _score = re.search(r"(\d+(\.\d+)?)", score_str)
-        # If the score is not found or is a float, raise an exception.
-        if _score is None or "." in _score.group(1):
-            msg = f"Score is not an integer digit in the range 1-5: {text}"
-            raise OutputParserException(msg)
-        score = int(_score.group(1))
-        # If the score is not in the range 1-5, raise an exception.
-        if not 1 <= score <= _MAX_SCORE:
-            msg = f"Score is not a digit in the range 1-5: {text}"
-            raise OutputParserException(msg)
-        normalized_score = (score - 1) / (_MAX_SCORE - 1)
-        return TrajectoryEval(score=normalized_score, reasoning=reasoning)
-
-
-class TrajectoryEvalChain(AgentTrajectoryEvaluator, LLMEvalChain):
-    """A chain for evaluating ReAct style agents.
-
-    This chain is used to evaluate ReAct style agents by reasoning about
-    the sequence of actions taken and their outcomes.
-    Based on the paper "ReAct: Synergizing Reasoning and Acting in Language Models"
-    (https://arxiv.org/abs/2210.03629)
-
-    Example:
-
-    .. code-block:: python
-
-        from langchain.agents import AgentType, initialize_agent
-        from langchain_community.chat_models import ChatOpenAI
-        from langchain.evaluation import TrajectoryEvalChain
-        from langchain.tools import tool
-
-        @tool
-        def geography_answers(country: str, question: str) -> str:
-            \"\"\"Very helpful answers to geography questions.\"\"\"
-            return f"{country}? IDK - We may never know {question}."
-
-        llm = ChatOpenAI(model="gpt-3.5-turbo", temperature=0)
-        agent = initialize_agent(
-            tools=[geography_answers],
-            llm=llm,
-            agent=AgentType.OPENAI_FUNCTIONS,
-            return_intermediate_steps=True,
-        )
-
-        question = "How many dwell in the largest minor region in Argentina?"
-        response = agent(question)
-
-        eval_chain = TrajectoryEvalChain.from_llm(
-            llm=llm, agent_tools=[geography_answers], return_reasoning=True
-        )
-
-        result = eval_chain.evaluate_agent_trajectory(
-            input=question,
-            agent_trajectory=response["intermediate_steps"],
-            prediction=response["output"],
-            reference="Paris",
-        )
-        print(result["score"])  # noqa: T201
-        # 0
-    """
-
-    agent_tools: Optional[list[BaseTool]] = None
-    """A list of tools available to the agent."""
-    eval_chain: LLMChain
-    """The language model chain used for evaluation."""
-    output_parser: TrajectoryOutputParser = Field(
-        default_factory=TrajectoryOutputParser,
-    )
-    """The output parser used to parse the output."""
-    return_reasoning: bool = False  # :meta private:
-    """DEPRECATED. Reasoning always returned."""
-
-    model_config = ConfigDict(
-        extra="ignore",
-    )
-
-    @property
-    def requires_reference(self) -> bool:
-        """Whether this evaluator requires a reference label."""
-        return False
-
-    @property
-    def _tools_description(self) -> str:
-        """Get the description of the agent tools.
-
-        Returns:
-            str: The description of the agent tools.
-        """
-        if self.agent_tools is None:
-            return ""
-        return "\n\n".join(
-            [
-                f"""Tool {i}: {tool.name}
-Description: {tool.description}"""
-                for i, tool in enumerate(self.agent_tools, 1)
-            ],
-        )
-
-    @staticmethod
-    def get_agent_trajectory(
-        steps: Union[str, Sequence[tuple[AgentAction, str]]],
-    ) -> str:
-        """Get the agent trajectory as a formatted string.
-
-        Args:
-            steps (Union[str, List[Tuple[AgentAction, str]]]): The agent trajectory.
-
-        Returns:
-            str: The formatted agent trajectory.
-        """
-        if isinstance(steps, str):
-            return steps
-
-        return "\n\n".join(
-            [
-                f"""Step {i}:
-Tool used: {action.tool}
-Tool input: {action.tool_input}
-Tool output: {output}"""
-                for i, (action, output) in enumerate(steps, 1)
-            ],
-        )
-
-    @staticmethod
-    def _format_reference(reference: Optional[str]) -> str:
-        """Format the reference text.
-
-        Args:
-            reference (str): The reference text.
-
-        Returns:
-            str: The formatted reference text.
-        """
-        if not reference:
-            return ""
-        return f"""
-
-The following is the expected answer. Use this to measure correctness:
-[GROUND_TRUTH]
-{reference}
-[END_GROUND_TRUTH]
-"""
-
-    @classmethod
-    def from_llm(
-        cls,
-        llm: BaseLanguageModel,
-        agent_tools: Optional[Sequence[BaseTool]] = None,
-        output_parser: Optional[TrajectoryOutputParser] = None,
-        **kwargs: Any,
-    ) -> "TrajectoryEvalChain":
-        """Create a TrajectoryEvalChain object from a language model chain.
-
-        Args:
-            llm (BaseChatModel): The language model chain.
-            agent_tools (Optional[Sequence[BaseTool]]): A list of tools
-                available to the agent.
-            output_parser (Optional[TrajectoryOutputParser]): The output parser
-                used to parse the chain output into a score.
-        Returns:
-            TrajectoryEvalChain: The TrajectoryEvalChain object.
-        """
-        if not isinstance(llm, BaseChatModel):
-            msg = "Only chat models supported by the current trajectory eval"
-            raise NotImplementedError(msg)
-        prompt = EVAL_CHAT_PROMPT if agent_tools else TOOL_FREE_EVAL_CHAT_PROMPT
-        eval_chain = LLMChain(llm=llm, prompt=prompt)
-        return cls(
-            agent_tools=agent_tools,  # type: ignore[arg-type]
-            eval_chain=eval_chain,
-            output_parser=output_parser or TrajectoryOutputParser(),
-            **kwargs,
-        )
-
-    @property
-    def input_keys(self) -> list[str]:
-        """Get the input keys for the chain.
-
-        Returns:
-            List[str]: The input keys.
-        """
-        return ["question", "agent_trajectory", "answer", "reference"]
-
-    @property
-    def output_keys(self) -> list[str]:
-        """Get the output keys for the chain.
-
-        Returns:
-            List[str]: The output keys.
-        """
-        return ["score", "reasoning"]
-
-    def prep_inputs(self, inputs: Union[dict[str, Any], Any]) -> dict[str, str]:
-        """Validate and prep inputs."""
-        inputs["reference"] = self._format_reference(inputs.get("reference"))
-        return super().prep_inputs(inputs)
-
-    def _call(
-        self,
-        inputs: dict[str, str],
-        run_manager: Optional[CallbackManagerForChainRun] = None,
-    ) -> dict[str, Any]:
-        """Run the chain and generate the output.
-
-        Args:
-            inputs (Dict[str, str]): The input values for the chain.
-            run_manager (Optional[CallbackManagerForChainRun]): The callback
-                manager for the chain run.
-
-        Returns:
-            Dict[str, Any]: The output values of the chain.
-        """
-        chain_input = {**inputs}
-        if self.agent_tools:
-            chain_input["tool_descriptions"] = self._tools_description
-        _run_manager = run_manager or CallbackManagerForChainRun.get_noop_manager()
-        raw_output = self.eval_chain.run(
-            chain_input,
-            callbacks=_run_manager.get_child(),
-        )
-        return cast(dict, self.output_parser.parse(raw_output))
-
-    async def _acall(
-        self,
-        inputs: dict[str, str],
-        run_manager: Optional[AsyncCallbackManagerForChainRun] = None,
-    ) -> dict[str, Any]:
-        """Run the chain and generate the output.
-
-        Args:
-            inputs (Dict[str, str]): The input values for the chain.
-            run_manager (Optional[CallbackManagerForChainRun]): The callback
-                manager for the chain run.
-
-        Returns:
-            Dict[str, Any]: The output values of the chain.
-        """
-        chain_input = {**inputs}
-        if self.agent_tools:
-            chain_input["tool_descriptions"] = self._tools_description
-        _run_manager = run_manager or AsyncCallbackManagerForChainRun.get_noop_manager()
-        raw_output = await self.eval_chain.arun(
-            chain_input,
-            callbacks=_run_manager.get_child(),
-        )
-        return cast(dict, self.output_parser.parse(raw_output))
-
-    @override
-    def _evaluate_agent_trajectory(
-        self,
-        *,
-        prediction: str,
-        input: str,
-        agent_trajectory: Sequence[tuple[AgentAction, str]],
-        reference: Optional[str] = None,
-        callbacks: Callbacks = None,
-        tags: Optional[list[str]] = None,
-        metadata: Optional[dict[str, Any]] = None,
-        include_run_info: bool = False,
-        **kwargs: Any,
-    ) -> dict:
-        """Evaluate a trajectory.
-
-        Args:
-            prediction (str): The final predicted response.
-            input (str): The input to the agent.
-            agent_trajectory (List[Tuple[AgentAction, str]]):
-                The intermediate steps forming the agent trajectory.
-            reference (Optional[str]): The reference answer.
-            callbacks (Callbacks): Callbacks to use for this chain run.
-
-        Returns:
-            dict: The evaluation result, which includes the score and optionally
-                the reasoning for reaching that.
-        """
-        inputs = {
-            "question": input,
-            "agent_trajectory": self.get_agent_trajectory(agent_trajectory),
-            "answer": prediction,
-            "reference": reference,
-        }
-        return self.__call__(
-            inputs=inputs,
-            callbacks=callbacks,
-            tags=tags,
-            metadata=metadata,
-            include_run_info=include_run_info,
-            return_only_outputs=True,
-        )
-
-    @override
-    async def _aevaluate_agent_trajectory(
-        self,
-        *,
-        prediction: str,
-        input: str,
-        agent_trajectory: Sequence[tuple[AgentAction, str]],
-        reference: Optional[str] = None,
-        callbacks: Callbacks = None,
-        tags: Optional[list[str]] = None,
-        metadata: Optional[dict[str, Any]] = None,
-        include_run_info: bool = False,
-        **kwargs: Any,
-    ) -> dict:
-        """Asynchronously evaluate a trajectory.
-
-        Args:
-            prediction (str): The final predicted response.
-            input (str): The input to the agent.
-            agent_trajectory (List[Tuple[AgentAction, str]]):
-                The intermediate steps forming the agent trajectory.
-            reference (Optional[str]): The reference answer.
-            callbacks (Callbacks): Callbacks to use for this chain run.
-
-        Returns:
-            dict: The evaluation result, which includes the score and optionally
-                the reasoning for reaching that.
-        """
-        inputs = {
-            "question": input,
-            "agent_trajectory": self.get_agent_trajectory(agent_trajectory),
-            "answer": prediction,
-            "reference": reference,
-        }
-        return await self.acall(
-            inputs=inputs,
-            callbacks=callbacks,
-            tags=tags,
-            metadata=metadata,
-            include_run_info=include_run_info,
-            return_only_outputs=True,
-        )