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

langchain/chains/elasticsearch_database/base.py

@@ -1,211 +0,0 @@
-"""Chain for interacting with Elasticsearch Database."""
-
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Any, Optional
-
-from langchain_core.callbacks import CallbackManagerForChainRun
-from langchain_core.language_models import BaseLanguageModel
-from langchain_core.output_parsers import BaseOutputParser, StrOutputParser
-from langchain_core.output_parsers.json import SimpleJsonOutputParser
-from langchain_core.prompts import BasePromptTemplate
-from langchain_core.runnables import Runnable
-from pydantic import ConfigDict, model_validator
-from typing_extensions import Self
-
-from langchain.chains.base import Chain
-from langchain.chains.elasticsearch_database.prompts import ANSWER_PROMPT, DSL_PROMPT
-
-if TYPE_CHECKING:
-    from elasticsearch import Elasticsearch
-
-INTERMEDIATE_STEPS_KEY = "intermediate_steps"
-
-
-class ElasticsearchDatabaseChain(Chain):
-    """Chain for interacting with Elasticsearch Database.
-
-    Example:
-        .. code-block:: python
-
-            from langchain.chains import ElasticsearchDatabaseChain
-            from langchain_community.llms import OpenAI
-            from elasticsearch import Elasticsearch
-
-            database = Elasticsearch("http://localhost:9200")
-            db_chain = ElasticsearchDatabaseChain.from_llm(OpenAI(), database)
-    """
-
-    query_chain: Runnable
-    """Chain for creating the ES query."""
-    answer_chain: Runnable
-    """Chain for answering the user question."""
-    database: Any = None
-    """Elasticsearch database to connect to of type elasticsearch.Elasticsearch."""
-    top_k: int = 10
-    """Number of results to return from the query"""
-    ignore_indices: Optional[list[str]] = None
-    include_indices: Optional[list[str]] = None
-    input_key: str = "question"  #: :meta private:
-    output_key: str = "result"  #: :meta private:
-    sample_documents_in_index_info: int = 3
-    return_intermediate_steps: bool = False
-    """Whether or not to return the intermediate steps along with the final answer."""
-
-    model_config = ConfigDict(
-        arbitrary_types_allowed=True,
-        extra="forbid",
-    )
-
-    @model_validator(mode="after")
-    def validate_indices(self) -> Self:
-        if self.include_indices and self.ignore_indices:
-            msg = "Cannot specify both 'include_indices' and 'ignore_indices'."
-            raise ValueError(msg)
-        return self
-
-    @property
-    def input_keys(self) -> list[str]:
-        """Return the singular input key.
-
-        :meta private:
-        """
-        return [self.input_key]
-
-    @property
-    def output_keys(self) -> list[str]:
-        """Return the singular output key.
-
-        :meta private:
-        """
-        if not self.return_intermediate_steps:
-            return [self.output_key]
-        return [self.output_key, INTERMEDIATE_STEPS_KEY]
-
-    def _list_indices(self) -> list[str]:
-        all_indices = [
-            index["index"] for index in self.database.cat.indices(format="json")
-        ]
-
-        if self.include_indices:
-            all_indices = [i for i in all_indices if i in self.include_indices]
-        if self.ignore_indices:
-            all_indices = [i for i in all_indices if i not in self.ignore_indices]
-
-        return all_indices
-
-    def _get_indices_infos(self, indices: list[str]) -> str:
-        mappings = self.database.indices.get_mapping(index=",".join(indices))
-        if self.sample_documents_in_index_info > 0:
-            for k, v in mappings.items():
-                hits = self.database.search(
-                    index=k,
-                    query={"match_all": {}},
-                    size=self.sample_documents_in_index_info,
-                )["hits"]["hits"]
-                hits = [str(hit["_source"]) for hit in hits]
-                mappings[k]["mappings"] = str(v) + "\n\n/*\n" + "\n".join(hits) + "\n*/"
-        return "\n\n".join(
-            [
-                "Mapping for index {}:\n{}".format(index, mappings[index]["mappings"])
-                for index in mappings
-            ],
-        )
-
-    def _search(self, indices: list[str], query: str) -> str:
-        result = self.database.search(index=",".join(indices), body=query)
-        return str(result)
-
-    def _call(
-        self,
-        inputs: dict[str, Any],
-        run_manager: Optional[CallbackManagerForChainRun] = None,
-    ) -> dict[str, Any]:
-        _run_manager = run_manager or CallbackManagerForChainRun.get_noop_manager()
-        input_text = f"{inputs[self.input_key]}\nESQuery:"
-        _run_manager.on_text(input_text, verbose=self.verbose)
-        indices = self._list_indices()
-        indices_info = self._get_indices_infos(indices)
-        query_inputs: dict = {
-            "input": input_text,
-            "top_k": str(self.top_k),
-            "indices_info": indices_info,
-            "stop": ["\nESResult:"],
-        }
-        intermediate_steps: list = []
-        try:
-            intermediate_steps.append(query_inputs)  # input: es generation
-            es_cmd = self.query_chain.invoke(
-                query_inputs,
-                config={"callbacks": _run_manager.get_child()},
-            )
-
-            _run_manager.on_text(es_cmd, color="green", verbose=self.verbose)
-            intermediate_steps.append(
-                es_cmd,
-            )  # output: elasticsearch dsl generation (no checker)
-            intermediate_steps.append({"es_cmd": es_cmd})  # input: ES search
-            result = self._search(indices=indices, query=es_cmd)
-            intermediate_steps.append(str(result))  # output: ES search
-
-            _run_manager.on_text("\nESResult: ", verbose=self.verbose)
-            _run_manager.on_text(result, color="yellow", verbose=self.verbose)
-
-            _run_manager.on_text("\nAnswer:", verbose=self.verbose)
-            answer_inputs: dict = {"data": result, "input": input_text}
-            intermediate_steps.append(answer_inputs)  # input: final answer
-            final_result = self.answer_chain.invoke(
-                answer_inputs,
-                config={"callbacks": _run_manager.get_child()},
-            )
-
-            intermediate_steps.append(final_result)  # output: final answer
-            _run_manager.on_text(final_result, color="green", verbose=self.verbose)
-            chain_result: dict[str, Any] = {self.output_key: final_result}
-            if self.return_intermediate_steps:
-                chain_result[INTERMEDIATE_STEPS_KEY] = intermediate_steps
-        except Exception as exc:
-            # Append intermediate steps to exception, to aid in logging and later
-            # improvement of few shot prompt seeds
-            exc.intermediate_steps = intermediate_steps  # type: ignore[attr-defined]
-            raise
-
-        return chain_result
-
-    @property
-    def _chain_type(self) -> str:
-        return "elasticsearch_database_chain"
-
-    @classmethod
-    def from_llm(
-        cls,
-        llm: BaseLanguageModel,
-        database: Elasticsearch,
-        *,
-        query_prompt: Optional[BasePromptTemplate] = None,
-        answer_prompt: Optional[BasePromptTemplate] = None,
-        query_output_parser: Optional[BaseOutputParser] = None,
-        **kwargs: Any,
-    ) -> ElasticsearchDatabaseChain:
-        """Convenience method to construct ElasticsearchDatabaseChain from an LLM.
-
-        Args:
-            llm: The language model to use.
-            database: The Elasticsearch db.
-            query_prompt: The prompt to use for query construction.
-            answer_prompt: The prompt to use for answering user question given data.
-            query_output_parser: The output parser to use for parsing model-generated
-                ES query. Defaults to SimpleJsonOutputParser.
-            kwargs: Additional arguments to pass to the constructor.
-        """
-        query_prompt = query_prompt or DSL_PROMPT
-        query_output_parser = query_output_parser or SimpleJsonOutputParser()
-        query_chain = query_prompt | llm | query_output_parser
-        answer_prompt = answer_prompt or ANSWER_PROMPT
-        answer_chain = answer_prompt | llm | StrOutputParser()
-        return cls(
-            query_chain=query_chain,
-            answer_chain=answer_chain,
-            database=database,
-            **kwargs,
-        )

langchain/chains/elasticsearch_database/prompts.py

@@ -1,35 +0,0 @@
-from langchain_core.prompts.prompt import PromptTemplate
-
-PROMPT_SUFFIX = """Only use the following Elasticsearch indices:
-{indices_info}
-
-Question: {input}
-ESQuery:"""
-
-DEFAULT_DSL_TEMPLATE = """Given an input question, create a syntactically correct Elasticsearch query to run. Unless the user specifies in their question a specific number of examples they wish to obtain, always limit your query to at most {top_k} results. You can order the results by a relevant column to return the most interesting examples in the database.
-
-Unless told to do not query for all the columns from a specific index, only ask for a few relevant columns given the question.
-
-Pay attention to use only the column names that you can see in the mapping description. Be careful to not query for columns that do not exist. Also, pay attention to which column is in which index. Return the query as valid json.
-
-Use the following format:
-
-Question: Question here
-ESQuery: Elasticsearch Query formatted as json
-"""  # noqa: E501
-
-DSL_PROMPT = PromptTemplate.from_template(DEFAULT_DSL_TEMPLATE + PROMPT_SUFFIX)
-
-DEFAULT_ANSWER_TEMPLATE = """Given an input question and relevant data from a database, answer the user question.
-
-Use the following format:
-
-Question: Question here
-Data: Relevant data here
-Answer: Final answer here
-
-Question: {input}
-Data: {data}
-Answer:"""  # noqa: E501
-
-ANSWER_PROMPT = PromptTemplate.from_template(DEFAULT_ANSWER_TEMPLATE)

langchain/chains/ernie_functions/__init__.py

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

langchain/chains/ernie_functions/base.py

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

langchain/chains/example_generator.py

@@ -1,22 +0,0 @@
-from langchain_core.language_models import BaseLanguageModel
-from langchain_core.output_parsers import StrOutputParser
-from langchain_core.prompts.few_shot import FewShotPromptTemplate
-from langchain_core.prompts.prompt import PromptTemplate
-
-TEST_GEN_TEMPLATE_SUFFIX = "Add another example."
-
-
-def generate_example(
-    examples: list[dict],
-    llm: BaseLanguageModel,
-    prompt_template: PromptTemplate,
-) -> str:
-    """Return another example given a list of examples for a prompt."""
-    prompt = FewShotPromptTemplate(
-        examples=examples,
-        suffix=TEST_GEN_TEMPLATE_SUFFIX,
-        input_variables=[],
-        example_prompt=prompt_template,
-    )
-    chain = prompt | llm | StrOutputParser()
-    return chain.invoke({})

langchain/chains/flare/__init__.py

@@ -1 +0,0 @@
-"""Adapted from https://github.com/jzbjyb/FLARE"""

langchain/chains/flare/base.py

@@ -1,282 +0,0 @@
-from __future__ import annotations
-
-import logging
-import re
-from collections.abc import Sequence
-from typing import Any, Optional
-
-from langchain_core.callbacks import (
-    CallbackManagerForChainRun,
-)
-from langchain_core.language_models import BaseLanguageModel
-from langchain_core.messages import AIMessage
-from langchain_core.output_parsers import StrOutputParser
-from langchain_core.prompts import BasePromptTemplate
-from langchain_core.retrievers import BaseRetriever
-from langchain_core.runnables import Runnable
-from pydantic import Field
-
-from langchain.chains.base import Chain
-from langchain.chains.flare.prompts import (
-    PROMPT,
-    QUESTION_GENERATOR_PROMPT,
-    FinishedOutputParser,
-)
-from langchain.chains.llm import LLMChain
-
-logger = logging.getLogger(__name__)
-
-
-def _extract_tokens_and_log_probs(response: AIMessage) -> tuple[list[str], list[float]]:
-    """Extract tokens and log probabilities from chat model response."""
-    tokens = []
-    log_probs = []
-    for token in response.response_metadata["logprobs"]["content"]:
-        tokens.append(token["token"])
-        log_probs.append(token["logprob"])
-    return tokens, log_probs
-
-
-class QuestionGeneratorChain(LLMChain):
-    """Chain that generates questions from uncertain spans."""
-
-    prompt: BasePromptTemplate = QUESTION_GENERATOR_PROMPT
-    """Prompt template for the chain."""
-
-    @classmethod
-    def is_lc_serializable(cls) -> bool:
-        return False
-
-    @property
-    def input_keys(self) -> list[str]:
-        """Input keys for the chain."""
-        return ["user_input", "context", "response"]
-
-
-def _low_confidence_spans(
-    tokens: Sequence[str],
-    log_probs: Sequence[float],
-    min_prob: float,
-    min_token_gap: int,
-    num_pad_tokens: int,
-) -> list[str]:
-    try:
-        import numpy as np
-
-        _low_idx = np.where(np.exp(log_probs) < min_prob)[0]
-    except ImportError:
-        logger.warning(
-            "NumPy not found in the current Python environment. FlareChain will use a "
-            "pure Python implementation for internal calculations, which may "
-            "significantly impact performance, especially for large datasets. For "
-            "optimal speed and efficiency, consider installing NumPy: pip install "
-            "numpy",
-        )
-        import math
-
-        _low_idx = [  # type: ignore[assignment]
-            idx
-            for idx, log_prob in enumerate(log_probs)
-            if math.exp(log_prob) < min_prob
-        ]
-    low_idx = [i for i in _low_idx if re.search(r"\w", tokens[i])]
-    if len(low_idx) == 0:
-        return []
-    spans = [[low_idx[0], low_idx[0] + num_pad_tokens + 1]]
-    for i, idx in enumerate(low_idx[1:]):
-        end = idx + num_pad_tokens + 1
-        if idx - low_idx[i] < min_token_gap:
-            spans[-1][1] = end
-        else:
-            spans.append([idx, end])
-    return ["".join(tokens[start:end]) for start, end in spans]
-
-
-class FlareChain(Chain):
-    """Chain that combines a retriever, a question generator,
-    and a response generator.
-
-    See [Active Retrieval Augmented Generation](https://arxiv.org/abs/2305.06983) paper.
-    """
-
-    question_generator_chain: Runnable
-    """Chain that generates questions from uncertain spans."""
-    response_chain: Runnable
-    """Chain that generates responses from user input and context."""
-    output_parser: FinishedOutputParser = Field(default_factory=FinishedOutputParser)
-    """Parser that determines whether the chain is finished."""
-    retriever: BaseRetriever
-    """Retriever that retrieves relevant documents from a user input."""
-    min_prob: float = 0.2
-    """Minimum probability for a token to be considered low confidence."""
-    min_token_gap: int = 5
-    """Minimum number of tokens between two low confidence spans."""
-    num_pad_tokens: int = 2
-    """Number of tokens to pad around a low confidence span."""
-    max_iter: int = 10
-    """Maximum number of iterations."""
-    start_with_retrieval: bool = True
-    """Whether to start with retrieval."""
-
-    @property
-    def input_keys(self) -> list[str]:
-        """Input keys for the chain."""
-        return ["user_input"]
-
-    @property
-    def output_keys(self) -> list[str]:
-        """Output keys for the chain."""
-        return ["response"]
-
-    def _do_generation(
-        self,
-        questions: list[str],
-        user_input: str,
-        response: str,
-        _run_manager: CallbackManagerForChainRun,
-    ) -> tuple[str, bool]:
-        callbacks = _run_manager.get_child()
-        docs = []
-        for question in questions:
-            docs.extend(self.retriever.invoke(question))
-        context = "\n\n".join(d.page_content for d in docs)
-        result = self.response_chain.invoke(
-            {
-                "user_input": user_input,
-                "context": context,
-                "response": response,
-            },
-            {"callbacks": callbacks},
-        )
-        if isinstance(result, AIMessage):
-            result = result.content
-        marginal, finished = self.output_parser.parse(result)
-        return marginal, finished
-
-    def _do_retrieval(
-        self,
-        low_confidence_spans: list[str],
-        _run_manager: CallbackManagerForChainRun,
-        user_input: str,
-        response: str,
-        initial_response: str,
-    ) -> tuple[str, bool]:
-        question_gen_inputs = [
-            {
-                "user_input": user_input,
-                "current_response": initial_response,
-                "uncertain_span": span,
-            }
-            for span in low_confidence_spans
-        ]
-        callbacks = _run_manager.get_child()
-        if isinstance(self.question_generator_chain, LLMChain):
-            question_gen_outputs = self.question_generator_chain.apply(
-                question_gen_inputs,
-                callbacks=callbacks,
-            )
-            questions = [
-                output[self.question_generator_chain.output_keys[0]]
-                for output in question_gen_outputs
-            ]
-        else:
-            questions = self.question_generator_chain.batch(
-                question_gen_inputs,
-                config={"callbacks": callbacks},
-            )
-        _run_manager.on_text(
-            f"Generated Questions: {questions}",
-            color="yellow",
-            end="\n",
-        )
-        return self._do_generation(questions, user_input, response, _run_manager)
-
-    def _call(
-        self,
-        inputs: dict[str, Any],
-        run_manager: Optional[CallbackManagerForChainRun] = None,
-    ) -> dict[str, Any]:
-        _run_manager = run_manager or CallbackManagerForChainRun.get_noop_manager()
-
-        user_input = inputs[self.input_keys[0]]
-
-        response = ""
-
-        for _i in range(self.max_iter):
-            _run_manager.on_text(
-                f"Current Response: {response}",
-                color="blue",
-                end="\n",
-            )
-            _input = {"user_input": user_input, "context": "", "response": response}
-            tokens, log_probs = _extract_tokens_and_log_probs(
-                self.response_chain.invoke(
-                    _input,
-                    {"callbacks": _run_manager.get_child()},
-                ),
-            )
-            low_confidence_spans = _low_confidence_spans(
-                tokens,
-                log_probs,
-                self.min_prob,
-                self.min_token_gap,
-                self.num_pad_tokens,
-            )
-            initial_response = response.strip() + " " + "".join(tokens)
-            if not low_confidence_spans:
-                response = initial_response
-                final_response, finished = self.output_parser.parse(response)
-                if finished:
-                    return {self.output_keys[0]: final_response}
-                continue
-
-            marginal, finished = self._do_retrieval(
-                low_confidence_spans,
-                _run_manager,
-                user_input,
-                response,
-                initial_response,
-            )
-            response = response.strip() + " " + marginal
-            if finished:
-                break
-        return {self.output_keys[0]: response}
-
-    @classmethod
-    def from_llm(
-        cls,
-        llm: BaseLanguageModel,
-        max_generation_len: int = 32,
-        **kwargs: Any,
-    ) -> FlareChain:
-        """Creates a FlareChain from a language model.
-
-        Args:
-            llm: Language model to use.
-            max_generation_len: Maximum length of the generated response.
-            kwargs: Additional arguments to pass to the constructor.
-
-        Returns:
-            FlareChain class with the given language model.
-        """
-        try:
-            from langchain_openai import ChatOpenAI
-        except ImportError as e:
-            msg = (
-                "OpenAI is required for FlareChain. "
-                "Please install langchain-openai."
-                "pip install langchain-openai"
-            )
-            raise ImportError(msg) from e
-        llm = ChatOpenAI(
-            max_completion_tokens=max_generation_len,
-            logprobs=True,
-            temperature=0,
-        )
-        response_chain = PROMPT | llm
-        question_gen_chain = QUESTION_GENERATOR_PROMPT | llm | StrOutputParser()
-        return cls(
-            question_generator_chain=question_gen_chain,
-            response_chain=response_chain,
-            **kwargs,
-        )

langchain/chains/flare/prompts.py

@@ -1,44 +0,0 @@
-from langchain_core.output_parsers import BaseOutputParser
-from langchain_core.prompts import PromptTemplate
-
-
-class FinishedOutputParser(BaseOutputParser[tuple[str, bool]]):
-    """Output parser that checks if the output is finished."""
-
-    finished_value: str = "FINISHED"
-    """Value that indicates the output is finished."""
-
-    def parse(self, text: str) -> tuple[str, bool]:
-        cleaned = text.strip()
-        finished = self.finished_value in cleaned
-        return cleaned.replace(self.finished_value, ""), finished
-
-
-PROMPT_TEMPLATE = """\
-Respond to the user message using any relevant context. \
-If context is provided, you should ground your answer in that context. \
-Once you're done responding return FINISHED.
-
->>> CONTEXT: {context}
->>> USER INPUT: {user_input}
->>> RESPONSE: {response}\
-"""
-
-PROMPT = PromptTemplate(
-    template=PROMPT_TEMPLATE,
-    input_variables=["user_input", "context", "response"],
-)
-
-
-QUESTION_GENERATOR_PROMPT_TEMPLATE = """\
-Given a user input and an existing partial response as context, \
-ask a question to which the answer is the given term/entity/phrase:
-
->>> USER INPUT: {user_input}
->>> EXISTING PARTIAL RESPONSE: {current_response}
-
-The question to which the answer is the term/entity/phrase "{uncertain_span}" is:"""
-QUESTION_GENERATOR_PROMPT = PromptTemplate(
-    template=QUESTION_GENERATOR_PROMPT_TEMPLATE,
-    input_variables=["user_input", "current_response", "uncertain_span"],
-)