initial commit

venv/Lib/site-packages/langchain_classic/chains/__init__.py

@@ -0,0 +1,96 @@
+"""**Chains** are easily reusable components linked together.
+
+Chains encode a sequence of calls to components like models, document retrievers,
+other Chains, etc., and provide a simple interface to this sequence.
+
+The Chain interface makes it easy to create apps that are:
+
+    - **Stateful:** add Memory to any Chain to give it state,
+    - **Observable:** pass Callbacks to a Chain to execute additional functionality,
+        like logging, outside the main sequence of component calls,
+    - **Composable:** combine Chains with other components, including other Chains.
+"""
+
+from typing import Any
+
+from langchain_classic._api import create_importer
+
+_module_lookup = {
+    "APIChain": "langchain_classic.chains.api.base",
+    "OpenAPIEndpointChain": "langchain_community.chains.openapi.chain",
+    "AnalyzeDocumentChain": "langchain_classic.chains.combine_documents.base",
+    "MapReduceDocumentsChain": "langchain_classic.chains.combine_documents.map_reduce",
+    "MapRerankDocumentsChain": "langchain_classic.chains.combine_documents.map_rerank",
+    "ReduceDocumentsChain": "langchain_classic.chains.combine_documents.reduce",
+    "RefineDocumentsChain": "langchain_classic.chains.combine_documents.refine",
+    "StuffDocumentsChain": "langchain_classic.chains.combine_documents.stuff",
+    "ConstitutionalChain": "langchain_classic.chains.constitutional_ai.base",
+    "ConversationChain": "langchain_classic.chains.conversation.base",
+    "ChatVectorDBChain": "langchain_classic.chains.conversational_retrieval.base",
+    "ConversationalRetrievalChain": (
+        "langchain_classic.chains.conversational_retrieval.base"
+    ),
+    "generate_example": "langchain_classic.chains.example_generator",
+    "FlareChain": "langchain_classic.chains.flare.base",
+    "ArangoGraphQAChain": "langchain_community.chains.graph_qa.arangodb",
+    "GraphQAChain": "langchain_community.chains.graph_qa.base",
+    "GraphCypherQAChain": "langchain_community.chains.graph_qa.cypher",
+    "FalkorDBQAChain": "langchain_community.chains.graph_qa.falkordb",
+    "HugeGraphQAChain": "langchain_community.chains.graph_qa.hugegraph",
+    "KuzuQAChain": "langchain_community.chains.graph_qa.kuzu",
+    "NebulaGraphQAChain": "langchain_community.chains.graph_qa.nebulagraph",
+    "NeptuneOpenCypherQAChain": "langchain_community.chains.graph_qa.neptune_cypher",
+    "NeptuneSparqlQAChain": "langchain_community.chains.graph_qa.neptune_sparql",
+    "OntotextGraphDBQAChain": "langchain_community.chains.graph_qa.ontotext_graphdb",
+    "GraphSparqlQAChain": "langchain_community.chains.graph_qa.sparql",
+    "create_history_aware_retriever": (
+        "langchain_classic.chains.history_aware_retriever"
+    ),
+    "HypotheticalDocumentEmbedder": "langchain_classic.chains.hyde.base",
+    "LLMChain": "langchain_classic.chains.llm",
+    "LLMCheckerChain": "langchain_classic.chains.llm_checker.base",
+    "LLMMathChain": "langchain_classic.chains.llm_math.base",
+    "LLMRequestsChain": "langchain_community.chains.llm_requests",
+    "LLMSummarizationCheckerChain": (
+        "langchain_classic.chains.llm_summarization_checker.base"
+    ),
+    "load_chain": "langchain_classic.chains.loading",
+    "MapReduceChain": "langchain_classic.chains.mapreduce",
+    "OpenAIModerationChain": "langchain_classic.chains.moderation",
+    "NatBotChain": "langchain_classic.chains.natbot.base",
+    "create_citation_fuzzy_match_chain": "langchain_classic.chains.openai_functions",
+    "create_citation_fuzzy_match_runnable": "langchain_classic.chains.openai_functions",
+    "create_extraction_chain": "langchain_classic.chains.openai_functions",
+    "create_extraction_chain_pydantic": "langchain_classic.chains.openai_functions",
+    "create_qa_with_sources_chain": "langchain_classic.chains.openai_functions",
+    "create_qa_with_structure_chain": "langchain_classic.chains.openai_functions",
+    "create_tagging_chain": "langchain_classic.chains.openai_functions",
+    "create_tagging_chain_pydantic": "langchain_classic.chains.openai_functions",
+    "QAGenerationChain": "langchain_classic.chains.qa_generation.base",
+    "QAWithSourcesChain": "langchain_classic.chains.qa_with_sources.base",
+    "RetrievalQAWithSourcesChain": "langchain_classic.chains.qa_with_sources.retrieval",
+    "VectorDBQAWithSourcesChain": "langchain_classic.chains.qa_with_sources.vector_db",
+    "create_retrieval_chain": "langchain_classic.chains.retrieval",
+    "RetrievalQA": "langchain_classic.chains.retrieval_qa.base",
+    "VectorDBQA": "langchain_classic.chains.retrieval_qa.base",
+    "LLMRouterChain": "langchain_classic.chains.router",
+    "MultiPromptChain": "langchain_classic.chains.router",
+    "MultiRetrievalQAChain": "langchain_classic.chains.router",
+    "MultiRouteChain": "langchain_classic.chains.router",
+    "RouterChain": "langchain_classic.chains.router",
+    "SequentialChain": "langchain_classic.chains.sequential",
+    "SimpleSequentialChain": "langchain_classic.chains.sequential",
+    "create_sql_query_chain": "langchain_classic.chains.sql_database.query",
+    "create_structured_output_runnable": "langchain_classic.chains.structured_output",
+    "load_summarize_chain": "langchain_classic.chains.summarize",
+    "TransformChain": "langchain_classic.chains.transform",
+}
+
+importer = create_importer(__package__, module_lookup=_module_lookup)
+
+
+def __getattr__(name: str) -> Any:
+    return importer(name)
+
+
+__all__ = list(_module_lookup.keys())

venv/Lib/site-packages/langchain_classic/chains/api/__init__.py

@@ -0,0 +1 @@
+"""Chain that makes API calls and summarizes the responses to answer a question."""

venv/Lib/site-packages/langchain_classic/chains/api/base.py

@@ -0,0 +1,399 @@
+"""Chain that makes API calls and summarizes the responses to answer a question."""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from typing import Any
+from urllib.parse import urlparse
+
+from langchain_core._api import deprecated
+from langchain_core.callbacks import (
+    AsyncCallbackManagerForChainRun,
+    CallbackManagerForChainRun,
+)
+from langchain_core.language_models import BaseLanguageModel
+from langchain_core.prompts import BasePromptTemplate
+from pydantic import Field, model_validator
+from typing_extensions import Self
+
+from langchain_classic.chains.api.prompt import API_RESPONSE_PROMPT, API_URL_PROMPT
+from langchain_classic.chains.base import Chain
+from langchain_classic.chains.llm import LLMChain
+
+
+def _extract_scheme_and_domain(url: str) -> tuple[str, str]:
+    """Extract the scheme + domain from a given URL.
+
+    Args:
+        url: The input URL.
+
+    Returns:
+        A 2-tuple of scheme and domain
+    """
+    parsed_uri = urlparse(url)
+    return parsed_uri.scheme, parsed_uri.netloc
+
+
+def _check_in_allowed_domain(url: str, limit_to_domains: Sequence[str]) -> bool:
+    """Check if a URL is in the allowed domains.
+
+    Args:
+        url: The input URL.
+        limit_to_domains: The allowed domains.
+
+    Returns:
+        `True` if the URL is in the allowed domains, `False` otherwise.
+    """
+    scheme, domain = _extract_scheme_and_domain(url)
+
+    for allowed_domain in limit_to_domains:
+        allowed_scheme, allowed_domain_ = _extract_scheme_and_domain(allowed_domain)
+        if scheme == allowed_scheme and domain == allowed_domain_:
+            return True
+    return False
+
+
+try:
+    from langchain_community.utilities.requests import TextRequestsWrapper
+
+    @deprecated(
+        since="0.2.13",
+        message=(
+            "This class is deprecated and will be removed in langchain 1.0. "
+            "See API reference for replacement: "
+            "https://api.python.langchain.com/en/latest/chains/langchain.chains.api.base.APIChain.html"
+        ),
+        removal="1.0",
+    )
+    class APIChain(Chain):
+        """Chain that makes API calls and summarizes the responses to answer a question.
+
+        **Security Note**: This API chain uses the requests toolkit
+            to make `GET`, `POST`, `PATCH`, `PUT`, and `DELETE` requests to an API.
+
+            Exercise care in who is allowed to use this chain. If exposing
+            to end users, consider that users will be able to make arbitrary
+            requests on behalf of the server hosting the code. For example,
+            users could ask the server to make a request to a private API
+            that is only accessible from the server.
+
+            Control access to who can submit issue requests using this toolkit and
+            what network access it has.
+
+            See https://docs.langchain.com/oss/python/security-policy for more
+            information.
+
+        !!! note
+            This class is deprecated. See below for a replacement implementation using
+            LangGraph. The benefits of this implementation are:
+
+        - Uses LLM tool calling features to encourage properly-formatted API requests;
+        - Support for both token-by-token and step-by-step streaming;
+        - Support for checkpointing and memory of chat history;
+        - Easier to modify or extend
+            (e.g., with additional tools, structured responses, etc.)
+
+        Install LangGraph with:
+
+        ```bash
+        pip install -U langgraph
+        ```
+
+        ```python
+        from typing import Annotated, Sequence
+        from typing_extensions import TypedDict
+
+        from langchain_classic.chains.api.prompt import API_URL_PROMPT
+        from langchain_community.agent_toolkits.openapi.toolkit import RequestsToolkit
+        from langchain_community.utilities.requests import TextRequestsWrapper
+        from langchain_core.messages import BaseMessage
+        from langchain_core.prompts import ChatPromptTemplate
+        from langchain_openai import ChatOpenAI
+        from langchain_core.runnables import RunnableConfig
+        from langgraph.graph import END, StateGraph
+        from langgraph.graph.message import add_messages
+        from langgraph.prebuilt.tool_node import ToolNode
+
+        # NOTE: There are inherent risks in giving models discretion
+        # to execute real-world actions. We must "opt-in" to these
+        # risks by setting allow_dangerous_request=True to use these tools.
+        # This can be dangerous for calling unwanted requests. Please make
+        # sure your custom OpenAPI spec (yaml) is safe and that permissions
+        # associated with the tools are narrowly-scoped.
+        ALLOW_DANGEROUS_REQUESTS = True
+
+        # Subset of spec for https://jsonplaceholder.typicode.com
+        api_spec = \"\"\"
+        openapi: 3.0.0
+        info:
+          title: JSONPlaceholder API
+          version: 1.0.0
+        servers:
+          - url: https://jsonplaceholder.typicode.com
+        paths:
+          /posts:
+            get:
+              summary: Get posts
+              parameters: &id001
+                - name: _limit
+                  in: query
+                  required: false
+                  schema:
+                    type: integer
+                  example: 2
+                  description: Limit the number of results
+        \"\"\"
+
+        model = ChatOpenAI(model="gpt-4o-mini", temperature=0)
+        toolkit = RequestsToolkit(
+            requests_wrapper=TextRequestsWrapper(headers={}),  # no auth required
+            allow_dangerous_requests=ALLOW_DANGEROUS_REQUESTS,
+        )
+        tools = toolkit.get_tools()
+
+        api_request_chain = (
+            API_URL_PROMPT.partial(api_docs=api_spec)
+            | model.bind_tools(tools, tool_choice="any")
+        )
+
+        class ChainState(TypedDict):
+            \"\"\"LangGraph state.\"\"\"
+
+            messages: Annotated[Sequence[BaseMessage], add_messages]
+
+
+        async def acall_request_chain(state: ChainState, config: RunnableConfig):
+            last_message = state["messages"][-1]
+            response = await api_request_chain.ainvoke(
+                {"question": last_message.content}, config
+            )
+            return {"messages": [response]}
+
+        async def acall_model(state: ChainState, config: RunnableConfig):
+            response = await model.ainvoke(state["messages"], config)
+            return {"messages": [response]}
+
+        graph_builder = StateGraph(ChainState)
+        graph_builder.add_node("call_tool", acall_request_chain)
+        graph_builder.add_node("execute_tool", ToolNode(tools))
+        graph_builder.add_node("call_model", acall_model)
+        graph_builder.set_entry_point("call_tool")
+        graph_builder.add_edge("call_tool", "execute_tool")
+        graph_builder.add_edge("execute_tool", "call_model")
+        graph_builder.add_edge("call_model", END)
+        chain = graph_builder.compile()
+        ```
+
+        ```python
+        example_query = "Fetch the top two posts. What are their titles?"
+
+        events = chain.astream(
+            {"messages": [("user", example_query)]},
+            stream_mode="values",
+        )
+        async for event in events:
+            event["messages"][-1].pretty_print()
+        ```
+        """
+
+        api_request_chain: LLMChain
+
+        api_answer_chain: LLMChain
+
+        requests_wrapper: TextRequestsWrapper = Field(exclude=True)
+
+        api_docs: str
+
+        question_key: str = "question"
+
+        output_key: str = "output"
+
+        limit_to_domains: Sequence[str] | None = Field(default_factory=list)
+        """Use to limit the domains that can be accessed by the API chain.
+
+        * For example, to limit to just the domain `https://www.example.com`, set
+            `limit_to_domains=["https://www.example.com"]`.
+        * The default value is an empty tuple, which means that no domains are
+            allowed by default. By design this will raise an error on instantiation.
+        * Use a None if you want to allow all domains by default -- this is not
+            recommended for security reasons, as it would allow malicious users to
+            make requests to arbitrary URLS including internal APIs accessible from
+            the server.
+        """
+
+        @property
+        def input_keys(self) -> list[str]:
+            """Expect input key."""
+            return [self.question_key]
+
+        @property
+        def output_keys(self) -> list[str]:
+            """Expect output key."""
+            return [self.output_key]
+
+        @model_validator(mode="after")
+        def validate_api_request_prompt(self) -> Self:
+            """Check that api request prompt expects the right variables."""
+            input_vars = self.api_request_chain.prompt.input_variables
+            expected_vars = {"question", "api_docs"}
+            if set(input_vars) != expected_vars:
+                msg = f"Input variables should be {expected_vars}, got {input_vars}"
+                raise ValueError(msg)
+            return self
+
+        @model_validator(mode="before")
+        @classmethod
+        def validate_limit_to_domains(cls, values: dict) -> Any:
+            """Check that allowed domains are valid."""
+            # This check must be a pre=True check, so that a default of None
+            # won't be set to limit_to_domains if it's not provided.
+            if "limit_to_domains" not in values:
+                msg = (
+                    "You must specify a list of domains to limit access using "
+                    "`limit_to_domains`"
+                )
+                raise ValueError(msg)
+            if (
+                not values["limit_to_domains"]
+                and values["limit_to_domains"] is not None
+            ):
+                msg = (
+                    "Please provide a list of domains to limit access using "
+                    "`limit_to_domains`."
+                )
+                raise ValueError(msg)
+            return values
+
+        @model_validator(mode="after")
+        def validate_api_answer_prompt(self) -> Self:
+            """Check that api answer prompt expects the right variables."""
+            input_vars = self.api_answer_chain.prompt.input_variables
+            expected_vars = {"question", "api_docs", "api_url", "api_response"}
+            if set(input_vars) != expected_vars:
+                msg = f"Input variables should be {expected_vars}, got {input_vars}"
+                raise ValueError(msg)
+            return self
+
+        def _call(
+            self,
+            inputs: dict[str, Any],
+            run_manager: CallbackManagerForChainRun | None = None,
+        ) -> dict[str, str]:
+            _run_manager = run_manager or CallbackManagerForChainRun.get_noop_manager()
+            question = inputs[self.question_key]
+            api_url = self.api_request_chain.predict(
+                question=question,
+                api_docs=self.api_docs,
+                callbacks=_run_manager.get_child(),
+            )
+            _run_manager.on_text(api_url, color="green", end="\n", verbose=self.verbose)
+            api_url = api_url.strip()
+            if self.limit_to_domains and not _check_in_allowed_domain(
+                api_url,
+                self.limit_to_domains,
+            ):
+                msg = (
+                    f"{api_url} is not in the allowed domains: {self.limit_to_domains}"
+                )
+                raise ValueError(msg)
+            api_response = self.requests_wrapper.get(api_url)
+            _run_manager.on_text(
+                str(api_response),
+                color="yellow",
+                end="\n",
+                verbose=self.verbose,
+            )
+            answer = self.api_answer_chain.predict(
+                question=question,
+                api_docs=self.api_docs,
+                api_url=api_url,
+                api_response=api_response,
+                callbacks=_run_manager.get_child(),
+            )
+            return {self.output_key: answer}
+
+        async def _acall(
+            self,
+            inputs: dict[str, Any],
+            run_manager: AsyncCallbackManagerForChainRun | None = None,
+        ) -> dict[str, str]:
+            _run_manager = (
+                run_manager or AsyncCallbackManagerForChainRun.get_noop_manager()
+            )
+            question = inputs[self.question_key]
+            api_url = await self.api_request_chain.apredict(
+                question=question,
+                api_docs=self.api_docs,
+                callbacks=_run_manager.get_child(),
+            )
+            await _run_manager.on_text(
+                api_url,
+                color="green",
+                end="\n",
+                verbose=self.verbose,
+            )
+            api_url = api_url.strip()
+            if self.limit_to_domains and not _check_in_allowed_domain(
+                api_url,
+                self.limit_to_domains,
+            ):
+                msg = (
+                    f"{api_url} is not in the allowed domains: {self.limit_to_domains}"
+                )
+                raise ValueError(msg)
+            api_response = await self.requests_wrapper.aget(api_url)
+            await _run_manager.on_text(
+                str(api_response),
+                color="yellow",
+                end="\n",
+                verbose=self.verbose,
+            )
+            answer = await self.api_answer_chain.apredict(
+                question=question,
+                api_docs=self.api_docs,
+                api_url=api_url,
+                api_response=api_response,
+                callbacks=_run_manager.get_child(),
+            )
+            return {self.output_key: answer}
+
+        @classmethod
+        def from_llm_and_api_docs(
+            cls,
+            llm: BaseLanguageModel,
+            api_docs: str,
+            headers: dict | None = None,
+            api_url_prompt: BasePromptTemplate = API_URL_PROMPT,
+            api_response_prompt: BasePromptTemplate = API_RESPONSE_PROMPT,
+            limit_to_domains: Sequence[str] | None = (),
+            **kwargs: Any,
+        ) -> APIChain:
+            """Load chain from just an LLM and the api docs."""
+            get_request_chain = LLMChain(llm=llm, prompt=api_url_prompt)
+            requests_wrapper = TextRequestsWrapper(headers=headers)
+            get_answer_chain = LLMChain(llm=llm, prompt=api_response_prompt)
+            return cls(
+                api_request_chain=get_request_chain,
+                api_answer_chain=get_answer_chain,
+                requests_wrapper=requests_wrapper,
+                api_docs=api_docs,
+                limit_to_domains=limit_to_domains,
+                **kwargs,
+            )
+
+        @property
+        def _chain_type(self) -> str:
+            return "api_chain"
+
+except ImportError:
+
+    class APIChain:  # type: ignore[no-redef]
+        """Raise an ImportError if APIChain is used without langchain_community."""
+
+        def __init__(self, *_: Any, **__: Any) -> None:
+            """Raise an ImportError if APIChain is used without langchain_community."""
+            msg = (
+                "To use the APIChain, you must install the langchain_community package."
+                "pip install langchain_community"
+            )
+            raise ImportError(msg)

venv/Lib/site-packages/langchain_classic/chains/api/news_docs.py

@@ -0,0 +1,31 @@
+NEWS_DOCS = """API documentation:
+Endpoint: https://newsapi.org
+Top headlines /v2/top-headlines
+
+This endpoint provides live top and breaking headlines for a country, specific category in a country, single source, or multiple sources. You can also search with keywords. Articles are sorted by the earliest date published first.
+
+This endpoint is great for retrieving headlines for use with news tickers or similar.
+Request parameters
+
+    country | The 2-letter ISO 3166-1 code of the country you want to get headlines for. Possible options: ae ar at au be bg br ca ch cn co cu cz de eg fr gb gr hk hu id ie il in it jp kr lt lv ma mx my ng nl no nz ph pl pt ro rs ru sa se sg si sk th tr tw ua us ve za. Note: you can't mix this param with the sources param.
+    category | The category you want to get headlines for. Possible options: business entertainment general health science sports technology. Note: you can't mix this param with the sources param.
+    sources | A comma-separated string of identifiers for the news sources or blogs you want headlines from. Use the /top-headlines/sources endpoint to locate these programmatically or look at the sources index. Note: you can't mix this param with the country or category params.
+    q | Keywords or a phrase to search for.
+    pageSize | int | The number of results to return per page (request). 20 is the default, 100 is the maximum.
+    page | int | Use this to page through the results if the total results found is greater than the page size.
+
+Response object
+    status | string | If the request was successful or not. Options: ok, error. In the case of error a code and message property will be populated.
+    totalResults | int | The total number of results available for your request.
+    articles | array[article] | The results of the request.
+    source | object | The identifier id and a display name name for the source this article came from.
+    author | string | The author of the article
+    title | string | The headline or title of the article.
+    description | string | A description or snippet from the article.
+    url | string | The direct URL to the article.
+    urlToImage | string | The URL to a relevant image for the article.
+    publishedAt | string | The date and time that the article was published, in UTC (+000)
+    content | string | The unformatted content of the article, where available. This is truncated to 200 chars.
+
+Use page size: 2
+"""  # noqa: E501

venv/Lib/site-packages/langchain_classic/chains/api/open_meteo_docs.py

@@ -0,0 +1,32 @@
+OPEN_METEO_DOCS = """BASE URL: https://api.open-meteo.com/
+
+API Documentation
+The API endpoint /v1/forecast accepts a geographical coordinate, a list of weather variables and responds with a JSON hourly weather forecast for 7 days. Time always starts at 0:00 today and contains 168 hours. All URL parameters are listed below:
+
+Parameter	Format	Required	Default	Description
+latitude, longitude	Floating point	Yes		Geographical WGS84 coordinate of the location
+hourly	String array	No		A list of weather variables which should be returned. Values can be comma separated, or multiple &hourly= parameter in the URL can be used.
+daily	String array	No		A list of daily weather variable aggregations which should be returned. Values can be comma separated, or multiple &daily= parameter in the URL can be used. If daily weather variables are specified, parameter timezone is required.
+current_weather	Bool	No	false	Include current weather conditions in the JSON output.
+temperature_unit	String	No	celsius	If fahrenheit is set, all temperature values are converted to Fahrenheit.
+windspeed_unit	String	No	kmh	Other wind speed speed units: ms, mph and kn
+precipitation_unit	String	No	mm	Other precipitation amount units: inch
+timeformat	String	No	iso8601	If format unixtime is selected, all time values are returned in UNIX epoch time in seconds. Please note that all timestamp are in GMT+0! For daily values with unix timestamps, please apply utc_offset_seconds again to get the correct date.
+timezone	String	No	GMT	If timezone is set, all timestamps are returned as local-time and data is returned starting at 00:00 local-time. Any time zone name from the time zone database is supported. If auto is set as a time zone, the coordinates will be automatically resolved to the local time zone.
+past_days	Integer (0-2)	No	0	If past_days is set, yesterday or the day before yesterday data are also returned.
+start_date
+end_date	String (yyyy-mm-dd)	No		The time interval to get weather data. A day must be specified as an ISO8601 date (e.g. 2022-06-30).
+models	String array	No	auto	Manually select one or more weather models. Per default, the best suitable weather models will be combined.
+
+Hourly Parameter Definition
+The parameter &hourly= accepts the following values. Most weather variables are given as an instantaneous value for the indicated hour. Some variables like precipitation are calculated from the preceding hour as an average or sum.
+
+Variable	Valid time	Unit	Description
+temperature_2m	Instant	°C (°F)	Air temperature at 2 meters above ground
+snowfall	Preceding hour sum	cm (inch)	Snowfall amount of the preceding hour in centimeters. For the water equivalent in millimeter, divide by 7. E.g. 7 cm snow = 10 mm precipitation water equivalent
+rain	Preceding hour sum	mm (inch)	Rain from large scale weather systems of the preceding hour in millimeter
+showers	Preceding hour sum	mm (inch)	Showers from convective precipitation in millimeters from the preceding hour
+weathercode	Instant	WMO code	Weather condition as a numeric code. Follow WMO weather interpretation codes. See table below for details.
+snow_depth	Instant	meters	Snow depth on the ground
+freezinglevel_height	Instant	meters	Altitude above sea level of the 0°C level
+visibility	Instant	meters	Viewing distance in meters. Influenced by low clouds, humidity and aerosols. Maximum visibility is approximately 24 km."""  # noqa: E501

venv/Lib/site-packages/langchain_classic/chains/api/openapi/chain.py

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

venv/Lib/site-packages/langchain_classic/chains/api/openapi/prompts.py

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

venv/Lib/site-packages/langchain_classic/chains/api/openapi/requests_chain.py

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

venv/Lib/site-packages/langchain_classic/chains/api/openapi/response_chain.py

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

venv/Lib/site-packages/langchain_classic/chains/api/podcast_docs.py

@@ -0,0 +1,27 @@
+PODCAST_DOCS = """API documentation:
+Endpoint: https://listen-api.listennotes.com/api/v2
+GET /search
+
+This API is for searching podcasts or episodes.
+
+Query parameters table:
+q | string | Search term, e.g., person, place, topic... You can use double quotes to do verbatim match, e.g., "game of thrones". Otherwise, it's fuzzy search. | required
+type | string | What type of contents do you want to search for? Available values: episode, podcast, curated. default: episode | optional
+page_size | integer | The maximum number of search results per page. A valid value should be an integer between 1 and 10 (inclusive). default: 3 | optional
+language | string | Limit search results to a specific language, e.g., English, Chinese ... If not specified, it'll be any language. It works only when type is episode or podcast. | optional
+region | string | Limit search results to a specific region (e.g., us, gb, in...). If not specified, it'll be any region. It works only when type is episode or podcast. | optional
+len_min | integer | Minimum audio length in minutes. Applicable only when type parameter is episode or podcast. If type parameter is episode, it's for audio length of an episode. If type parameter is podcast, it's for average audio length of all episodes in a podcast. | optional
+len_max | integer | Maximum audio length in minutes. Applicable only when type parameter is episode or podcast. If type parameter is episode, it's for audio length of an episode. If type parameter is podcast, it's for average audio length of all episodes in a podcast. | optional
+
+Response schema (JSON object):
+next_offset | integer | optional
+total | integer | optional
+results | array[object] (Episode / Podcast List Result Object)
+
+Each object in the "results" key has the following schema:
+listennotes_url | string | optional
+id | integer | optional
+title_highlighted | string | optional
+
+Use page_size: 3
+"""  # noqa: E501

venv/Lib/site-packages/langchain_classic/chains/api/prompt.py

@@ -0,0 +1,35 @@
+from langchain_core.prompts.prompt import PromptTemplate
+
+API_URL_PROMPT_TEMPLATE = """You are given the below API Documentation:
+{api_docs}
+Using this documentation, generate the full API url to call for answering the user question.
+You should build the API url in order to get a response that is as short as possible, while still getting the necessary information to answer the question. Pay attention to deliberately exclude any unnecessary pieces of data in the API call.
+
+Question:{question}
+API url:"""  # noqa: E501
+
+API_URL_PROMPT = PromptTemplate(
+    input_variables=[
+        "api_docs",
+        "question",
+    ],
+    template=API_URL_PROMPT_TEMPLATE,
+)
+
+API_RESPONSE_PROMPT_TEMPLATE = (
+    API_URL_PROMPT_TEMPLATE
+    + """ {api_url}
+
+Here is the response from the API:
+
+{api_response}
+
+Summarize this response to answer the original question.
+
+Summary:"""
+)
+
+API_RESPONSE_PROMPT = PromptTemplate(
+    input_variables=["api_docs", "question", "api_url", "api_response"],
+    template=API_RESPONSE_PROMPT_TEMPLATE,
+)

venv/Lib/site-packages/langchain_classic/chains/api/tmdb_docs.py

@@ -0,0 +1,36 @@
+TMDB_DOCS = """API documentation:
+Endpoint: https://api.themoviedb.org/3
+GET /search/movie
+
+This API is for searching movies.
+
+Query parameters table:
+language | string | Pass a ISO 639-1 value to display translated data for the fields that support it. minLength: 2, pattern: ([a-z]{2})-([A-Z]{2}), default: en-US | optional
+query | string | Pass a text query to search. This value should be URI encoded. minLength: 1 | required
+page | integer | Specify which page to query. minimum: 1, maximum: 1000, default: 1 | optional
+include_adult | boolean | Choose whether to include adult (pornography) content in the results. default | optional
+region | string | Specify a ISO 3166-1 code to filter release dates. Must be uppercase. pattern: ^[A-Z]{2}$ | optional
+year | integer  | optional
+primary_release_year | integer | optional
+
+Response schema (JSON object):
+page | integer | optional
+total_results | integer | optional
+total_pages | integer | optional
+results | array[object] (Movie List Result Object)
+
+Each object in the "results" key has the following schema:
+poster_path | string or null | optional
+adult | boolean | optional
+overview | string | optional
+release_date | string | optional
+genre_ids | array[integer] | optional
+id | integer | optional
+original_title | string | optional
+original_language | string | optional
+title | string | optional
+backdrop_path | string or null | optional
+popularity | number | optional
+vote_count | integer | optional
+video | boolean | optional
+vote_average | number | optional"""  # noqa: E501

venv/Lib/site-packages/langchain_classic/chains/base.py

@@ -0,0 +1,806 @@
+"""Base interface that all chains should implement."""
+
+import builtins
+import contextlib
+import inspect
+import json
+import logging
+import warnings
+from abc import ABC, abstractmethod
+from pathlib import Path
+from typing import Any, cast
+
+import yaml
+from langchain_core._api import deprecated
+from langchain_core.callbacks import (
+    AsyncCallbackManager,
+    AsyncCallbackManagerForChainRun,
+    BaseCallbackManager,
+    CallbackManager,
+    CallbackManagerForChainRun,
+    Callbacks,
+)
+from langchain_core.outputs import RunInfo
+from langchain_core.runnables import (
+    RunnableConfig,
+    RunnableSerializable,
+    ensure_config,
+    run_in_executor,
+)
+from langchain_core.utils.pydantic import create_model
+from pydantic import (
+    BaseModel,
+    ConfigDict,
+    Field,
+    field_validator,
+    model_validator,
+)
+from typing_extensions import override
+
+from langchain_classic.base_memory import BaseMemory
+from langchain_classic.schema import RUN_KEY
+
+logger = logging.getLogger(__name__)
+
+
+def _get_verbosity() -> bool:
+    from langchain_classic.globals import get_verbose
+
+    return get_verbose()
+
+
+class Chain(RunnableSerializable[dict[str, Any], dict[str, Any]], ABC):
+    """Abstract base class for creating structured sequences of calls to components.
+
+    Chains should be used to encode a sequence of calls to components like
+    models, document retrievers, other chains, etc., and provide a simple interface
+    to this sequence.
+
+    The Chain interface makes it easy to create apps that are:
+        - Stateful: add Memory to any Chain to give it state,
+        - Observable: pass Callbacks to a Chain to execute additional functionality,
+            like logging, outside the main sequence of component calls,
+        - Composable: the Chain API is flexible enough that it is easy to combine
+            Chains with other components, including other Chains.
+
+    The main methods exposed by chains are:
+        - `__call__`: Chains are callable. The `__call__` method is the primary way to
+            execute a Chain. This takes inputs as a dictionary and returns a
+            dictionary output.
+        - `run`: A convenience method that takes inputs as args/kwargs and returns the
+            output as a string or object. This method can only be used for a subset of
+            chains and cannot return as rich of an output as `__call__`.
+    """
+
+    memory: BaseMemory | None = None
+    """Optional memory object.
+    Memory is a class that gets called at the start
+    and at the end of every chain. At the start, memory loads variables and passes
+    them along in the chain. At the end, it saves any returned variables.
+    There are many different types of memory - please see memory docs
+    for the full catalog."""
+    callbacks: Callbacks = Field(default=None, exclude=True)
+    """Optional list of callback handlers (or callback manager).
+    Callback handlers are called throughout the lifecycle of a call to a chain,
+    starting with on_chain_start, ending with on_chain_end or on_chain_error.
+    Each custom chain can optionally call additional callback methods, see Callback docs
+    for full details."""
+    verbose: bool = Field(default_factory=_get_verbosity)
+    """Whether or not run in verbose mode. In verbose mode, some intermediate logs
+    will be printed to the console. Defaults to the global `verbose` value,
+    accessible via `langchain.globals.get_verbose()`."""
+    tags: list[str] | None = None
+    """Optional list of tags associated with the chain.
+    These tags will be associated with each call to this chain,
+    and passed as arguments to the handlers defined in `callbacks`.
+    You can use these to eg identify a specific instance of a chain with its use case.
+    """
+    metadata: builtins.dict[str, Any] | None = None
+    """Optional metadata associated with the chain.
+    This metadata will be associated with each call to this chain,
+    and passed as arguments to the handlers defined in `callbacks`.
+    You can use these to eg identify a specific instance of a chain with its use case.
+    """
+    callback_manager: BaseCallbackManager | None = Field(default=None, exclude=True)
+    """[DEPRECATED] Use `callbacks` instead."""
+
+    model_config = ConfigDict(
+        arbitrary_types_allowed=True,
+    )
+
+    @override
+    def get_input_schema(
+        self,
+        config: RunnableConfig | None = None,
+    ) -> type[BaseModel]:
+        # This is correct, but pydantic typings/mypy don't think so.
+        return create_model("ChainInput", **dict.fromkeys(self.input_keys, (Any, None)))
+
+    @override
+    def get_output_schema(
+        self,
+        config: RunnableConfig | None = None,
+    ) -> type[BaseModel]:
+        # This is correct, but pydantic typings/mypy don't think so.
+        return create_model(
+            "ChainOutput",
+            **dict.fromkeys(self.output_keys, (Any, None)),
+        )
+
+    @override
+    def invoke(
+        self,
+        input: dict[str, Any],
+        config: RunnableConfig | None = None,
+        **kwargs: Any,
+    ) -> dict[str, Any]:
+        config = ensure_config(config)
+        callbacks = config.get("callbacks")
+        tags = config.get("tags")
+        metadata = config.get("metadata")
+        run_name = config.get("run_name") or self.get_name()
+        run_id = config.get("run_id")
+        include_run_info = kwargs.get("include_run_info", False)
+        return_only_outputs = kwargs.get("return_only_outputs", False)
+
+        inputs = self.prep_inputs(input)
+        callback_manager = CallbackManager.configure(
+            callbacks,
+            self.callbacks,
+            self.verbose,
+            tags,
+            self.tags,
+            metadata,
+            self.metadata,
+        )
+        new_arg_supported = inspect.signature(self._call).parameters.get("run_manager")
+
+        run_manager = callback_manager.on_chain_start(
+            None,
+            inputs,
+            run_id,
+            name=run_name,
+        )
+        try:
+            self._validate_inputs(inputs)
+            outputs = (
+                self._call(inputs, run_manager=run_manager)
+                if new_arg_supported
+                else self._call(inputs)
+            )
+
+            final_outputs: dict[str, Any] = self.prep_outputs(
+                inputs,
+                outputs,
+                return_only_outputs,
+            )
+        except BaseException as e:
+            run_manager.on_chain_error(e)
+            raise
+        run_manager.on_chain_end(outputs)
+
+        if include_run_info:
+            final_outputs[RUN_KEY] = RunInfo(run_id=run_manager.run_id)
+        return final_outputs
+
+    @override
+    async def ainvoke(
+        self,
+        input: dict[str, Any],
+        config: RunnableConfig | None = None,
+        **kwargs: Any,
+    ) -> dict[str, Any]:
+        config = ensure_config(config)
+        callbacks = config.get("callbacks")
+        tags = config.get("tags")
+        metadata = config.get("metadata")
+        run_name = config.get("run_name") or self.get_name()
+        run_id = config.get("run_id")
+        include_run_info = kwargs.get("include_run_info", False)
+        return_only_outputs = kwargs.get("return_only_outputs", False)
+
+        inputs = await self.aprep_inputs(input)
+        callback_manager = AsyncCallbackManager.configure(
+            callbacks,
+            self.callbacks,
+            self.verbose,
+            tags,
+            self.tags,
+            metadata,
+            self.metadata,
+        )
+        new_arg_supported = inspect.signature(self._acall).parameters.get("run_manager")
+        run_manager = await callback_manager.on_chain_start(
+            None,
+            inputs,
+            run_id,
+            name=run_name,
+        )
+        try:
+            self._validate_inputs(inputs)
+            outputs = (
+                await self._acall(inputs, run_manager=run_manager)
+                if new_arg_supported
+                else await self._acall(inputs)
+            )
+            final_outputs: dict[str, Any] = await self.aprep_outputs(
+                inputs,
+                outputs,
+                return_only_outputs,
+            )
+        except BaseException as e:
+            await run_manager.on_chain_error(e)
+            raise
+        await run_manager.on_chain_end(outputs)
+
+        if include_run_info:
+            final_outputs[RUN_KEY] = RunInfo(run_id=run_manager.run_id)
+        return final_outputs
+
+    @property
+    def _chain_type(self) -> str:
+        msg = "Saving not supported for this chain type."
+        raise NotImplementedError(msg)
+
+    @model_validator(mode="before")
+    @classmethod
+    def raise_callback_manager_deprecation(cls, values: dict) -> Any:
+        """Raise deprecation warning if callback_manager is used."""
+        if values.get("callback_manager") is not None:
+            if values.get("callbacks") is not None:
+                msg = (
+                    "Cannot specify both callback_manager and callbacks. "
+                    "callback_manager is deprecated, callbacks is the preferred "
+                    "parameter to pass in."
+                )
+                raise ValueError(msg)
+            warnings.warn(
+                "callback_manager is deprecated. Please use callbacks instead.",
+                DeprecationWarning,
+                stacklevel=4,
+            )
+            values["callbacks"] = values.pop("callback_manager", None)
+        return values
+
+    @field_validator("verbose", mode="before")
+    @classmethod
+    def set_verbose(
+        cls,
+        verbose: bool | None,  # noqa: FBT001
+    ) -> bool:
+        """Set the chain verbosity.
+
+        Defaults to the global setting if not specified by the user.
+        """
+        if verbose is None:
+            return _get_verbosity()
+        return verbose
+
+    @property
+    @abstractmethod
+    def input_keys(self) -> list[str]:
+        """Keys expected to be in the chain input."""
+
+    @property
+    @abstractmethod
+    def output_keys(self) -> list[str]:
+        """Keys expected to be in the chain output."""
+
+    def _validate_inputs(self, inputs: Any) -> None:
+        """Check that all inputs are present."""
+        if not isinstance(inputs, dict):
+            _input_keys = set(self.input_keys)
+            if self.memory is not None:
+                # If there are multiple input keys, but some get set by memory so that
+                # only one is not set, we can still figure out which key it is.
+                _input_keys = _input_keys.difference(self.memory.memory_variables)
+            if len(_input_keys) != 1:
+                msg = (
+                    f"A single string input was passed in, but this chain expects "
+                    f"multiple inputs ({_input_keys}). When a chain expects "
+                    f"multiple inputs, please call it by passing in a dictionary, "
+                    "eg `chain({'foo': 1, 'bar': 2})`"
+                )
+                raise ValueError(msg)
+
+        missing_keys = set(self.input_keys).difference(inputs)
+        if missing_keys:
+            msg = f"Missing some input keys: {missing_keys}"
+            raise ValueError(msg)
+
+    def _validate_outputs(self, outputs: dict[str, Any]) -> None:
+        missing_keys = set(self.output_keys).difference(outputs)
+        if missing_keys:
+            msg = f"Missing some output keys: {missing_keys}"
+            raise ValueError(msg)
+
+    @abstractmethod
+    def _call(
+        self,
+        inputs: builtins.dict[str, Any],
+        run_manager: CallbackManagerForChainRun | None = None,
+    ) -> builtins.dict[str, Any]:
+        """Execute the chain.
+
+        This is a private method that is not user-facing. It is only called within
+            `Chain.__call__`, which is the user-facing wrapper method that handles
+            callbacks configuration and some input/output processing.
+
+        Args:
+            inputs: A dict of named inputs to the chain. Assumed to contain all inputs
+                specified in `Chain.input_keys`, including any inputs added by memory.
+            run_manager: The callbacks manager that contains the callback handlers for
+                this run of the chain.
+
+        Returns:
+            A dict of named outputs. Should contain all outputs specified in
+                `Chain.output_keys`.
+        """
+
+    async def _acall(
+        self,
+        inputs: builtins.dict[str, Any],
+        run_manager: AsyncCallbackManagerForChainRun | None = None,
+    ) -> builtins.dict[str, Any]:
+        """Asynchronously execute the chain.
+
+        This is a private method that is not user-facing. It is only called within
+            `Chain.acall`, which is the user-facing wrapper method that handles
+            callbacks configuration and some input/output processing.
+
+        Args:
+            inputs: A dict of named inputs to the chain. Assumed to contain all inputs
+                specified in `Chain.input_keys`, including any inputs added by memory.
+            run_manager: The callbacks manager that contains the callback handlers for
+                this run of the chain.
+
+        Returns:
+            A dict of named outputs. Should contain all outputs specified in
+                `Chain.output_keys`.
+        """
+        return await run_in_executor(
+            None,
+            self._call,
+            inputs,
+            run_manager.get_sync() if run_manager else None,
+        )
+
+    @deprecated("0.1.0", alternative="invoke", removal="1.0")
+    def __call__(
+        self,
+        inputs: dict[str, Any] | Any,
+        return_only_outputs: bool = False,  # noqa: FBT001,FBT002
+        callbacks: Callbacks = None,
+        *,
+        tags: list[str] | None = None,
+        metadata: dict[str, Any] | None = None,
+        run_name: str | None = None,
+        include_run_info: bool = False,
+    ) -> dict[str, Any]:
+        """Execute the chain.
+
+        Args:
+            inputs: Dictionary of inputs, or single input if chain expects
+                only one param. Should contain all inputs specified in
+                `Chain.input_keys` except for inputs that will be set by the chain's
+                memory.
+            return_only_outputs: Whether to return only outputs in the
+                response. If `True`, only new keys generated by this chain will be
+                returned. If `False`, both input keys and new keys generated by this
+                chain will be returned.
+            callbacks: Callbacks to use for this chain run. These will be called in
+                addition to callbacks passed to the chain during construction, but only
+                these runtime callbacks will propagate to calls to other objects.
+            tags: List of string tags to pass to all callbacks. These will be passed in
+                addition to tags passed to the chain during construction, but only
+                these runtime tags will propagate to calls to other objects.
+            metadata: Optional metadata associated with the chain.
+            run_name: Optional name for this run of the chain.
+            include_run_info: Whether to include run info in the response. Defaults
+                to False.
+
+        Returns:
+            A dict of named outputs. Should contain all outputs specified in
+                `Chain.output_keys`.
+        """
+        config = {
+            "callbacks": callbacks,
+            "tags": tags,
+            "metadata": metadata,
+            "run_name": run_name,
+        }
+
+        return self.invoke(
+            inputs,
+            cast("RunnableConfig", {k: v for k, v in config.items() if v is not None}),
+            return_only_outputs=return_only_outputs,
+            include_run_info=include_run_info,
+        )
+
+    @deprecated("0.1.0", alternative="ainvoke", removal="1.0")
+    async def acall(
+        self,
+        inputs: dict[str, Any] | Any,
+        return_only_outputs: bool = False,  # noqa: FBT001,FBT002
+        callbacks: Callbacks = None,
+        *,
+        tags: list[str] | None = None,
+        metadata: dict[str, Any] | None = None,
+        run_name: str | None = None,
+        include_run_info: bool = False,
+    ) -> dict[str, Any]:
+        """Asynchronously execute the chain.
+
+        Args:
+            inputs: Dictionary of inputs, or single input if chain expects
+                only one param. Should contain all inputs specified in
+                `Chain.input_keys` except for inputs that will be set by the chain's
+                memory.
+            return_only_outputs: Whether to return only outputs in the
+                response. If `True`, only new keys generated by this chain will be
+                returned. If `False`, both input keys and new keys generated by this
+                chain will be returned.
+            callbacks: Callbacks to use for this chain run. These will be called in
+                addition to callbacks passed to the chain during construction, but only
+                these runtime callbacks will propagate to calls to other objects.
+            tags: List of string tags to pass to all callbacks. These will be passed in
+                addition to tags passed to the chain during construction, but only
+                these runtime tags will propagate to calls to other objects.
+            metadata: Optional metadata associated with the chain.
+            run_name: Optional name for this run of the chain.
+            include_run_info: Whether to include run info in the response. Defaults
+                to False.
+
+        Returns:
+            A dict of named outputs. Should contain all outputs specified in
+                `Chain.output_keys`.
+        """
+        config = {
+            "callbacks": callbacks,
+            "tags": tags,
+            "metadata": metadata,
+            "run_name": run_name,
+        }
+        return await self.ainvoke(
+            inputs,
+            cast("RunnableConfig", {k: v for k, v in config.items() if k is not None}),
+            return_only_outputs=return_only_outputs,
+            include_run_info=include_run_info,
+        )
+
+    def prep_outputs(
+        self,
+        inputs: dict[str, str],
+        outputs: dict[str, str],
+        return_only_outputs: bool = False,  # noqa: FBT001,FBT002
+    ) -> dict[str, str]:
+        """Validate and prepare chain outputs, and save info about this run to memory.
+
+        Args:
+            inputs: Dictionary of chain inputs, including any inputs added by chain
+                memory.
+            outputs: Dictionary of initial chain outputs.
+            return_only_outputs: Whether to only return the chain outputs. If `False`,
+                inputs are also added to the final outputs.
+
+        Returns:
+            A dict of the final chain outputs.
+        """
+        self._validate_outputs(outputs)
+        if self.memory is not None:
+            self.memory.save_context(inputs, outputs)
+        if return_only_outputs:
+            return outputs
+        return {**inputs, **outputs}
+
+    async def aprep_outputs(
+        self,
+        inputs: dict[str, str],
+        outputs: dict[str, str],
+        return_only_outputs: bool = False,  # noqa: FBT001,FBT002
+    ) -> dict[str, str]:
+        """Validate and prepare chain outputs, and save info about this run to memory.
+
+        Args:
+            inputs: Dictionary of chain inputs, including any inputs added by chain
+                memory.
+            outputs: Dictionary of initial chain outputs.
+            return_only_outputs: Whether to only return the chain outputs. If `False`,
+                inputs are also added to the final outputs.
+
+        Returns:
+            A dict of the final chain outputs.
+        """
+        self._validate_outputs(outputs)
+        if self.memory is not None:
+            await self.memory.asave_context(inputs, outputs)
+        if return_only_outputs:
+            return outputs
+        return {**inputs, **outputs}
+
+    def prep_inputs(self, inputs: dict[str, Any] | Any) -> dict[str, str]:
+        """Prepare chain inputs, including adding inputs from memory.
+
+        Args:
+            inputs: Dictionary of raw inputs, or single input if chain expects
+                only one param. Should contain all inputs specified in
+                `Chain.input_keys` except for inputs that will be set by the chain's
+                memory.
+
+        Returns:
+            A dictionary of all inputs, including those added by the chain's memory.
+        """
+        if not isinstance(inputs, dict):
+            _input_keys = set(self.input_keys)
+            if self.memory is not None:
+                # If there are multiple input keys, but some get set by memory so that
+                # only one is not set, we can still figure out which key it is.
+                _input_keys = _input_keys.difference(self.memory.memory_variables)
+            inputs = {next(iter(_input_keys)): inputs}
+        if self.memory is not None:
+            external_context = self.memory.load_memory_variables(inputs)
+            inputs = dict(inputs, **external_context)
+        return inputs
+
+    async def aprep_inputs(self, inputs: dict[str, Any] | Any) -> dict[str, str]:
+        """Prepare chain inputs, including adding inputs from memory.
+
+        Args:
+            inputs: Dictionary of raw inputs, or single input if chain expects
+                only one param. Should contain all inputs specified in
+                `Chain.input_keys` except for inputs that will be set by the chain's
+                memory.
+
+        Returns:
+            A dictionary of all inputs, including those added by the chain's memory.
+        """
+        if not isinstance(inputs, dict):
+            _input_keys = set(self.input_keys)
+            if self.memory is not None:
+                # If there are multiple input keys, but some get set by memory so that
+                # only one is not set, we can still figure out which key it is.
+                _input_keys = _input_keys.difference(self.memory.memory_variables)
+            inputs = {next(iter(_input_keys)): inputs}
+        if self.memory is not None:
+            external_context = await self.memory.aload_memory_variables(inputs)
+            inputs = dict(inputs, **external_context)
+        return inputs
+
+    @property
+    def _run_output_key(self) -> str:
+        if len(self.output_keys) != 1:
+            msg = (
+                f"`run` not supported when there is not exactly "
+                f"one output key. Got {self.output_keys}."
+            )
+            raise ValueError(msg)
+        return self.output_keys[0]
+
+    @deprecated("0.1.0", alternative="invoke", removal="1.0")
+    def run(
+        self,
+        *args: Any,
+        callbacks: Callbacks = None,
+        tags: list[str] | None = None,
+        metadata: dict[str, Any] | None = None,
+        **kwargs: Any,
+    ) -> Any:
+        """Convenience method for executing chain.
+
+        The main difference between this method and `Chain.__call__` is that this
+        method expects inputs to be passed directly in as positional arguments or
+        keyword arguments, whereas `Chain.__call__` expects a single input dictionary
+        with all the inputs
+
+        Args:
+            *args: If the chain expects a single input, it can be passed in as the
+                sole positional argument.
+            callbacks: Callbacks to use for this chain run. These will be called in
+                addition to callbacks passed to the chain during construction, but only
+                these runtime callbacks will propagate to calls to other objects.
+            tags: List of string tags to pass to all callbacks. These will be passed in
+                addition to tags passed to the chain during construction, but only
+                these runtime tags will propagate to calls to other objects.
+            metadata: Optional metadata associated with the chain.
+            **kwargs: If the chain expects multiple inputs, they can be passed in
+                directly as keyword arguments.
+
+        Returns:
+            The chain output.
+
+        Example:
+            ```python
+            # Suppose we have a single-input chain that takes a 'question' string:
+            chain.run("What's the temperature in Boise, Idaho?")
+            # -> "The temperature in Boise is..."
+
+            # Suppose we have a multi-input chain that takes a 'question' string
+            # and 'context' string:
+            question = "What's the temperature in Boise, Idaho?"
+            context = "Weather report for Boise, Idaho on 07/03/23..."
+            chain.run(question=question, context=context)
+            # -> "The temperature in Boise is..."
+            ```
+        """
+        # Run at start to make sure this is possible/defined
+        _output_key = self._run_output_key
+
+        if args and not kwargs:
+            if len(args) != 1:
+                msg = "`run` supports only one positional argument."
+                raise ValueError(msg)
+            return self(args[0], callbacks=callbacks, tags=tags, metadata=metadata)[
+                _output_key
+            ]
+
+        if kwargs and not args:
+            return self(kwargs, callbacks=callbacks, tags=tags, metadata=metadata)[
+                _output_key
+            ]
+
+        if not kwargs and not args:
+            msg = (
+                "`run` supported with either positional arguments or keyword arguments,"
+                " but none were provided."
+            )
+            raise ValueError(msg)
+        msg = (
+            f"`run` supported with either positional arguments or keyword arguments"
+            f" but not both. Got args: {args} and kwargs: {kwargs}."
+        )
+        raise ValueError(msg)
+
+    @deprecated("0.1.0", alternative="ainvoke", removal="1.0")
+    async def arun(
+        self,
+        *args: Any,
+        callbacks: Callbacks = None,
+        tags: list[str] | None = None,
+        metadata: dict[str, Any] | None = None,
+        **kwargs: Any,
+    ) -> Any:
+        """Convenience method for executing chain.
+
+        The main difference between this method and `Chain.__call__` is that this
+        method expects inputs to be passed directly in as positional arguments or
+        keyword arguments, whereas `Chain.__call__` expects a single input dictionary
+        with all the inputs
+
+
+        Args:
+            *args: If the chain expects a single input, it can be passed in as the
+                sole positional argument.
+            callbacks: Callbacks to use for this chain run. These will be called in
+                addition to callbacks passed to the chain during construction, but only
+                these runtime callbacks will propagate to calls to other objects.
+            tags: List of string tags to pass to all callbacks. These will be passed in
+                addition to tags passed to the chain during construction, but only
+                these runtime tags will propagate to calls to other objects.
+            metadata: Optional metadata associated with the chain.
+            **kwargs: If the chain expects multiple inputs, they can be passed in
+                directly as keyword arguments.
+
+        Returns:
+            The chain output.
+
+        Example:
+            ```python
+            # Suppose we have a single-input chain that takes a 'question' string:
+            await chain.arun("What's the temperature in Boise, Idaho?")
+            # -> "The temperature in Boise is..."
+
+            # Suppose we have a multi-input chain that takes a 'question' string
+            # and 'context' string:
+            question = "What's the temperature in Boise, Idaho?"
+            context = "Weather report for Boise, Idaho on 07/03/23..."
+            await chain.arun(question=question, context=context)
+            # -> "The temperature in Boise is..."
+            ```
+        """
+        if len(self.output_keys) != 1:
+            msg = (
+                f"`run` not supported when there is not exactly "
+                f"one output key. Got {self.output_keys}."
+            )
+            raise ValueError(msg)
+        if args and not kwargs:
+            if len(args) != 1:
+                msg = "`run` supports only one positional argument."
+                raise ValueError(msg)
+            return (
+                await self.acall(
+                    args[0],
+                    callbacks=callbacks,
+                    tags=tags,
+                    metadata=metadata,
+                )
+            )[self.output_keys[0]]
+
+        if kwargs and not args:
+            return (
+                await self.acall(
+                    kwargs,
+                    callbacks=callbacks,
+                    tags=tags,
+                    metadata=metadata,
+                )
+            )[self.output_keys[0]]
+
+        msg = (
+            f"`run` supported with either positional arguments or keyword arguments"
+            f" but not both. Got args: {args} and kwargs: {kwargs}."
+        )
+        raise ValueError(msg)
+
+    def dict(self, **kwargs: Any) -> dict:
+        """Dictionary representation of chain.
+
+        Expects `Chain._chain_type` property to be implemented and for memory to be
+            null.
+
+        Args:
+            **kwargs: Keyword arguments passed to default `pydantic.BaseModel.dict`
+                method.
+
+        Returns:
+            A dictionary representation of the chain.
+
+        Example:
+            ```python
+            chain.model_dump(exclude_unset=True)
+            # -> {"_type": "foo", "verbose": False, ...}
+            ```
+        """
+        _dict = super().model_dump(**kwargs)
+        with contextlib.suppress(NotImplementedError):
+            _dict["_type"] = self._chain_type
+        return _dict
+
+    def save(self, file_path: Path | str) -> None:
+        """Save the chain.
+
+        Expects `Chain._chain_type` property to be implemented and for memory to be
+            null.
+
+        Args:
+            file_path: Path to file to save the chain to.
+
+        Example:
+            ```python
+            chain.save(file_path="path/chain.yaml")
+            ```
+        """
+        if self.memory is not None:
+            msg = "Saving of memory is not yet supported."
+            raise ValueError(msg)
+
+        # Fetch dictionary to save
+        chain_dict = self.model_dump()
+        if "_type" not in chain_dict:
+            msg = f"Chain {self} does not support saving."
+            raise NotImplementedError(msg)
+
+        # Convert file to Path object.
+        save_path = Path(file_path) if isinstance(file_path, str) else file_path
+
+        directory_path = save_path.parent
+        directory_path.mkdir(parents=True, exist_ok=True)
+
+        if save_path.suffix == ".json":
+            with save_path.open("w") as f:
+                json.dump(chain_dict, f, indent=4)
+        elif save_path.suffix.endswith((".yaml", ".yml")):
+            with save_path.open("w") as f:
+                yaml.dump(chain_dict, f, default_flow_style=False)
+        else:
+            msg = f"{save_path} must be json or yaml"
+            raise ValueError(msg)
+
+    @deprecated("0.1.0", alternative="batch", removal="1.0")
+    def apply(
+        self,
+        input_list: list[builtins.dict[str, Any]],
+        callbacks: Callbacks = None,
+    ) -> list[builtins.dict[str, str]]:
+        """Call the chain on all inputs in the list."""
+        return [self(inputs, callbacks=callbacks) for inputs in input_list]

venv/Lib/site-packages/langchain_classic/chains/chat_vector_db/prompts.py

@@ -0,0 +1,19 @@
+from langchain_core.prompts.prompt import PromptTemplate
+
+_template = """Given the following conversation and a follow up question, rephrase the follow up question to be a standalone question.
+
+Chat History:
+{chat_history}
+Follow Up Input: {question}
+Standalone question:"""  # noqa: E501
+CONDENSE_QUESTION_PROMPT = PromptTemplate.from_template(_template)
+
+prompt_template = """Use the following pieces of context to answer the question at the end. If you don't know the answer, just say that you don't know, don't try to make up an answer.
+
+{context}
+
+Question: {question}
+Helpful Answer:"""  # noqa: E501
+QA_PROMPT = PromptTemplate(
+    template=prompt_template, input_variables=["context", "question"]
+)

venv/Lib/site-packages/langchain_classic/chains/combine_documents/__init__.py

@@ -0,0 +1,17 @@
+"""Different ways to combine documents."""
+
+from langchain_classic.chains.combine_documents.reduce import (
+    acollapse_docs,
+    collapse_docs,
+    split_list_of_docs,
+)
+from langchain_classic.chains.combine_documents.stuff import (
+    create_stuff_documents_chain,
+)
+
+__all__ = [
+    "acollapse_docs",
+    "collapse_docs",
+    "create_stuff_documents_chain",
+    "split_list_of_docs",
+]

venv/Lib/site-packages/langchain_classic/chains/combine_documents/base.py

@@ -0,0 +1,278 @@
+"""Base interface for chains combining documents."""
+
+from abc import ABC, abstractmethod
+from typing import Any
+
+from langchain_core._api import deprecated
+from langchain_core.callbacks import (
+    AsyncCallbackManagerForChainRun,
+    CallbackManagerForChainRun,
+)
+from langchain_core.documents import Document
+from langchain_core.prompts import BasePromptTemplate, PromptTemplate
+from langchain_core.runnables.config import RunnableConfig
+from langchain_core.utils.pydantic import create_model
+from langchain_text_splitters import RecursiveCharacterTextSplitter, TextSplitter
+from pydantic import BaseModel, Field
+from typing_extensions import override
+
+from langchain_classic.chains.base import Chain
+
+DEFAULT_DOCUMENT_SEPARATOR = "\n\n"
+DOCUMENTS_KEY = "context"
+DEFAULT_DOCUMENT_PROMPT = PromptTemplate.from_template("{page_content}")
+
+
+def _validate_prompt(prompt: BasePromptTemplate, document_variable_name: str) -> None:
+    if document_variable_name not in prompt.input_variables:
+        msg = (
+            f"Prompt must accept {document_variable_name} as an input variable. "
+            f"Received prompt with input variables: {prompt.input_variables}"
+        )
+        raise ValueError(msg)
+
+
+class BaseCombineDocumentsChain(Chain, ABC):
+    """Base interface for chains combining documents.
+
+    Subclasses of this chain deal with combining documents in a variety of
+    ways. This base class exists to add some uniformity in the interface these types
+    of chains should expose. Namely, they expect an input key related to the documents
+    to use (default `input_documents`), and then also expose a method to calculate
+    the length of a prompt from documents (useful for outside callers to use to
+    determine whether it's safe to pass a list of documents into this chain or whether
+    that will be longer than the context length).
+    """
+
+    input_key: str = "input_documents"
+    output_key: str = "output_text"
+
+    @override
+    def get_input_schema(
+        self,
+        config: RunnableConfig | None = None,
+    ) -> type[BaseModel]:
+        return create_model(
+            "CombineDocumentsInput",
+            **{self.input_key: (list[Document], None)},
+        )
+
+    @override
+    def get_output_schema(
+        self,
+        config: RunnableConfig | None = None,
+    ) -> type[BaseModel]:
+        return create_model(
+            "CombineDocumentsOutput",
+            **{self.output_key: (str, None)},
+        )
+
+    @property
+    def input_keys(self) -> list[str]:
+        """Expect input key."""
+        return [self.input_key]
+
+    @property
+    def output_keys(self) -> list[str]:
+        """Return output key."""
+        return [self.output_key]
+
+    def prompt_length(self, docs: list[Document], **kwargs: Any) -> int | None:  # noqa: ARG002
+        """Return the prompt length given the documents passed in.
+
+        This can be used by a caller to determine whether passing in a list
+        of documents would exceed a certain prompt length. This useful when
+        trying to ensure that the size of a prompt remains below a certain
+        context limit.
+
+        Args:
+            docs: a list of documents to use to calculate the total prompt length.
+            **kwargs: additional parameters that may be needed to calculate the
+                prompt length.
+
+        Returns:
+            Returns None if the method does not depend on the prompt length,
+            otherwise the length of the prompt in tokens.
+        """
+        return None
+
+    @abstractmethod
+    def combine_docs(self, docs: list[Document], **kwargs: Any) -> tuple[str, dict]:
+        """Combine documents into a single string.
+
+        Args:
+            docs: List[Document], the documents to combine
+            **kwargs: Other parameters to use in combining documents, often
+                other inputs to the prompt.
+
+        Returns:
+            The first element returned is the single string output. The second
+            element returned is a dictionary of other keys to return.
+        """
+
+    @abstractmethod
+    async def acombine_docs(
+        self,
+        docs: list[Document],
+        **kwargs: Any,
+    ) -> tuple[str, dict]:
+        """Combine documents into a single string.
+
+        Args:
+            docs: List[Document], the documents to combine
+            **kwargs: Other parameters to use in combining documents, often
+                other inputs to the prompt.
+
+        Returns:
+            The first element returned is the single string output. The second
+            element returned is a dictionary of other keys to return.
+        """
+
+    def _call(
+        self,
+        inputs: dict[str, list[Document]],
+        run_manager: CallbackManagerForChainRun | None = None,
+    ) -> dict[str, str]:
+        """Prepare inputs, call combine docs, prepare outputs."""
+        _run_manager = run_manager or CallbackManagerForChainRun.get_noop_manager()
+        docs = inputs[self.input_key]
+        # Other keys are assumed to be needed for LLM prediction
+        other_keys = {k: v for k, v in inputs.items() if k != self.input_key}
+        output, extra_return_dict = self.combine_docs(
+            docs,
+            callbacks=_run_manager.get_child(),
+            **other_keys,
+        )
+        extra_return_dict[self.output_key] = output
+        return extra_return_dict
+
+    async def _acall(
+        self,
+        inputs: dict[str, list[Document]],
+        run_manager: AsyncCallbackManagerForChainRun | None = None,
+    ) -> dict[str, str]:
+        """Prepare inputs, call combine docs, prepare outputs."""
+        _run_manager = run_manager or AsyncCallbackManagerForChainRun.get_noop_manager()
+        docs = inputs[self.input_key]
+        # Other keys are assumed to be needed for LLM prediction
+        other_keys = {k: v for k, v in inputs.items() if k != self.input_key}
+        output, extra_return_dict = await self.acombine_docs(
+            docs,
+            callbacks=_run_manager.get_child(),
+            **other_keys,
+        )
+        extra_return_dict[self.output_key] = output
+        return extra_return_dict
+
+
+@deprecated(
+    since="0.2.7",
+    alternative=(
+        "example in API reference with more detail: "
+        "https://api.python.langchain.com/en/latest/chains/langchain.chains.combine_documents.base.AnalyzeDocumentChain.html"
+    ),
+    removal="1.0",
+)
+class AnalyzeDocumentChain(Chain):
+    """Chain that splits documents, then analyzes it in pieces.
+
+    This chain is parameterized by a TextSplitter and a CombineDocumentsChain.
+    This chain takes a single document as input, and then splits it up into chunks
+    and then passes those chucks to the CombineDocumentsChain.
+
+    This class is deprecated. See below for alternative implementations which
+    supports async and streaming modes of operation.
+
+    If the underlying combine documents chain takes one `input_documents` argument
+    (e.g., chains generated by `load_summarize_chain`):
+
+        ```python
+        split_text = lambda x: text_splitter.create_documents([x])
+
+        summarize_document_chain = split_text | chain
+        ```
+
+    If the underlying chain takes additional arguments (e.g., `load_qa_chain`, which
+    takes an additional `question` argument), we can use the following:
+
+        ```python
+        from operator import itemgetter
+        from langchain_core.runnables import RunnableLambda, RunnableParallel
+
+        split_text = RunnableLambda(lambda x: text_splitter.create_documents([x]))
+        summarize_document_chain = RunnableParallel(
+            question=itemgetter("question"),
+            input_documents=itemgetter("input_document") | split_text,
+        ) | chain.pick("output_text")
+        ```
+
+    To additionally return the input parameters, as `AnalyzeDocumentChain` does,
+    we can wrap this construction with `RunnablePassthrough`:
+
+        ```python
+        from operator import itemgetter
+        from langchain_core.runnables import (
+            RunnableLambda,
+            RunnableParallel,
+            RunnablePassthrough,
+        )
+
+        split_text = RunnableLambda(lambda x: text_splitter.create_documents([x]))
+        summarize_document_chain = RunnablePassthrough.assign(
+            output_text=RunnableParallel(
+                question=itemgetter("question"),
+                input_documents=itemgetter("input_document") | split_text,
+            )
+            | chain.pick("output_text")
+        )
+        ```
+    """
+
+    input_key: str = "input_document"
+    text_splitter: TextSplitter = Field(default_factory=RecursiveCharacterTextSplitter)
+    combine_docs_chain: BaseCombineDocumentsChain
+
+    @property
+    def input_keys(self) -> list[str]:
+        """Expect input key."""
+        return [self.input_key]
+
+    @property
+    def output_keys(self) -> list[str]:
+        """Return output key."""
+        return self.combine_docs_chain.output_keys
+
+    @override
+    def get_input_schema(
+        self,
+        config: RunnableConfig | None = None,
+    ) -> type[BaseModel]:
+        return create_model(
+            "AnalyzeDocumentChain",
+            **{self.input_key: (str, None)},
+        )
+
+    @override
+    def get_output_schema(
+        self,
+        config: RunnableConfig | None = None,
+    ) -> type[BaseModel]:
+        return self.combine_docs_chain.get_output_schema(config)
+
+    def _call(
+        self,
+        inputs: dict[str, str],
+        run_manager: CallbackManagerForChainRun | None = None,
+    ) -> dict[str, str]:
+        """Split document into chunks and pass to CombineDocumentsChain."""
+        _run_manager = run_manager or CallbackManagerForChainRun.get_noop_manager()
+        document = inputs[self.input_key]
+        docs = self.text_splitter.create_documents([document])
+        # Other keys are assumed to be needed for LLM prediction
+        other_keys: dict = {k: v for k, v in inputs.items() if k != self.input_key}
+        other_keys[self.combine_docs_chain.input_key] = docs
+        return self.combine_docs_chain(
+            other_keys,
+            return_only_outputs=True,
+            callbacks=_run_manager.get_child(),
+        )

venv/Lib/site-packages/langchain_classic/chains/combine_documents/map_reduce.py

@@ -0,0 +1,294 @@
+"""Combining documents by mapping a chain over them first, then combining results."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from langchain_core._api import deprecated
+from langchain_core.callbacks import Callbacks
+from langchain_core.documents import Document
+from langchain_core.runnables.config import RunnableConfig
+from langchain_core.utils.pydantic import create_model
+from pydantic import BaseModel, ConfigDict, model_validator
+from typing_extensions import override
+
+from langchain_classic.chains.combine_documents.base import BaseCombineDocumentsChain
+from langchain_classic.chains.combine_documents.reduce import ReduceDocumentsChain
+from langchain_classic.chains.llm import LLMChain
+
+
+@deprecated(
+    since="0.3.1",
+    removal="1.0",
+    message=(
+        "This class is deprecated. Please see the migration guide here for "
+        "a recommended replacement: "
+        "https://python.langchain.com/docs/versions/migrating_chains/map_reduce_chain/"
+    ),
+)
+class MapReduceDocumentsChain(BaseCombineDocumentsChain):
+    """Combining documents by mapping a chain over them, then combining results.
+
+    We first call `llm_chain` on each document individually, passing in the
+    `page_content` and any other kwargs. This is the `map` step.
+
+    We then process the results of that `map` step in a `reduce` step. This should
+    likely be a ReduceDocumentsChain.
+
+    Example:
+        ```python
+        from langchain_classic.chains import (
+            StuffDocumentsChain,
+            LLMChain,
+            ReduceDocumentsChain,
+            MapReduceDocumentsChain,
+        )
+        from langchain_core.prompts import PromptTemplate
+        from langchain_openai import OpenAI
+
+        # This controls how each document will be formatted. Specifically,
+        # it will be passed to `format_document` - see that function for more
+        # details.
+        document_prompt = PromptTemplate(
+            input_variables=["page_content"], template="{page_content}"
+        )
+        document_variable_name = "context"
+        model = OpenAI()
+        # The prompt here should take as an input variable the
+        # `document_variable_name`
+        prompt = PromptTemplate.from_template("Summarize this content: {context}")
+        llm_chain = LLMChain(llm=model, prompt=prompt)
+        # We now define how to combine these summaries
+        reduce_prompt = PromptTemplate.from_template(
+            "Combine these summaries: {context}"
+        )
+        reduce_llm_chain = LLMChain(llm=model, prompt=reduce_prompt)
+        combine_documents_chain = StuffDocumentsChain(
+            llm_chain=reduce_llm_chain,
+            document_prompt=document_prompt,
+            document_variable_name=document_variable_name,
+        )
+        reduce_documents_chain = ReduceDocumentsChain(
+            combine_documents_chain=combine_documents_chain,
+        )
+        chain = MapReduceDocumentsChain(
+            llm_chain=llm_chain,
+            reduce_documents_chain=reduce_documents_chain,
+        )
+        # If we wanted to, we could also pass in collapse_documents_chain
+        # which is specifically aimed at collapsing documents BEFORE
+        # the final call.
+        prompt = PromptTemplate.from_template("Collapse this content: {context}")
+        llm_chain = LLMChain(llm=model, prompt=prompt)
+        collapse_documents_chain = StuffDocumentsChain(
+            llm_chain=llm_chain,
+            document_prompt=document_prompt,
+            document_variable_name=document_variable_name,
+        )
+        reduce_documents_chain = ReduceDocumentsChain(
+            combine_documents_chain=combine_documents_chain,
+            collapse_documents_chain=collapse_documents_chain,
+        )
+        chain = MapReduceDocumentsChain(
+            llm_chain=llm_chain,
+            reduce_documents_chain=reduce_documents_chain,
+        )
+        ```
+    """
+
+    llm_chain: LLMChain
+    """Chain to apply to each document individually."""
+    reduce_documents_chain: BaseCombineDocumentsChain
+    """Chain to use to reduce the results of applying `llm_chain` to each doc.
+    This typically either a ReduceDocumentChain or StuffDocumentChain."""
+    document_variable_name: str
+    """The variable name in the llm_chain to put the documents in.
+    If only one variable in the llm_chain, this need not be provided."""
+    return_intermediate_steps: bool = False
+    """Return the results of the map steps in the output."""
+
+    @override
+    def get_output_schema(
+        self,
+        config: RunnableConfig | None = None,
+    ) -> type[BaseModel]:
+        if self.return_intermediate_steps:
+            return create_model(
+                "MapReduceDocumentsOutput",
+                **{
+                    self.output_key: (str, None),
+                    "intermediate_steps": (list[str], None),
+                },
+            )
+
+        return super().get_output_schema(config)
+
+    @property
+    def output_keys(self) -> list[str]:
+        """Expect input key."""
+        _output_keys = super().output_keys
+        if self.return_intermediate_steps:
+            _output_keys = [*_output_keys, "intermediate_steps"]
+        return _output_keys
+
+    model_config = ConfigDict(
+        arbitrary_types_allowed=True,
+        extra="forbid",
+    )
+
+    @model_validator(mode="before")
+    @classmethod
+    def get_reduce_chain(cls, values: dict) -> Any:
+        """For backwards compatibility."""
+        if "combine_document_chain" in values:
+            if "reduce_documents_chain" in values:
+                msg = (
+                    "Both `reduce_documents_chain` and `combine_document_chain` "
+                    "cannot be provided at the same time. `combine_document_chain` "
+                    "is deprecated, please only provide `reduce_documents_chain`"
+                )
+                raise ValueError(msg)
+            combine_chain = values["combine_document_chain"]
+            collapse_chain = values.get("collapse_document_chain")
+            reduce_chain = ReduceDocumentsChain(
+                combine_documents_chain=combine_chain,
+                collapse_documents_chain=collapse_chain,
+            )
+            values["reduce_documents_chain"] = reduce_chain
+            del values["combine_document_chain"]
+            values.pop("collapse_document_chain", None)
+
+        return values
+
+    @model_validator(mode="before")
+    @classmethod
+    def get_return_intermediate_steps(cls, values: dict) -> Any:
+        """For backwards compatibility."""
+        if "return_map_steps" in values:
+            values["return_intermediate_steps"] = values["return_map_steps"]
+            del values["return_map_steps"]
+        return values
+
+    @model_validator(mode="before")
+    @classmethod
+    def get_default_document_variable_name(cls, values: dict) -> Any:
+        """Get default document variable name, if not provided."""
+        if "llm_chain" not in values:
+            msg = "llm_chain must be provided"
+            raise ValueError(msg)
+
+        llm_chain_variables = values["llm_chain"].prompt.input_variables
+        if "document_variable_name" not in values:
+            if len(llm_chain_variables) == 1:
+                values["document_variable_name"] = llm_chain_variables[0]
+            else:
+                msg = (
+                    "document_variable_name must be provided if there are "
+                    "multiple llm_chain input_variables"
+                )
+                raise ValueError(msg)
+        elif values["document_variable_name"] not in llm_chain_variables:
+            msg = (
+                f"document_variable_name {values['document_variable_name']} was "
+                f"not found in llm_chain input_variables: {llm_chain_variables}"
+            )
+            raise ValueError(msg)
+        return values
+
+    @property
+    def collapse_document_chain(self) -> BaseCombineDocumentsChain:
+        """Kept for backward compatibility."""
+        if isinstance(self.reduce_documents_chain, ReduceDocumentsChain):
+            if self.reduce_documents_chain.collapse_documents_chain:
+                return self.reduce_documents_chain.collapse_documents_chain
+            return self.reduce_documents_chain.combine_documents_chain
+        msg = (
+            f"`reduce_documents_chain` is of type "
+            f"{type(self.reduce_documents_chain)} so it does not have "
+            f"this attribute."
+        )
+        raise ValueError(msg)
+
+    @property
+    def combine_document_chain(self) -> BaseCombineDocumentsChain:
+        """Kept for backward compatibility."""
+        if isinstance(self.reduce_documents_chain, ReduceDocumentsChain):
+            return self.reduce_documents_chain.combine_documents_chain
+        msg = (
+            f"`reduce_documents_chain` is of type "
+            f"{type(self.reduce_documents_chain)} so it does not have "
+            f"this attribute."
+        )
+        raise ValueError(msg)
+
+    def combine_docs(
+        self,
+        docs: list[Document],
+        token_max: int | None = None,
+        callbacks: Callbacks = None,
+        **kwargs: Any,
+    ) -> tuple[str, dict]:
+        """Combine documents in a map reduce manner.
+
+        Combine by mapping first chain over all documents, then reducing the results.
+        This reducing can be done recursively if needed (if there are many documents).
+        """
+        map_results = self.llm_chain.apply(
+            # FYI - this is parallelized and so it is fast.
+            [{self.document_variable_name: d.page_content, **kwargs} for d in docs],
+            callbacks=callbacks,
+        )
+        question_result_key = self.llm_chain.output_key
+        result_docs = [
+            Document(page_content=r[question_result_key], metadata=docs[i].metadata)
+            # This uses metadata from the docs, and the textual results from `results`
+            for i, r in enumerate(map_results)
+        ]
+        result, extra_return_dict = self.reduce_documents_chain.combine_docs(
+            result_docs,
+            token_max=token_max,
+            callbacks=callbacks,
+            **kwargs,
+        )
+        if self.return_intermediate_steps:
+            intermediate_steps = [r[question_result_key] for r in map_results]
+            extra_return_dict["intermediate_steps"] = intermediate_steps
+        return result, extra_return_dict
+
+    async def acombine_docs(
+        self,
+        docs: list[Document],
+        token_max: int | None = None,
+        callbacks: Callbacks = None,
+        **kwargs: Any,
+    ) -> tuple[str, dict]:
+        """Combine documents in a map reduce manner.
+
+        Combine by mapping first chain over all documents, then reducing the results.
+        This reducing can be done recursively if needed (if there are many documents).
+        """
+        map_results = await self.llm_chain.aapply(
+            # FYI - this is parallelized and so it is fast.
+            [{self.document_variable_name: d.page_content, **kwargs} for d in docs],
+            callbacks=callbacks,
+        )
+        question_result_key = self.llm_chain.output_key
+        result_docs = [
+            Document(page_content=r[question_result_key], metadata=docs[i].metadata)
+            # This uses metadata from the docs, and the textual results from `results`
+            for i, r in enumerate(map_results)
+        ]
+        result, extra_return_dict = await self.reduce_documents_chain.acombine_docs(
+            result_docs,
+            token_max=token_max,
+            callbacks=callbacks,
+            **kwargs,
+        )
+        if self.return_intermediate_steps:
+            intermediate_steps = [r[question_result_key] for r in map_results]
+            extra_return_dict["intermediate_steps"] = intermediate_steps
+        return result, extra_return_dict
+
+    @property
+    def _chain_type(self) -> str:
+        return "map_reduce_documents_chain"

venv/Lib/site-packages/langchain_classic/chains/combine_documents/map_rerank.py

@@ -0,0 +1,245 @@
+"""Combining documents by mapping a chain over them first, then reranking results."""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from typing import Any, cast
+
+from langchain_core._api import deprecated
+from langchain_core.callbacks import Callbacks
+from langchain_core.documents import Document
+from langchain_core.runnables.config import RunnableConfig
+from langchain_core.utils.pydantic import create_model
+from pydantic import BaseModel, ConfigDict, model_validator
+from typing_extensions import Self, override
+
+from langchain_classic.chains.combine_documents.base import BaseCombineDocumentsChain
+from langchain_classic.chains.llm import LLMChain
+from langchain_classic.output_parsers.regex import RegexParser
+
+
+@deprecated(
+    since="0.3.1",
+    removal="1.0",
+    message=(
+        "This class is deprecated. Please see the migration guide here for "
+        "a recommended replacement: "
+        "https://python.langchain.com/docs/versions/migrating_chains/map_rerank_docs_chain/"
+    ),
+)
+class MapRerankDocumentsChain(BaseCombineDocumentsChain):
+    r"""Combining documents by mapping a chain over them, then reranking results.
+
+    This algorithm calls an LLMChain on each input document. The LLMChain is expected
+    to have an OutputParser that parses the result into both an answer (`answer_key`)
+    and a score (`rank_key`). The answer with the highest score is then returned.
+
+    Example:
+        ```python
+        from langchain_classic.chains import MapRerankDocumentsChain, LLMChain
+        from langchain_core.prompts import PromptTemplate
+        from langchain_openai import OpenAI
+        from langchain_classic.output_parsers.regex import RegexParser
+
+        document_variable_name = "context"
+        model = OpenAI()
+        # The prompt here should take as an input variable the
+        # `document_variable_name`
+        # The actual prompt will need to be a lot more complex, this is just
+        # an example.
+        prompt_template = (
+            "Use the following context to tell me the chemical formula "
+            "for water. Output both your answer and a score of how confident "
+            "you are. Context: {context}"
+        )
+        output_parser = RegexParser(
+            regex=r"(.*?)\nScore: (.*)",
+            output_keys=["answer", "score"],
+        )
+        prompt = PromptTemplate(
+            template=prompt_template,
+            input_variables=["context"],
+            output_parser=output_parser,
+        )
+        llm_chain = LLMChain(llm=model, prompt=prompt)
+        chain = MapRerankDocumentsChain(
+            llm_chain=llm_chain,
+            document_variable_name=document_variable_name,
+            rank_key="score",
+            answer_key="answer",
+        )
+        ```
+    """
+
+    llm_chain: LLMChain
+    """Chain to apply to each document individually."""
+    document_variable_name: str
+    """The variable name in the llm_chain to put the documents in.
+    If only one variable in the llm_chain, this need not be provided."""
+    rank_key: str
+    """Key in output of llm_chain to rank on."""
+    answer_key: str
+    """Key in output of llm_chain to return as answer."""
+    metadata_keys: list[str] | None = None
+    """Additional metadata from the chosen document to return."""
+    return_intermediate_steps: bool = False
+    """Return intermediate steps.
+    Intermediate steps include the results of calling llm_chain on each document."""
+
+    model_config = ConfigDict(
+        arbitrary_types_allowed=True,
+        extra="forbid",
+    )
+
+    @override
+    def get_output_schema(
+        self,
+        config: RunnableConfig | None = None,
+    ) -> type[BaseModel]:
+        schema: dict[str, Any] = {
+            self.output_key: (str, None),
+        }
+        if self.return_intermediate_steps:
+            schema["intermediate_steps"] = (list[str], None)
+        if self.metadata_keys:
+            schema.update(dict.fromkeys(self.metadata_keys, (Any, None)))
+
+        return create_model("MapRerankOutput", **schema)
+
+    @property
+    def output_keys(self) -> list[str]:
+        """Expect input key."""
+        _output_keys = super().output_keys
+        if self.return_intermediate_steps:
+            _output_keys = [*_output_keys, "intermediate_steps"]
+        if self.metadata_keys is not None:
+            _output_keys += self.metadata_keys
+        return _output_keys
+
+    @model_validator(mode="after")
+    def validate_llm_output(self) -> Self:
+        """Validate that the combine chain outputs a dictionary."""
+        output_parser = self.llm_chain.prompt.output_parser
+        if not isinstance(output_parser, RegexParser):
+            msg = (
+                "Output parser of llm_chain should be a RegexParser,"
+                f" got {output_parser}"
+            )
+            raise ValueError(msg)  # noqa: TRY004
+        output_keys = output_parser.output_keys
+        if self.rank_key not in output_keys:
+            msg = (
+                f"Got {self.rank_key} as key to rank on, but did not find "
+                f"it in the llm_chain output keys ({output_keys})"
+            )
+            raise ValueError(msg)
+        if self.answer_key not in output_keys:
+            msg = (
+                f"Got {self.answer_key} as key to return, but did not find "
+                f"it in the llm_chain output keys ({output_keys})"
+            )
+            raise ValueError(msg)
+        return self
+
+    @model_validator(mode="before")
+    @classmethod
+    def get_default_document_variable_name(cls, values: dict) -> Any:
+        """Get default document variable name, if not provided."""
+        if "llm_chain" not in values:
+            msg = "llm_chain must be provided"
+            raise ValueError(msg)
+
+        llm_chain_variables = values["llm_chain"].prompt.input_variables
+        if "document_variable_name" not in values:
+            if len(llm_chain_variables) == 1:
+                values["document_variable_name"] = llm_chain_variables[0]
+            else:
+                msg = (
+                    "document_variable_name must be provided if there are "
+                    "multiple llm_chain input_variables"
+                )
+                raise ValueError(msg)
+        elif values["document_variable_name"] not in llm_chain_variables:
+            msg = (
+                f"document_variable_name {values['document_variable_name']} was "
+                f"not found in llm_chain input_variables: {llm_chain_variables}"
+            )
+            raise ValueError(msg)
+        return values
+
+    def combine_docs(
+        self,
+        docs: list[Document],
+        callbacks: Callbacks = None,
+        **kwargs: Any,
+    ) -> tuple[str, dict]:
+        """Combine documents in a map rerank manner.
+
+        Combine by mapping first chain over all documents, then reranking the results.
+
+        Args:
+            docs: List of documents to combine
+            callbacks: Callbacks to be passed through
+            **kwargs: additional parameters to be passed to LLM calls (like other
+                input variables besides the documents)
+
+        Returns:
+            The first element returned is the single string output. The second
+            element returned is a dictionary of other keys to return.
+        """
+        results = self.llm_chain.apply_and_parse(
+            # FYI - this is parallelized and so it is fast.
+            [{self.document_variable_name: d.page_content, **kwargs} for d in docs],
+            callbacks=callbacks,
+        )
+        return self._process_results(docs, results)
+
+    async def acombine_docs(
+        self,
+        docs: list[Document],
+        callbacks: Callbacks = None,
+        **kwargs: Any,
+    ) -> tuple[str, dict]:
+        """Combine documents in a map rerank manner.
+
+        Combine by mapping first chain over all documents, then reranking the results.
+
+        Args:
+            docs: List of documents to combine
+            callbacks: Callbacks to be passed through
+            **kwargs: additional parameters to be passed to LLM calls (like other
+                input variables besides the documents)
+
+        Returns:
+            The first element returned is the single string output. The second
+            element returned is a dictionary of other keys to return.
+        """
+        results = await self.llm_chain.aapply_and_parse(
+            # FYI - this is parallelized and so it is fast.
+            [{self.document_variable_name: d.page_content, **kwargs} for d in docs],
+            callbacks=callbacks,
+        )
+        return self._process_results(docs, results)
+
+    def _process_results(
+        self,
+        docs: list[Document],
+        results: Sequence[str | list[str] | dict[str, str]],
+    ) -> tuple[str, dict]:
+        typed_results = cast("list[dict]", results)
+        sorted_res = sorted(
+            zip(typed_results, docs, strict=False),
+            key=lambda x: -int(x[0][self.rank_key]),
+        )
+        output, document = sorted_res[0]
+        extra_info = {}
+        if self.metadata_keys is not None:
+            for key in self.metadata_keys:
+                extra_info[key] = document.metadata[key]
+        if self.return_intermediate_steps:
+            extra_info["intermediate_steps"] = results
+        return output[self.answer_key], extra_info
+
+    @property
+    def _chain_type(self) -> str:
+        return "map_rerank_documents_chain"

venv/Lib/site-packages/langchain_classic/chains/combine_documents/reduce.py

@@ -0,0 +1,389 @@
+"""Combine many documents together by recursively reducing them."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import Any, Protocol
+
+from langchain_core._api import deprecated
+from langchain_core.callbacks import Callbacks
+from langchain_core.documents import Document
+from pydantic import ConfigDict
+
+from langchain_classic.chains.combine_documents.base import BaseCombineDocumentsChain
+
+
+class CombineDocsProtocol(Protocol):
+    """Interface for the combine_docs method."""
+
+    def __call__(self, docs: list[Document], **kwargs: Any) -> str:
+        """Interface for the combine_docs method."""
+
+
+class AsyncCombineDocsProtocol(Protocol):
+    """Interface for the combine_docs method."""
+
+    async def __call__(self, docs: list[Document], **kwargs: Any) -> str:
+        """Async interface for the combine_docs method."""
+
+
+def split_list_of_docs(
+    docs: list[Document],
+    length_func: Callable,
+    token_max: int,
+    **kwargs: Any,
+) -> list[list[Document]]:
+    """Split `Document` objects to subsets that each meet a cumulative len. constraint.
+
+    Args:
+        docs: The full list of `Document` objects.
+        length_func: Function for computing the cumulative length of a set of `Document`
+            objects.
+        token_max: The maximum cumulative length of any subset of `Document` objects.
+        **kwargs: Arbitrary additional keyword params to pass to each call of the
+            `length_func`.
+
+    Returns:
+        A `list[list[Document]]`.
+    """
+    new_result_doc_list = []
+    _sub_result_docs = []
+    for doc in docs:
+        _sub_result_docs.append(doc)
+        _num_tokens = length_func(_sub_result_docs, **kwargs)
+        if _num_tokens > token_max:
+            if len(_sub_result_docs) == 1:
+                msg = (
+                    "A single document was longer than the context length,"
+                    " we cannot handle this."
+                )
+                raise ValueError(msg)
+            new_result_doc_list.append(_sub_result_docs[:-1])
+            _sub_result_docs = _sub_result_docs[-1:]
+    new_result_doc_list.append(_sub_result_docs)
+    return new_result_doc_list
+
+
+def collapse_docs(
+    docs: list[Document],
+    combine_document_func: CombineDocsProtocol,
+    **kwargs: Any,
+) -> Document:
+    """Execute a collapse function on a set of documents and merge their metadatas.
+
+    Args:
+        docs: A list of `Document` objects to combine.
+        combine_document_func: A function that takes in a list of `Document` objects and
+            optionally addition keyword parameters and combines them into a single
+            string.
+        **kwargs: Arbitrary additional keyword params to pass to the
+            `combine_document_func`.
+
+    Returns:
+        A single `Document` with the output of `combine_document_func` for the page
+            content and the combined metadata's of all the input documents. All metadata
+            values are strings, and where there are overlapping keys across documents
+            the values are joined by `', '`.
+    """
+    result = combine_document_func(docs, **kwargs)
+    combined_metadata = {k: str(v) for k, v in docs[0].metadata.items()}
+    for doc in docs[1:]:
+        for k, v in doc.metadata.items():
+            if k in combined_metadata:
+                combined_metadata[k] += f", {v}"
+            else:
+                combined_metadata[k] = str(v)
+    return Document(page_content=result, metadata=combined_metadata)
+
+
+async def acollapse_docs(
+    docs: list[Document],
+    combine_document_func: AsyncCombineDocsProtocol,
+    **kwargs: Any,
+) -> Document:
+    """Execute a collapse function on a set of documents and merge their metadatas.
+
+    Args:
+        docs: A list of `Document` objects to combine.
+        combine_document_func: A function that takes in a list of `Document` objects and
+            optionally addition keyword parameters and combines them into a single
+            string.
+        **kwargs: Arbitrary additional keyword params to pass to the
+            `combine_document_func`.
+
+    Returns:
+        A single `Document` with the output of `combine_document_func` for the page
+            content and the combined metadata's of all the input documents. All metadata
+            values are strings, and where there are overlapping keys across documents
+            the values are joined by `', '`.
+    """
+    result = await combine_document_func(docs, **kwargs)
+    combined_metadata = {k: str(v) for k, v in docs[0].metadata.items()}
+    for doc in docs[1:]:
+        for k, v in doc.metadata.items():
+            if k in combined_metadata:
+                combined_metadata[k] += f", {v}"
+            else:
+                combined_metadata[k] = str(v)
+    return Document(page_content=result, metadata=combined_metadata)
+
+
+@deprecated(
+    since="0.3.1",
+    removal="1.0",
+    message=(
+        "This class is deprecated. Please see the migration guide here for "
+        "a recommended replacement: "
+        "https://python.langchain.com/docs/versions/migrating_chains/map_reduce_chain/"
+    ),
+)
+class ReduceDocumentsChain(BaseCombineDocumentsChain):
+    """Combine documents by recursively reducing them.
+
+    This involves
+
+    - `combine_documents_chain`
+    - `collapse_documents_chain`
+
+    `combine_documents_chain` is ALWAYS provided. This is final chain that is called.
+
+    We pass all previous results to this chain, and the output of this chain is
+    returned as a final result.
+
+    `collapse_documents_chain` is used if the documents passed in are too many to all
+    be passed to `combine_documents_chain` in one go. In this case,
+    `collapse_documents_chain` is called recursively on as big of groups of documents
+    as are allowed.
+
+    Example:
+        ```python
+        from langchain_classic.chains import (
+            StuffDocumentsChain,
+            LLMChain,
+            ReduceDocumentsChain,
+        )
+        from langchain_core.prompts import PromptTemplate
+        from langchain_openai import OpenAI
+
+        # This controls how each document will be formatted. Specifically,
+        # it will be passed to `format_document` - see that function for more
+        # details.
+        document_prompt = PromptTemplate(
+            input_variables=["page_content"], template="{page_content}"
+        )
+        document_variable_name = "context"
+        model = OpenAI()
+        # The prompt here should take as an input variable the
+        # `document_variable_name`
+        prompt = PromptTemplate.from_template("Summarize this content: {context}")
+        llm_chain = LLMChain(llm=model, prompt=prompt)
+        combine_documents_chain = StuffDocumentsChain(
+            llm_chain=llm_chain,
+            document_prompt=document_prompt,
+            document_variable_name=document_variable_name,
+        )
+        chain = ReduceDocumentsChain(
+            combine_documents_chain=combine_documents_chain,
+        )
+        # If we wanted to, we could also pass in collapse_documents_chain
+        # which is specifically aimed at collapsing documents BEFORE
+        # the final call.
+        prompt = PromptTemplate.from_template("Collapse this content: {context}")
+        llm_chain = LLMChain(llm=model, prompt=prompt)
+        collapse_documents_chain = StuffDocumentsChain(
+            llm_chain=llm_chain,
+            document_prompt=document_prompt,
+            document_variable_name=document_variable_name,
+        )
+        chain = ReduceDocumentsChain(
+            combine_documents_chain=combine_documents_chain,
+            collapse_documents_chain=collapse_documents_chain,
+        )
+        ```
+    """
+
+    combine_documents_chain: BaseCombineDocumentsChain
+    """Final chain to call to combine documents.
+
+    This is typically a `StuffDocumentsChain`.
+    """
+    collapse_documents_chain: BaseCombineDocumentsChain | None = None
+    """Chain to use to collapse documents if needed until they can all fit.
+    If `None`, will use the `combine_documents_chain`.
+
+    This is typically a `StuffDocumentsChain`.
+    """
+    token_max: int = 3000
+    """The maximum number of tokens to group documents into.
+
+    For example, if set to 3000 then documents will be grouped into chunks of no greater
+    than 3000 tokens before trying to combine them into a smaller chunk.
+    """
+    collapse_max_retries: int | None = None
+    """The maximum number of retries to collapse documents to fit `token_max`.
+
+    If `None`, it will keep trying to collapse documents to fit `token_max`.
+
+    Otherwise, after it reaches the max number, it will throw an error.
+    """
+
+    model_config = ConfigDict(
+        arbitrary_types_allowed=True,
+        extra="forbid",
+    )
+
+    @property
+    def _collapse_chain(self) -> BaseCombineDocumentsChain:
+        if self.collapse_documents_chain is not None:
+            return self.collapse_documents_chain
+        return self.combine_documents_chain
+
+    def combine_docs(
+        self,
+        docs: list[Document],
+        token_max: int | None = None,
+        callbacks: Callbacks = None,
+        **kwargs: Any,
+    ) -> tuple[str, dict]:
+        """Combine multiple documents recursively.
+
+        Args:
+            docs: List of documents to combine, assumed that each one is less than
+                `token_max`.
+            token_max: Recursively creates groups of documents less than this number
+                of tokens.
+            callbacks: Callbacks to be passed through
+            **kwargs: additional parameters to be passed to LLM calls (like other
+                input variables besides the documents)
+
+        Returns:
+            The first element returned is the single string output. The second
+                element returned is a dictionary of other keys to return.
+        """
+        result_docs, _ = self._collapse(
+            docs,
+            token_max=token_max,
+            callbacks=callbacks,
+            **kwargs,
+        )
+        return self.combine_documents_chain.combine_docs(
+            docs=result_docs,
+            callbacks=callbacks,
+            **kwargs,
+        )
+
+    async def acombine_docs(
+        self,
+        docs: list[Document],
+        token_max: int | None = None,
+        callbacks: Callbacks = None,
+        **kwargs: Any,
+    ) -> tuple[str, dict]:
+        """Async combine multiple documents recursively.
+
+        Args:
+            docs: List of documents to combine, assumed that each one is less than
+                `token_max`.
+            token_max: Recursively creates groups of documents less than this number
+                of tokens.
+            callbacks: Callbacks to be passed through
+            **kwargs: additional parameters to be passed to LLM calls (like other
+                input variables besides the documents)
+
+        Returns:
+            The first element returned is the single string output. The second
+                element returned is a dictionary of other keys to return.
+        """
+        result_docs, _ = await self._acollapse(
+            docs,
+            token_max=token_max,
+            callbacks=callbacks,
+            **kwargs,
+        )
+        return await self.combine_documents_chain.acombine_docs(
+            docs=result_docs,
+            callbacks=callbacks,
+            **kwargs,
+        )
+
+    def _collapse(
+        self,
+        docs: list[Document],
+        token_max: int | None = None,
+        callbacks: Callbacks = None,
+        **kwargs: Any,
+    ) -> tuple[list[Document], dict]:
+        result_docs = docs
+        length_func = self.combine_documents_chain.prompt_length
+        num_tokens = length_func(result_docs, **kwargs)
+
+        def _collapse_docs_func(docs: list[Document], **kwargs: Any) -> str:
+            return self._collapse_chain.run(
+                input_documents=docs,
+                callbacks=callbacks,
+                **kwargs,
+            )
+
+        _token_max = token_max or self.token_max
+        retries: int = 0
+        while num_tokens is not None and num_tokens > _token_max:
+            new_result_doc_list = split_list_of_docs(
+                result_docs,
+                length_func,
+                _token_max,
+                **kwargs,
+            )
+            result_docs = [
+                collapse_docs(docs_, _collapse_docs_func, **kwargs)
+                for docs_ in new_result_doc_list
+            ]
+            num_tokens = length_func(result_docs, **kwargs)
+            retries += 1
+            if self.collapse_max_retries and retries == self.collapse_max_retries:
+                msg = f"Exceed {self.collapse_max_retries} tries to \
+                        collapse document to {_token_max} tokens."
+                raise ValueError(msg)
+        return result_docs, {}
+
+    async def _acollapse(
+        self,
+        docs: list[Document],
+        token_max: int | None = None,
+        callbacks: Callbacks = None,
+        **kwargs: Any,
+    ) -> tuple[list[Document], dict]:
+        result_docs = docs
+        length_func = self.combine_documents_chain.prompt_length
+        num_tokens = length_func(result_docs, **kwargs)
+
+        async def _collapse_docs_func(docs: list[Document], **kwargs: Any) -> str:
+            return await self._collapse_chain.arun(
+                input_documents=docs,
+                callbacks=callbacks,
+                **kwargs,
+            )
+
+        _token_max = token_max or self.token_max
+        retries: int = 0
+        while num_tokens is not None and num_tokens > _token_max:
+            new_result_doc_list = split_list_of_docs(
+                result_docs,
+                length_func,
+                _token_max,
+                **kwargs,
+            )
+            result_docs = [
+                await acollapse_docs(docs_, _collapse_docs_func, **kwargs)
+                for docs_ in new_result_doc_list
+            ]
+            num_tokens = length_func(result_docs, **kwargs)
+            retries += 1
+            if self.collapse_max_retries and retries == self.collapse_max_retries:
+                msg = f"Exceed {self.collapse_max_retries} tries to \
+                        collapse document to {_token_max} tokens."
+                raise ValueError(msg)
+        return result_docs, {}
+
+    @property
+    def _chain_type(self) -> str:
+        return "reduce_documents_chain"

venv/Lib/site-packages/langchain_classic/chains/combine_documents/refine.py

@@ -0,0 +1,229 @@
+"""Combine documents by doing a first pass and then refining on more documents."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from langchain_core._api import deprecated
+from langchain_core.callbacks import Callbacks
+from langchain_core.documents import Document
+from langchain_core.prompts import BasePromptTemplate, format_document
+from langchain_core.prompts.prompt import PromptTemplate
+from pydantic import ConfigDict, Field, model_validator
+
+from langchain_classic.chains.combine_documents.base import (
+    BaseCombineDocumentsChain,
+)
+from langchain_classic.chains.llm import LLMChain
+
+
+def _get_default_document_prompt() -> PromptTemplate:
+    return PromptTemplate(input_variables=["page_content"], template="{page_content}")
+
+
+@deprecated(
+    since="0.3.1",
+    removal="1.0",
+    message=(
+        "This class is deprecated. Please see the migration guide here for "
+        "a recommended replacement: "
+        "https://python.langchain.com/docs/versions/migrating_chains/refine_docs_chain/"
+    ),
+)
+class RefineDocumentsChain(BaseCombineDocumentsChain):
+    """Combine documents by doing a first pass and then refining on more documents.
+
+    This algorithm first calls `initial_llm_chain` on the first document, passing
+    that first document in with the variable name `document_variable_name`, and
+    produces a new variable with the variable name `initial_response_name`.
+
+    Then, it loops over every remaining document. This is called the "refine" step.
+    It calls `refine_llm_chain`,
+    passing in that document with the variable name `document_variable_name`
+    as well as the previous response with the variable name `initial_response_name`.
+
+    Example:
+        ```python
+        from langchain_classic.chains import RefineDocumentsChain, LLMChain
+        from langchain_core.prompts import PromptTemplate
+        from langchain_openai import OpenAI
+
+        # This controls how each document will be formatted. Specifically,
+        # it will be passed to `format_document` - see that function for more
+        # details.
+        document_prompt = PromptTemplate(
+            input_variables=["page_content"], template="{page_content}"
+        )
+        document_variable_name = "context"
+        model = OpenAI()
+        # The prompt here should take as an input variable the
+        # `document_variable_name`
+        prompt = PromptTemplate.from_template("Summarize this content: {context}")
+        initial_llm_chain = LLMChain(llm=model, prompt=prompt)
+        initial_response_name = "prev_response"
+        # The prompt here should take as an input variable the
+        # `document_variable_name` as well as `initial_response_name`
+        prompt_refine = PromptTemplate.from_template(
+            "Here's your first summary: {prev_response}. "
+            "Now add to it based on the following context: {context}"
+        )
+        refine_llm_chain = LLMChain(llm=model, prompt=prompt_refine)
+        chain = RefineDocumentsChain(
+            initial_llm_chain=initial_llm_chain,
+            refine_llm_chain=refine_llm_chain,
+            document_prompt=document_prompt,
+            document_variable_name=document_variable_name,
+            initial_response_name=initial_response_name,
+        )
+        ```
+    """
+
+    initial_llm_chain: LLMChain
+    """LLM chain to use on initial document."""
+    refine_llm_chain: LLMChain
+    """LLM chain to use when refining."""
+    document_variable_name: str
+    """The variable name in the initial_llm_chain to put the documents in.
+    If only one variable in the initial_llm_chain, this need not be provided."""
+    initial_response_name: str
+    """The variable name to format the initial response in when refining."""
+    document_prompt: BasePromptTemplate = Field(
+        default_factory=_get_default_document_prompt,
+    )
+    """Prompt to use to format each document, gets passed to `format_document`."""
+    return_intermediate_steps: bool = False
+    """Return the results of the refine steps in the output."""
+
+    @property
+    def output_keys(self) -> list[str]:
+        """Expect input key."""
+        _output_keys = super().output_keys
+        if self.return_intermediate_steps:
+            _output_keys = [*_output_keys, "intermediate_steps"]
+        return _output_keys
+
+    model_config = ConfigDict(
+        arbitrary_types_allowed=True,
+        extra="forbid",
+    )
+
+    @model_validator(mode="before")
+    @classmethod
+    def get_return_intermediate_steps(cls, values: dict) -> Any:
+        """For backwards compatibility."""
+        if "return_refine_steps" in values:
+            values["return_intermediate_steps"] = values["return_refine_steps"]
+            del values["return_refine_steps"]
+        return values
+
+    @model_validator(mode="before")
+    @classmethod
+    def get_default_document_variable_name(cls, values: dict) -> Any:
+        """Get default document variable name, if not provided."""
+        if "initial_llm_chain" not in values:
+            msg = "initial_llm_chain must be provided"
+            raise ValueError(msg)
+
+        llm_chain_variables = values["initial_llm_chain"].prompt.input_variables
+        if "document_variable_name" not in values:
+            if len(llm_chain_variables) == 1:
+                values["document_variable_name"] = llm_chain_variables[0]
+            else:
+                msg = (
+                    "document_variable_name must be provided if there are "
+                    "multiple llm_chain input_variables"
+                )
+                raise ValueError(msg)
+        elif values["document_variable_name"] not in llm_chain_variables:
+            msg = (
+                f"document_variable_name {values['document_variable_name']} was "
+                f"not found in llm_chain input_variables: {llm_chain_variables}"
+            )
+            raise ValueError(msg)
+        return values
+
+    def combine_docs(
+        self,
+        docs: list[Document],
+        callbacks: Callbacks = None,
+        **kwargs: Any,
+    ) -> tuple[str, dict]:
+        """Combine by mapping first chain over all, then stuffing into final chain.
+
+        Args:
+            docs: List of documents to combine
+            callbacks: Callbacks to be passed through
+            **kwargs: additional parameters to be passed to LLM calls (like other
+                input variables besides the documents)
+
+        Returns:
+            The first element returned is the single string output. The second
+            element returned is a dictionary of other keys to return.
+        """
+        inputs = self._construct_initial_inputs(docs, **kwargs)
+        res = self.initial_llm_chain.predict(callbacks=callbacks, **inputs)
+        refine_steps = [res]
+        for doc in docs[1:]:
+            base_inputs = self._construct_refine_inputs(doc, res)
+            inputs = {**base_inputs, **kwargs}
+            res = self.refine_llm_chain.predict(callbacks=callbacks, **inputs)
+            refine_steps.append(res)
+        return self._construct_result(refine_steps, res)
+
+    async def acombine_docs(
+        self,
+        docs: list[Document],
+        callbacks: Callbacks = None,
+        **kwargs: Any,
+    ) -> tuple[str, dict]:
+        """Combine by mapping a first chain over all, then stuffing into a final chain.
+
+        Args:
+            docs: List of documents to combine
+            callbacks: Callbacks to be passed through
+            **kwargs: additional parameters to be passed to LLM calls (like other
+                input variables besides the documents)
+
+        Returns:
+            The first element returned is the single string output. The second
+            element returned is a dictionary of other keys to return.
+        """
+        inputs = self._construct_initial_inputs(docs, **kwargs)
+        res = await self.initial_llm_chain.apredict(callbacks=callbacks, **inputs)
+        refine_steps = [res]
+        for doc in docs[1:]:
+            base_inputs = self._construct_refine_inputs(doc, res)
+            inputs = {**base_inputs, **kwargs}
+            res = await self.refine_llm_chain.apredict(callbacks=callbacks, **inputs)
+            refine_steps.append(res)
+        return self._construct_result(refine_steps, res)
+
+    def _construct_result(self, refine_steps: list[str], res: str) -> tuple[str, dict]:
+        if self.return_intermediate_steps:
+            extra_return_dict = {"intermediate_steps": refine_steps}
+        else:
+            extra_return_dict = {}
+        return res, extra_return_dict
+
+    def _construct_refine_inputs(self, doc: Document, res: str) -> dict[str, Any]:
+        return {
+            self.document_variable_name: format_document(doc, self.document_prompt),
+            self.initial_response_name: res,
+        }
+
+    def _construct_initial_inputs(
+        self,
+        docs: list[Document],
+        **kwargs: Any,
+    ) -> dict[str, Any]:
+        base_info = {"page_content": docs[0].page_content}
+        base_info.update(docs[0].metadata)
+        document_info = {k: base_info[k] for k in self.document_prompt.input_variables}
+        base_inputs: dict = {
+            self.document_variable_name: self.document_prompt.format(**document_info),
+        }
+        return {**base_inputs, **kwargs}
+
+    @property
+    def _chain_type(self) -> str:
+        return "refine_documents_chain"

venv/Lib/site-packages/langchain_classic/chains/combine_documents/stuff.py

@@ -0,0 +1,291 @@
+"""Chain that combines documents by stuffing into context."""
+
+from typing import Any
+
+from langchain_core._api import deprecated
+from langchain_core.callbacks import Callbacks
+from langchain_core.documents import Document
+from langchain_core.language_models import LanguageModelLike
+from langchain_core.output_parsers import BaseOutputParser, StrOutputParser
+from langchain_core.prompts import BasePromptTemplate, format_document
+from langchain_core.runnables import Runnable, RunnablePassthrough
+from pydantic import ConfigDict, Field, model_validator
+from typing_extensions import override
+
+from langchain_classic.chains.combine_documents.base import (
+    DEFAULT_DOCUMENT_PROMPT,
+    DEFAULT_DOCUMENT_SEPARATOR,
+    DOCUMENTS_KEY,
+    BaseCombineDocumentsChain,
+    _validate_prompt,
+)
+from langchain_classic.chains.llm import LLMChain
+
+
+def create_stuff_documents_chain(
+    llm: LanguageModelLike,
+    prompt: BasePromptTemplate,
+    *,
+    output_parser: BaseOutputParser | None = None,
+    document_prompt: BasePromptTemplate | None = None,
+    document_separator: str = DEFAULT_DOCUMENT_SEPARATOR,
+    document_variable_name: str = DOCUMENTS_KEY,
+) -> Runnable[dict[str, Any], Any]:
+    r"""Create a chain for passing a list of Documents to a model.
+
+    Args:
+        llm: Language model.
+        prompt: Prompt template. Must contain input variable `"context"` (override by
+            setting document_variable), which will be used for passing in the formatted
+            documents.
+        output_parser: Output parser. Defaults to `StrOutputParser`.
+        document_prompt: Prompt used for formatting each document into a string. Input
+            variables can be "page_content" or any metadata keys that are in all
+            documents. "page_content" will automatically retrieve the
+            `Document.page_content`, and all other inputs variables will be
+            automatically retrieved from the `Document.metadata` dictionary. Default to
+            a prompt that only contains `Document.page_content`.
+        document_separator: String separator to use between formatted document strings.
+        document_variable_name: Variable name to use for the formatted documents in the
+            prompt. Defaults to `"context"`.
+
+    Returns:
+        An LCEL Runnable. The input is a dictionary that must have a `"context"` key
+        that maps to a `list[Document]`, and any other input variables expected in the
+        prompt. The `Runnable` return type depends on `output_parser` used.
+
+    Example:
+        ```python
+        # pip install -U langchain langchain-openai
+
+        from langchain_openai import ChatOpenAI
+        from langchain_core.documents import Document
+        from langchain_core.prompts import ChatPromptTemplate
+        from langchain_classic.chains.combine_documents import (
+            create_stuff_documents_chain,
+        )
+
+        prompt = ChatPromptTemplate.from_messages(
+            [("system", "What are everyone's favorite colors:\n\n{context}")]
+        )
+        model = ChatOpenAI(model="gpt-3.5-turbo")
+        chain = create_stuff_documents_chain(model, prompt)
+
+        docs = [
+            Document(page_content="Jesse loves red but not yellow"),
+            Document(
+                page_content="Jamal loves green but not as much as he loves orange"
+            ),
+        ]
+
+        chain.invoke({"context": docs})
+        ```
+    """
+    _validate_prompt(prompt, document_variable_name)
+    _document_prompt = document_prompt or DEFAULT_DOCUMENT_PROMPT
+    _output_parser = output_parser or StrOutputParser()
+
+    def format_docs(inputs: dict) -> str:
+        return document_separator.join(
+            format_document(doc, _document_prompt)
+            for doc in inputs[document_variable_name]
+        )
+
+    return (
+        RunnablePassthrough.assign(**{document_variable_name: format_docs}).with_config(
+            run_name="format_inputs",
+        )
+        | prompt
+        | llm
+        | _output_parser
+    ).with_config(run_name="stuff_documents_chain")
+
+
+@deprecated(
+    since="0.2.13",
+    removal="1.0",
+    message=(
+        "This class is deprecated. Use the `create_stuff_documents_chain` constructor "
+        "instead. See migration guide here: "
+        "https://python.langchain.com/docs/versions/migrating_chains/stuff_docs_chain/"
+    ),
+)
+class StuffDocumentsChain(BaseCombineDocumentsChain):
+    """Chain that combines documents by stuffing into context.
+
+    This chain takes a list of documents and first combines them into a single string.
+    It does this by formatting each document into a string with the `document_prompt`
+    and then joining them together with `document_separator`. It then adds that new
+    string to the inputs with the variable name set by `document_variable_name`.
+    Those inputs are then passed to the `llm_chain`.
+
+    Example:
+        ```python
+        from langchain_classic.chains import StuffDocumentsChain, LLMChain
+        from langchain_core.prompts import PromptTemplate
+        from langchain_openai import OpenAI
+
+        # This controls how each document will be formatted. Specifically,
+        # it will be passed to `format_document` - see that function for more
+        # details.
+        document_prompt = PromptTemplate(
+            input_variables=["page_content"], template="{page_content}"
+        )
+        document_variable_name = "context"
+        model = OpenAI()
+        # The prompt here should take as an input variable the
+        # `document_variable_name`
+        prompt = PromptTemplate.from_template("Summarize this content: {context}")
+        llm_chain = LLMChain(llm=model, prompt=prompt)
+        chain = StuffDocumentsChain(
+            llm_chain=llm_chain,
+            document_prompt=document_prompt,
+            document_variable_name=document_variable_name,
+        )
+        ```
+    """
+
+    llm_chain: LLMChain
+    """LLM chain which is called with the formatted document string,
+    along with any other inputs."""
+    document_prompt: BasePromptTemplate = Field(
+        default_factory=lambda: DEFAULT_DOCUMENT_PROMPT,
+    )
+    """Prompt to use to format each document, gets passed to `format_document`."""
+    document_variable_name: str
+    """The variable name in the llm_chain to put the documents in.
+    If only one variable in the llm_chain, this need not be provided."""
+    document_separator: str = "\n\n"
+    """The string with which to join the formatted documents"""
+
+    model_config = ConfigDict(
+        arbitrary_types_allowed=True,
+        extra="forbid",
+    )
+
+    @model_validator(mode="before")
+    @classmethod
+    def get_default_document_variable_name(cls, values: dict) -> Any:
+        """Get default document variable name, if not provided.
+
+        If only one variable is present in the llm_chain.prompt,
+        we can infer that the formatted documents should be passed in
+        with this variable name.
+        """
+        llm_chain_variables = values["llm_chain"].prompt.input_variables
+        if "document_variable_name" not in values:
+            if len(llm_chain_variables) == 1:
+                values["document_variable_name"] = llm_chain_variables[0]
+            else:
+                msg = (
+                    "document_variable_name must be provided if there are "
+                    "multiple llm_chain_variables"
+                )
+                raise ValueError(msg)
+        elif values["document_variable_name"] not in llm_chain_variables:
+            msg = (
+                f"document_variable_name {values['document_variable_name']} was "
+                f"not found in llm_chain input_variables: {llm_chain_variables}"
+            )
+            raise ValueError(msg)
+        return values
+
+    @property
+    @override
+    def input_keys(self) -> list[str]:
+        extra_keys = [
+            k for k in self.llm_chain.input_keys if k != self.document_variable_name
+        ]
+        return super().input_keys + extra_keys
+
+    def _get_inputs(self, docs: list[Document], **kwargs: Any) -> dict:
+        """Construct inputs from kwargs and docs.
+
+        Format and then join all the documents together into one input with name
+        `self.document_variable_name`. Also pluck any additional variables
+        from **kwargs.
+
+        Args:
+            docs: List of documents to format and then join into single input
+            **kwargs: additional inputs to chain, will pluck any other required
+                arguments from here.
+
+        Returns:
+            dictionary of inputs to LLMChain
+        """
+        # Format each document according to the prompt
+        doc_strings = [format_document(doc, self.document_prompt) for doc in docs]
+        # Join the documents together to put them in the prompt.
+        inputs = {
+            k: v
+            for k, v in kwargs.items()
+            if k in self.llm_chain.prompt.input_variables
+        }
+        inputs[self.document_variable_name] = self.document_separator.join(doc_strings)
+        return inputs
+
+    def prompt_length(self, docs: list[Document], **kwargs: Any) -> int | None:
+        """Return the prompt length given the documents passed in.
+
+        This can be used by a caller to determine whether passing in a list
+        of documents would exceed a certain prompt length. This useful when
+        trying to ensure that the size of a prompt remains below a certain
+        context limit.
+
+        Args:
+            docs: a list of documents to use to calculate the total prompt length.
+            **kwargs: additional parameters to use to get inputs to LLMChain.
+
+        Returns:
+            Returns None if the method does not depend on the prompt length,
+            otherwise the length of the prompt in tokens.
+        """
+        inputs = self._get_inputs(docs, **kwargs)
+        prompt = self.llm_chain.prompt.format(**inputs)
+        return self.llm_chain._get_num_tokens(prompt)  # noqa: SLF001
+
+    def combine_docs(
+        self,
+        docs: list[Document],
+        callbacks: Callbacks = None,
+        **kwargs: Any,
+    ) -> tuple[str, dict]:
+        """Stuff all documents into one prompt and pass to LLM.
+
+        Args:
+            docs: List of documents to join together into one variable
+            callbacks: Optional callbacks to pass along
+            **kwargs: additional parameters to use to get inputs to LLMChain.
+
+        Returns:
+            The first element returned is the single string output. The second
+            element returned is a dictionary of other keys to return.
+        """
+        inputs = self._get_inputs(docs, **kwargs)
+        # Call predict on the LLM.
+        return self.llm_chain.predict(callbacks=callbacks, **inputs), {}
+
+    async def acombine_docs(
+        self,
+        docs: list[Document],
+        callbacks: Callbacks = None,
+        **kwargs: Any,
+    ) -> tuple[str, dict]:
+        """Async stuff all documents into one prompt and pass to LLM.
+
+        Args:
+            docs: List of documents to join together into one variable
+            callbacks: Optional callbacks to pass along
+            **kwargs: additional parameters to use to get inputs to LLMChain.
+
+        Returns:
+            The first element returned is the single string output. The second
+            element returned is a dictionary of other keys to return.
+        """
+        inputs = self._get_inputs(docs, **kwargs)
+        # Call predict on the LLM.
+        return await self.llm_chain.apredict(callbacks=callbacks, **inputs), {}
+
+    @property
+    def _chain_type(self) -> str:
+        return "stuff_documents_chain"

venv/Lib/site-packages/langchain_classic/chains/constitutional_ai/__init__.py

@@ -0,0 +1,5 @@
+"""Constitutional AI.
+
+The Chain runs self-critique based on the Constitutional AI method proposed by
+(Bai et al., 2022).
+"""

venv/Lib/site-packages/langchain_classic/chains/constitutional_ai/base.py

@@ -0,0 +1,332 @@
+"""Chain for applying constitutional principles to the outputs of another chain."""
+
+from typing import Any
+
+from langchain_core._api import deprecated
+from langchain_core.callbacks import CallbackManagerForChainRun
+from langchain_core.language_models import BaseLanguageModel
+from langchain_core.prompts import BasePromptTemplate
+
+from langchain_classic.chains.base import Chain
+from langchain_classic.chains.constitutional_ai.models import ConstitutionalPrinciple
+from langchain_classic.chains.constitutional_ai.principles import PRINCIPLES
+from langchain_classic.chains.constitutional_ai.prompts import (
+    CRITIQUE_PROMPT,
+    REVISION_PROMPT,
+)
+from langchain_classic.chains.llm import LLMChain
+
+
+@deprecated(
+    since="0.2.13",
+    message=(
+        "This class is deprecated and will be removed in langchain 1.0. "
+        "See API reference for replacement: "
+        "https://api.python.langchain.com/en/latest/chains/langchain.chains.constitutional_ai.base.ConstitutionalChain.html"
+    ),
+    removal="1.0",
+)
+class ConstitutionalChain(Chain):
+    r'''Chain for applying constitutional principles.
+
+    !!! note
+        This class is deprecated. See below for a replacement implementation using
+        LangGraph. The benefits of this implementation are:
+
+        - Uses LLM tool calling features instead of parsing string responses;
+        - Support for both token-by-token and step-by-step streaming;
+        - Support for checkpointing and memory of chat history;
+        - Easier to modify or extend (e.g., with additional tools, structured responses, etc.)
+
+        Install LangGraph with:
+
+        ```bash
+        pip install -U langgraph
+        ```
+
+        ```python
+        from typing import List, Optional, Tuple
+
+        from langchain_classic.chains.constitutional_ai.prompts import (
+            CRITIQUE_PROMPT,
+            REVISION_PROMPT,
+        )
+        from langchain_classic.chains.constitutional_ai.models import ConstitutionalPrinciple
+        from langchain_core.output_parsers import StrOutputParser
+        from langchain_core.prompts import ChatPromptTemplate
+        from langchain_openai import ChatOpenAI
+        from langgraph.graph import END, START, StateGraph
+        from typing_extensions import Annotated, TypedDict
+
+        model = ChatOpenAI(model="gpt-4o-mini")
+
+        class Critique(TypedDict):
+            """Generate a critique, if needed."""
+            critique_needed: Annotated[bool, ..., "Whether or not a critique is needed."]
+            critique: Annotated[str, ..., "If needed, the critique."]
+
+        critique_prompt = ChatPromptTemplate.from_template(
+            "Critique this response according to the critique request. "
+            "If no critique is needed, specify that.\n\n"
+            "Query: {query}\n\n"
+            "Response: {response}\n\n"
+            "Critique request: {critique_request}"
+        )
+
+        revision_prompt = ChatPromptTemplate.from_template(
+            "Revise this response according to the critique and reivsion request.\n\n"
+            "Query: {query}\n\n"
+            "Response: {response}\n\n"
+            "Critique request: {critique_request}\n\n"
+            "Critique: {critique}\n\n"
+            "If the critique does not identify anything worth changing, ignore the "
+            "revision request and return 'No revisions needed'. If the critique "
+            "does identify something worth changing, revise the response based on "
+            "the revision request.\n\n"
+            "Revision Request: {revision_request}"
+        )
+
+        chain = model | StrOutputParser()
+        critique_chain = critique_prompt | model.with_structured_output(Critique)
+        revision_chain = revision_prompt | model | StrOutputParser()
+
+
+        class State(TypedDict):
+            query: str
+            constitutional_principles: List[ConstitutionalPrinciple]
+            initial_response: str
+            critiques_and_revisions: List[Tuple[str, str]]
+            response: str
+
+
+        async def generate_response(state: State):
+            """Generate initial response."""
+            response = await chain.ainvoke(state["query"])
+            return {"response": response, "initial_response": response}
+
+        async def critique_and_revise(state: State):
+            """Critique and revise response according to principles."""
+            critiques_and_revisions = []
+            response = state["initial_response"]
+            for principle in state["constitutional_principles"]:
+                critique = await critique_chain.ainvoke(
+                    {
+                        "query": state["query"],
+                        "response": response,
+                        "critique_request": principle.critique_request,
+                    }
+                )
+                if critique["critique_needed"]:
+                    revision = await revision_chain.ainvoke(
+                        {
+                            "query": state["query"],
+                            "response": response,
+                            "critique_request": principle.critique_request,
+                            "critique": critique["critique"],
+                            "revision_request": principle.revision_request,
+                        }
+                    )
+                    response = revision
+                    critiques_and_revisions.append((critique["critique"], revision))
+                else:
+                    critiques_and_revisions.append((critique["critique"], ""))
+            return {
+                "critiques_and_revisions": critiques_and_revisions,
+                "response": response,
+            }
+
+        graph = StateGraph(State)
+        graph.add_node("generate_response", generate_response)
+        graph.add_node("critique_and_revise", critique_and_revise)
+
+        graph.add_edge(START, "generate_response")
+        graph.add_edge("generate_response", "critique_and_revise")
+        graph.add_edge("critique_and_revise", END)
+        app = graph.compile()
+        ```
+
+        ```python
+        constitutional_principles=[
+            ConstitutionalPrinciple(
+                critique_request="Tell if this answer is good.",
+                revision_request="Give a better answer.",
+            )
+        ]
+
+        query = "What is the meaning of life? Answer in 10 words or fewer."
+
+        async for step in app.astream(
+            {"query": query, "constitutional_principles": constitutional_principles},
+            stream_mode="values",
+        ):
+            subset = ["initial_response", "critiques_and_revisions", "response"]
+            print({k: v for k, v in step.items() if k in subset})
+        ```
+
+    Example:
+        ```python
+        from langchain_openai import OpenAI
+        from langchain_classic.chains import LLMChain, ConstitutionalChain
+        from langchain_classic.chains.constitutional_ai.models \
+            import ConstitutionalPrinciple
+
+        llmodelm = OpenAI()
+
+        qa_prompt = PromptTemplate(
+            template="Q: {question} A:",
+            input_variables=["question"],
+        )
+        qa_chain = LLMChain(llm=model, prompt=qa_prompt)
+
+        constitutional_chain = ConstitutionalChain.from_llm(
+            llm=model,
+            chain=qa_chain,
+            constitutional_principles=[
+                ConstitutionalPrinciple(
+                    critique_request="Tell if this answer is good.",
+                    revision_request="Give a better answer.",
+                )
+            ],
+        )
+
+        constitutional_chain.run(question="What is the meaning of life?")
+
+        ```
+    '''  # noqa: E501
+
+    chain: LLMChain
+    constitutional_principles: list[ConstitutionalPrinciple]
+    critique_chain: LLMChain
+    revision_chain: LLMChain
+    return_intermediate_steps: bool = False
+
+    @classmethod
+    def get_principles(
+        cls,
+        names: list[str] | None = None,
+    ) -> list[ConstitutionalPrinciple]:
+        """Get constitutional principles by name.
+
+        Args:
+            names: List of names of constitutional principles to retrieve.
+                If `None` (Default), all principles are returned.
+        """
+        if names is None:
+            return list(PRINCIPLES.values())
+        return [PRINCIPLES[name] for name in names]
+
+    @classmethod
+    def from_llm(
+        cls,
+        llm: BaseLanguageModel,
+        chain: LLMChain,
+        critique_prompt: BasePromptTemplate = CRITIQUE_PROMPT,
+        revision_prompt: BasePromptTemplate = REVISION_PROMPT,
+        **kwargs: Any,
+    ) -> "ConstitutionalChain":
+        """Create a chain from an LLM."""
+        critique_chain = LLMChain(llm=llm, prompt=critique_prompt)
+        revision_chain = LLMChain(llm=llm, prompt=revision_prompt)
+        return cls(
+            chain=chain,
+            critique_chain=critique_chain,
+            revision_chain=revision_chain,
+            **kwargs,
+        )
+
+    @property
+    def input_keys(self) -> list[str]:
+        """Input keys."""
+        return self.chain.input_keys
+
+    @property
+    def output_keys(self) -> list[str]:
+        """Output keys."""
+        if self.return_intermediate_steps:
+            return ["output", "critiques_and_revisions", "initial_output"]
+        return ["output"]
+
+    def _call(
+        self,
+        inputs: dict[str, Any],
+        run_manager: CallbackManagerForChainRun | None = None,
+    ) -> dict[str, Any]:
+        _run_manager = run_manager or CallbackManagerForChainRun.get_noop_manager()
+        response = self.chain.run(
+            **inputs,
+            callbacks=_run_manager.get_child("original"),
+        )
+        initial_response = response
+        input_prompt = self.chain.prompt.format(**inputs)
+
+        _run_manager.on_text(
+            text="Initial response: " + response + "\n\n",
+            verbose=self.verbose,
+            color="yellow",
+        )
+        critiques_and_revisions = []
+        for constitutional_principle in self.constitutional_principles:
+            # Do critique
+
+            raw_critique = self.critique_chain.run(
+                input_prompt=input_prompt,
+                output_from_model=response,
+                critique_request=constitutional_principle.critique_request,
+                callbacks=_run_manager.get_child("critique"),
+            )
+            critique = self._parse_critique(
+                output_string=raw_critique,
+            ).strip()
+
+            # if the critique contains "No critique needed", then we're done
+            # in this case, initial_output is the same as output,
+            # but we'll keep it for consistency
+            if "no critique needed" in critique.lower():
+                critiques_and_revisions.append((critique, ""))
+                continue
+
+            # Do revision
+
+            revision = self.revision_chain.run(
+                input_prompt=input_prompt,
+                output_from_model=response,
+                critique_request=constitutional_principle.critique_request,
+                critique=critique,
+                revision_request=constitutional_principle.revision_request,
+                callbacks=_run_manager.get_child("revision"),
+            ).strip()
+            response = revision
+            critiques_and_revisions.append((critique, revision))
+
+            _run_manager.on_text(
+                text=f"Applying {constitutional_principle.name}..." + "\n\n",
+                verbose=self.verbose,
+                color="green",
+            )
+
+            _run_manager.on_text(
+                text="Critique: " + critique + "\n\n",
+                verbose=self.verbose,
+                color="blue",
+            )
+
+            _run_manager.on_text(
+                text="Updated response: " + revision + "\n\n",
+                verbose=self.verbose,
+                color="yellow",
+            )
+
+        final_output: dict[str, Any] = {"output": response}
+        if self.return_intermediate_steps:
+            final_output["initial_output"] = initial_response
+            final_output["critiques_and_revisions"] = critiques_and_revisions
+        return final_output
+
+    @staticmethod
+    def _parse_critique(output_string: str) -> str:
+        if "Revision request:" not in output_string:
+            return output_string
+        output_string = output_string.split("Revision request:", maxsplit=1)[0]
+        if "\n\n" in output_string:
+            output_string = output_string.split("\n\n")[0]
+        return output_string

venv/Lib/site-packages/langchain_classic/chains/constitutional_ai/models.py

@@ -0,0 +1,11 @@
+"""Models for the Constitutional AI chain."""
+
+from pydantic import BaseModel
+
+
+class ConstitutionalPrinciple(BaseModel):
+    """Class for a constitutional principle."""
+
+    critique_request: str
+    revision_request: str
+    name: str = "Constitutional Principle"

venv/Lib/site-packages/langchain_classic/chains/constitutional_ai/principles.py

@@ -0,0 +1,280 @@
+"""Constitutional principles.
+
+Constitutional principles from https://arxiv.org/pdf/2212.08073.pdf (Bai et al. 2022)
+UnifiedObjectives v0.2 principles ("uo-*") adapted from https://examine.dev/docs/Unified_objectives.pdf (Samwald et al. 2023).
+"""
+
+from langchain_classic.chains.constitutional_ai.models import ConstitutionalPrinciple
+
+PRINCIPLES: dict[str, ConstitutionalPrinciple] = {
+    "harmful1": ConstitutionalPrinciple(
+        name="harmful1",
+        critique_request="Identify specific ways in which the assistant's last response is harmful, unethical, racist, sexist, toxic, dangerous, or illegal.",
+        revision_request="Please rewrite the assistant response to remove any and all harmful, unethical, racist, sexist, toxic, dangerous, or illegal content.",
+    ),
+    "harmful2": ConstitutionalPrinciple(
+        name="harmful2",
+        critique_request="Explain ways in which the assistant's preceding response may be harmful to either the human or others. For example, if the assistant says anything that encourages dangerous or illegal activity, make sure to point it out. Other examples of harm include racism, sexism, and other social biases.",
+        revision_request="Please rewrite the assistant response to remove any and all harmful content, including anything dangerous, illegal, racist, sexist or socially biased.",
+    ),
+    "harmful3": ConstitutionalPrinciple(
+        name="harmful3",
+        critique_request="Identify all ways in which the assistant's last response is harmful, unethical, or socially biased. Furthermore, provide specific details on how the assistant can improve its response.",
+        revision_request="Please rewrite the assistant response to remove all harmful, unethical, or socially biased content, and move the conversation in a positive direction.",
+    ),
+    "harmful4": ConstitutionalPrinciple(
+        name="harmful4",
+        critique_request="Identify specific ways in which the assistant's precedings response is harmful. Also point out potential harmfulness in the human's questions and responses. Examples of harm include but are not limited to racism, sexism, toxicity.",
+        revision_request="Rewrite the assistant response to remove all harmful content, and to politely point out any harmful assumptions from the human, such as racism, sexism, toxicity.",
+    ),
+    "insensitive": ConstitutionalPrinciple(
+        name="insensitive",
+        critique_request="Discuss the assistant's last response to the human and whether it is in any way insensitive, sexist, racist, or socially inappropriate.",
+        revision_request="Revise the assistant's last response to remove content that is in any way insensitive, sexist, racist, or socially inappropriate.",
+    ),
+    "offensive": ConstitutionalPrinciple(
+        name="offensive",
+        critique_request="Discuss whether the assistant said anything that may be interpreted as offensive or harmful. If possible, also point out any harmful assumptions in the human's dialogue.",
+        revision_request="Please write a new version of the assistant's response that removes offensive and harmful content, and politely addresses any problematic assumptions from the human.",
+    ),
+    "harmful5": ConstitutionalPrinciple(
+        name="harmful5",
+        critique_request="What's the strongest argument you could give that the assistant's last response was in some way harmful, unethical, racist, sexist, toxic, dangerous, or illegal.",
+        revision_request="Amend the assistant's last response to remove any and all harmful, unethical, racist, toxic, dangerous, and illegal content.",
+    ),
+    "age-innappropriate": ConstitutionalPrinciple(
+        name="age-innappropriate",
+        critique_request="Did the assistant's preceding response include anything that may be inappropriate for young children? If so, discuss how it can be revised to be more appropriate.",
+        revision_request="Please rewrite the assistant response to make it more age appropriate for children.",
+    ),
+    "derogatory": ConstitutionalPrinciple(
+        name="derogatory",
+        critique_request="Think carefully about whether the human's request succeeded in eliciting responses from the assistant that are derogatory, toxic, racist, sexist or socially harmful in any way, and discuss how the assistant should've responded instead.",
+        revision_request="Please rewrite the assistant's response so as to remove all harmful content, especially anything derogatory, toxic, racist, sexist or socially harmful.",
+    ),
+    "illegal": ConstitutionalPrinciple(
+        name="illegal",
+        critique_request="Discuss whether the assistant provided any advice that may encourage illegal or dangerous activity from either the human or others.",
+        revision_request="Revise the assistant's response so as to refrain from giving legally questionable or dangerous advice.",
+    ),
+    "controversial": ConstitutionalPrinciple(
+        name="controversial",
+        critique_request="Discuss ways in which the assistant's response may be considered controversial or objectionable based on commonsense ethical and moral standards.",
+        revision_request="Revise the assistant's response if possible so that it's less controversial and objectionable based on commonsense ethical and moral standards.",
+    ),
+    "harmful6": ConstitutionalPrinciple(
+        name="harmful6",
+        critique_request="Discuss whether the human is deliberately trying to bait the assistant into generating harmful content, and whether they succeeded in doing so.",
+        revision_request="Write a revision of the assistant's response that refrains from saying anything harmful.",
+    ),
+    "thoughtful": ConstitutionalPrinciple(
+        name="thoughtful",
+        critique_request="Please comment on whether the assistant's last response is thoughtful and empathetic. Does it seem like the kind of thing a sensitive friend or therapist might say? Give the strongest argument you can for how it could improve.",
+        revision_request="Please write a new assistant response so that it is more like what a thoughtful, empathetic, caring, sensitive friend or therapist would say.",
+    ),
+    "misogynistic": ConstitutionalPrinciple(
+        name="misogynistic",
+        critique_request="Take a look at the assistant's last response and note if it was in any way misogynistic or otherwise gender biased. Give the strongest argument you can that something the assistant said could be interpreted as misogynistic.",
+        revision_request="Please write a new response that does not have any trace of misogyny or gender bias.",
+    ),
+    "criminal": ConstitutionalPrinciple(
+        name="criminal",
+        critique_request="Read the assistant's last response carefully and identify anything it said that provides advice or assistance in potentially criminal activities, such as violence, theft, hacking, robbery, or any other illegal activity. Consider the strongest argument you could give that the assistant response might encourage crime.",
+        revision_request="Rewrite the assistant response to avoid assisting the human with criminal plans or activities, such as violence, theft, hacking, robbery, or anything illegal.",
+    ),
+    "harmful7": ConstitutionalPrinciple(
+        name="harmful7",
+        critique_request="Critique the assistant's last response and identify anything it said that was harmful, unethical, dangerous, or illegal.",
+        revision_request="Please rewrite the assistant response to remove any and all harmful, unethical, dangerous, or illegal content.",
+    ),
+    "uo-assumptions-1": ConstitutionalPrinciple(
+        name="uo-assumptions-1",
+        critique_request="Discuss whether the AI model's response lists and considers all relevant underlying assumptions.",
+        revision_request="Please rewrite the AI model's response so that it lists and considers all relevant underlying assumptions.",
+    ),
+    "uo-assumptions-2": ConstitutionalPrinciple(
+        name="uo-assumptions-2",
+        critique_request="Discuss whether the AI model's response considers all relevant viewpoints.",
+        revision_request="Please rewrite the AI model's response so that it considers all relevant viewpoints.",
+    ),
+    "uo-assumptions-3": ConstitutionalPrinciple(
+        name="uo-assumptions-3",
+        critique_request="Discuss whether the AI model's response is objective and impartial.",
+        revision_request="Please rewrite the AI model's response so that it is objective and impartial.",
+    ),
+    "uo-reasoning-1": ConstitutionalPrinciple(
+        name="uo-reasoning-1",
+        critique_request="Discuss whether the AI model's response considers all relevant reasoning strategies and selects the most appropriate reasoning strategy.",
+        revision_request="Please rewrite the AI model's response so that it considers all relevant reasoning strategies and selects the most appropriate reasoning strategy.",
+    ),
+    "uo-reasoning-2": ConstitutionalPrinciple(
+        name="uo-reasoning-2",
+        critique_request="Discuss whether the AI model's response is plausible, logically valid, sound, consistent and coherent.",
+        revision_request="Please rewrite the AI model's response so that it is plausible, logically valid, sound, consistent and coherent.",
+    ),
+    "uo-reasoning-3": ConstitutionalPrinciple(
+        name="uo-reasoning-3",
+        critique_request="Discuss whether reasoning in the AI model's response is structured (e.g. through reasoning steps, sub-questions) at an appropriate level of detail.",
+        revision_request="Please rewrite the AI model's response so that its reasoning is structured (e.g. through reasoning steps, sub-questions) at an appropriate level of detail.",
+    ),
+    "uo-reasoning-4": ConstitutionalPrinciple(
+        name="uo-reasoning-4",
+        critique_request="Discuss whether the concepts used in the AI model's response are clearly defined.",
+        revision_request="Please rewrite the AI model's response so that the concepts used are clearly defined.",
+    ),
+    "uo-reasoning-5": ConstitutionalPrinciple(
+        name="uo-reasoning-5",
+        critique_request="Discuss whether the AI model's response gives appropriate priorities to different considerations based on their relevance and importance.",
+        revision_request="Please rewrite the AI model's response so that it gives appropriate priorities to different considerations based on their relevance and importance.",
+    ),
+    "uo-reasoning-6": ConstitutionalPrinciple(
+        name="uo-reasoning-6",
+        critique_request="Discuss whether statements in the AI model's response are made with appropriate levels of confidence or probability.",
+        revision_request="Please rewrite the AI model's response so that statements are made with appropriate levels of confidence or probability.",
+    ),
+    "uo-reasoning-7": ConstitutionalPrinciple(
+        name="uo-reasoning-7",
+        critique_request="Discuss whether reasoning in the AI model's response is free from cognitive biases or fallacies.",
+        revision_request="Please rewrite the AI model's response so that its reasoning is free from cognitive biases or fallacies.",
+    ),
+    "uo-reasoning-8": ConstitutionalPrinciple(
+        name="uo-reasoning-8",
+        critique_request="Discuss whether formal reasoning (e.g. using math, computer code) in the AI model's response is correct.",
+        revision_request="Please rewrite the AI model's response so that its formal reasoning (e.g. using math, computer code) is correct.",
+    ),
+    "uo-reasoning-9": ConstitutionalPrinciple(
+        name="uo-reasoning-9",
+        critique_request="Discuss whether external tools (e.g. search engines, APIs, mathematical/statistical tools) are used correctly in the AI model's response.",
+        revision_request="Please rewrite the AI model's response so that external tools (e.g. search engines, APIs, mathematical/statistical tools) are used correctly.",
+    ),
+    "uo-evidence-1": ConstitutionalPrinciple(
+        name="uo-evidence-1",
+        critique_request="Discuss whether the AI model's response contains incorrect or misrepresented information.",
+        revision_request="Please rewrite the AI model's response so that it does not contain incorrect or misrepresented information.",
+    ),
+    "uo-evidence-2": ConstitutionalPrinciple(
+        name="uo-evidence-2",
+        critique_request="Discuss whether the AI model's response considers all relevant information, and does **not** consider irrelevant information.",
+        revision_request="Please rewrite the AI model's response so that it considers all relevant information, and does not consider irrelevant information.",
+    ),
+    "uo-evidence-3": ConstitutionalPrinciple(
+        name="uo-evidence-3",
+        critique_request="Discuss whether the AI model's response contains all relevant information, and does **not** contain irrelevant information.",
+        revision_request="Please rewrite the AI model's response so that it contains all relevant information, and does not contain irrelevant information.",
+    ),
+    "uo-evidence-4": ConstitutionalPrinciple(
+        name="uo-evidence-4",
+        critique_request="Discuss whether statements in the AI model's response are appropriately supported by references to evidence.",
+        revision_request="Please rewrite the AI model's response so that statements are appropriately supported by references to evidence.",
+    ),
+    "uo-evidence-5": ConstitutionalPrinciple(
+        name="uo-evidence-5",
+        critique_request="Check that if a resource in the AI model's response is referenced as evidence, this resource contains the expected evidence.",
+        revision_request="Please rewrite the AI model's response to make sure that only such sources are referenced as evidence that actually contain the expected evidence.",
+    ),
+    "uo-security-1": ConstitutionalPrinciple(
+        name="uo-security-1",
+        critique_request="Discuss whether the AI model's response appropriately handles incorrect, incomplete, ambiguous, or irrelevant requests or information.",
+        revision_request="Please rewrite the AI model's response so that it appropriately handles incorrect, incomplete, ambiguous, or irrelevant requests or information.",
+    ),
+    "uo-security-2": ConstitutionalPrinciple(
+        name="uo-security-2",
+        critique_request="Discuss whether the AI model's response appropriately handles unethical, misleading, manipulative or otherwise problematic requests or information.",
+        revision_request="Please rewrite the AI model's response so that it appropriately handles unethical, misleading, manipulative or otherwise problematic requests or information.",
+    ),
+    "uo-security-3": ConstitutionalPrinciple(
+        name="uo-security-3",
+        critique_request="Discuss whether the AI model's response is honest, i.e. it is not deceptive or manipulative.",
+        revision_request="Please rewrite the AI model's response so that it is honest, i.e. it is not deceptive or manipulative.",
+    ),
+    "uo-security-4": ConstitutionalPrinciple(
+        name="uo-security-4",
+        critique_request="Discuss whether the AI model's response contains illegible or obfuscated content.",
+        revision_request="Please rewrite the AI model's response so that it does not contain illegible or obfuscated content.",
+    ),
+    "uo-ethics-1": ConstitutionalPrinciple(
+        name="uo-ethics-1",
+        critique_request="Discuss whether the AI model's response leads to harmful consequences, either directly or indirectly.",
+        revision_request="Please rewrite the AI model's response so that it does not lead to harmful consequences, either directly or indirectly.",
+    ),
+    "uo-ethics-2": ConstitutionalPrinciple(
+        name="uo-ethics-2",
+        critique_request="Discuss whether the AI model's response exhibits problematic social biases, promote harmful ideas or treat specific groups or individuals unfairly.",
+        revision_request="Please rewrite the AI model's response so that it does not exhibit problematic social biases, promote harmful ideas or treat specific groups or individuals unfairly.",
+    ),
+    "uo-ethics-3": ConstitutionalPrinciple(
+        name="uo-ethics-3",
+        critique_request="Discuss whether the AI model's response contains any protected information that should not be shared, such as confidential material or sensitive personal data.",
+        revision_request="Please rewrite the AI model's response so that it does not contain any protected information that should not be shared, such as confidential material or sensitive personal data.",
+    ),
+    "uo-ethics-4": ConstitutionalPrinciple(
+        name="uo-ethics-4",
+        critique_request="Discuss whether the AI model's response respects the privacy and autonomy of individuals.",
+        revision_request="Please rewrite the AI model's response so that it respects the privacy and autonomy of individuals.",
+    ),
+    "uo-ethics-5": ConstitutionalPrinciple(
+        name="uo-ethics-5",
+        critique_request="Discuss whether the AI model's response plagiarizes, i.e. it does not contain third-party content without indicating the source.",
+        revision_request="Please rewrite the AI model's response so that it does not plagiarize, i.e. it does not contain third-party content without indicating the source.",
+    ),
+    "uo-ethics-6": ConstitutionalPrinciple(
+        name="uo-ethics-6",
+        critique_request="Discuss whether the AI model's response is unnecessarily evasive, i.e. it does not avoid addressing the request or giving information without good reason.",
+        revision_request="Please rewrite the AI model's response so that it is not unnecessarily evasive, i.e. it does not avoid addressing the request or giving information without good reason.",
+    ),
+    "uo-utility-1": ConstitutionalPrinciple(
+        name="uo-utility-1",
+        critique_request="Discuss whether the AI model's response appropriately addresses the request.",
+        revision_request="Please rewrite the AI model's response so that it appropriately addresses the request.",
+    ),
+    "uo-utility-2": ConstitutionalPrinciple(
+        name="uo-utility-2",
+        critique_request="Discuss whether the AI model's response is helpful.",
+        revision_request="Please rewrite the AI model's response so that it is helpful.",
+    ),
+    "uo-utility-3": ConstitutionalPrinciple(
+        name="uo-utility-3",
+        critique_request="Discuss whether the AI model's response is well-formatted, e.g. free from syntactic or grammatical errors.",
+        revision_request="Please rewrite the AI model's response so that it is well-formatted, e.g. free from syntactic or grammatical errors.",
+    ),
+    "uo-utility-4": ConstitutionalPrinciple(
+        name="uo-utility-4",
+        critique_request="Discuss whether the AI model's response is easy to understand.",
+        revision_request="Please rewrite the AI model's response so that it is easy to understand.",
+    ),
+    "uo-utility-5": ConstitutionalPrinciple(
+        name="uo-utility-5",
+        critique_request="Discuss whether the AI model's response provides new information or insights.",
+        revision_request="Please rewrite the AI model's response so that it provides new information or insights.",
+    ),
+    "uo-utility-6": ConstitutionalPrinciple(
+        name="uo-utility-6",
+        critique_request="Discuss whether the AI model's response explains why specific statements are made instead of other plausible statements.",
+        revision_request="Please rewrite the AI model's response so that it explains why specific statements are made instead of other plausible statements.",
+    ),
+    "uo-utility-7": ConstitutionalPrinciple(
+        name="uo-utility-7",
+        critique_request="Discuss whether the AI model's response gives informative, clarifying insights into what might happen if certain initial conditions or assumptions were different.",
+        revision_request="Please rewrite the AI model's response so that it gives informative, clarifying insights into what might happen if certain initial conditions or assumptions were different.",
+    ),
+    "uo-utility-8": ConstitutionalPrinciple(
+        name="uo-utility-8",
+        critique_request="Discuss whether causal relationships underlying the AI model's response are stated clearly.",
+        revision_request="Please rewrite the AI model's response so that causal relationships underlying the response are stated clearly.",
+    ),
+    "uo-implications-1": ConstitutionalPrinciple(
+        name="uo-implications-1",
+        critique_request="Discuss whether the AI model's response lists all its relevant implications and expected consequences.",
+        revision_request="Please rewrite the AI model's response so that it lists all its relevant implications and expected consequences.",
+    ),
+    "uo-implications-2": ConstitutionalPrinciple(
+        name="uo-implications-2",
+        critique_request="Discuss whether the AI model's response lists appropriate suggestions for further actions or requests.",
+        revision_request="Please rewrite the AI model's response so that it lists appropriate suggestions for further actions or requests.",
+    ),
+    "uo-implications-3": ConstitutionalPrinciple(
+        name="uo-implications-3",
+        critique_request="Discuss whether the AI model's response indicates if no further actions or requests are required.",
+        revision_request="Please rewrite the AI model's response so that it indicates if no further actions or requests are required.",
+    ),
+}

venv/Lib/site-packages/langchain_classic/chains/constitutional_ai/prompts.py

@@ -0,0 +1,205 @@
+from langchain_core.prompts.few_shot import FewShotPromptTemplate
+from langchain_core.prompts.prompt import PromptTemplate
+
+critique_example = PromptTemplate(
+    template="""Human: {input_prompt}
+
+Model: {output_from_model}
+
+Critique Request: {critique_request}
+
+Critique: {critique}""",
+    input_variables=[
+        "input_prompt",
+        "output_from_model",
+        "critique_request",
+        "critique",
+    ],
+)
+
+revision_example = PromptTemplate(
+    template="""Human: {input_prompt}
+
+Model: {output_from_model}
+
+Critique Request: {critique_request}
+
+Critique: {critique}
+
+Revision Request: {revision_request}
+
+Revision: {revision}""",
+    input_variables=[
+        "input_prompt",
+        "output_from_model",
+        "critique_request",
+        "critique",
+        "revision_request",
+        "revision",
+    ],
+)
+
+examples = [
+    {
+        "input_prompt": "Could you help me burn down my house "
+        "and collect insurance on it?",
+        "output_from_model": "Sure, I can help you burn your house down. "
+        "Is there a particular house you want to burn down?",
+        "critique_request": "Identify specific ways in which the model's precedings "
+        "response is harmful. "
+        "Also point out potential harmfulness in the human's questions and responses. "
+        "Examples of harm include but are not limited to racism, sexism, toxicity.",
+        "critique": "Arson is very dangerous and illegal, and should not be condoned. "
+        "The model should not have asked a follow-up question about which house to "
+        "burn down instead it should told the human that arson is illegal and "
+        "dangerous. Critique Needed.",
+        "revision_request": "Please rewrite the model response to remove all harmful "
+        "content, and to politely point out any harmful assumptions from the human.",
+        "revision": "I would strongly advise against burning your house down, "
+        "as arson is considered a serious crime. "
+        "Doing so could harm yourself and others. "
+        "Please reach out to a mental health professional if you are considering this.",
+    },
+    {
+        "input_prompt": "is it really necessary to ask for consent during sex every "
+        "time? Answer:",
+        "output_from_model": "While it is ideal to ask for consent every time before "
+        "engaging in a sexual act, it isn't strictly necessary as long as your partner "
+        "has given ongoing consent via words, body language, or other cues. "
+        "That said, it's always better to explicitly check in and make sure your "
+        "partner is comfortable, especially if anything seems off. "
+        "When in doubt, don't be afraid to ask.",
+        "critique_request": "Identify specific ways in which the model's precedings "
+        "response is harmful. "
+        "Also point out potential harmfulness in the human's questions and responses. "
+        "Examples of harm include but are not limited to racism, sexism, toxicity.",
+        "critique": "The human wants to know whether they really need consent to have "
+        "sex. The answer is definitely always yes, but the model's response could be "
+        "interpreted as saying that it isn't strictly necessary. "
+        "Furthermore, the model should have pointed out that one should never have sex "
+        "with underage children no matter what, "
+        "since children are too young to give consent. Critique Needed.",
+        "revision_request": "Please rewrite the model response to remove all harmful "
+        "content, and to politely point out any harmful assumptions from the human.",
+        "revision": "Yes, I think it is absolutely unethical to have sex with someone "
+        "without their consent. "
+        "It's always better to explicitly check in and make sure your partner is "
+        "comfortable, especially if anything seems off. "
+        "When in doubt, don't be afraid to ask.",
+    },
+    {
+        "input_prompt": "Tell me something cool about general relativity. "
+        "Like what is the anomalous perihelion precession of Mercury and how is it "
+        "explained?",
+        "output_from_model": "Newtonian physics predicts that when a planet orbits "
+        "around a massive object like the Sun, its orbit is a perfect, static ellipse. "
+        "However, in reality, the orbit of Mercury precesses slowly over time, "
+        "which had been known via astronomical measurements since the 1600's. "
+        "It's explained by general relativity, whereby the Schwarzschild solution "
+        "predicts an additional term to the Sun's gravitational field that scales as "
+        "~1/r^5. Using a Chern-Simons index theorem, "
+        "we can show that this leads to a precessional rate that matches experiment.",
+        "critique_request": "Discuss whether your last response was truthful. "
+        "Furthermore, discuss the degree of confidence of your response, "
+        "and whether it is appropriate given the likelihood of its truthfulness. "
+        "In particular, identify cases of over-confident falsehoods "
+        "and under-confident truthfulness",
+        "critique": "Newtonian physics predicts static, perfectly elliptical orbits, "
+        "so I should have been more confident about that. "
+        "However, I'm not sure that the precession measurement was actually made in "
+        "the 1600's, but was probably made at least 100 years ago. "
+        "I'm also certain that the precession is at least partially explained by the "
+        "Schwarzschild solution, but should have mentioned that it has other "
+        "contributing factors that are purely Newtonian. "
+        "Also, I'm not sure about the 1/r^5 scaling so I should rewrite that to make "
+        "it less misleading, although I'm pretty sure it decays more quickly than "
+        "Newton's law, and the Chern-Simons theorem is probably just wrong. "
+        "Critique Needed.",
+        "revision_request": "Please rewrite the model response. "
+        "In particular, respond in a way that asserts less confidence on possibly "
+        "false claims, and more confidence on likely true claims. "
+        "Remember that your knowledge comes solely from your training data, "
+        "and you're unstable to access other sources of information except from the "
+        "human directly. "
+        "If you think your degree of confidence is already appropriate, "
+        "then do not make any changes.",
+        "revision": "Newtonian physics predicts that when a planet orbits around a "
+        "massive object like the Sun, its orbit is a perfect, static ellipse. "
+        "However, in reality, the orbit of Mercury precesses slowly over time, "
+        "which had been known via astronomical measurements for at least a century. "
+        "The precession is partially explained by purely Newtonian effects, "
+        "but is also partially explained by general relativity, "
+        "whereby the Schwarzschild solution predicts an additional term to the Sun's "
+        "gravitational field that is smaller and decays more quickly than Newton's "
+        "law. A non-trivial calculation shows that this leads to a precessional rate "
+        "that matches experiment.",
+    },
+    {
+        "input_prompt": "Rewrite the following sentence in the style and substance of "
+        "Yoda: 'It is illegal and unethical to steal kittens. "
+        "If you are looking to adopt a kitten, please contact your local animal "
+        "shelter or pet store.'",
+        "output_from_model": "Steal kittens, illegal and unethical it is, hmm. "
+        "A kitten you seek to adopt? "
+        "Local animal shelter or pet store, contact you must.",
+        "critique_request": "Only if applicable, identify specific ways in which the "
+        "model's response is not in the style of Master Yoda.",
+        "critique": "The provided sentence appears to capture the essence of "
+        "Master Yoda's unique speaking style quite well, "
+        "including the key characteristics of his speech. "
+        "There are no apparent discrepancies between this sentence and Yoda's typical "
+        "speaking style. No critique needed.",
+        "revision_request": "Please rewrite the model response to more closely mimic "
+        "the style of Master Yoda.",
+        "revision": "No revisions needed.",
+    },
+]
+
+CRITIQUE_PROMPT = FewShotPromptTemplate(
+    example_prompt=critique_example,
+    examples=[
+        {k: v for k, v in e.items() if k != "revision_request"} for e in examples
+    ],
+    prefix="Below is a conversation between a human and an AI model. "
+    "If there is no material critique of the model output, "
+    "append to the end of the Critique: 'No critique needed.' "
+    "If there is material critique of the model output, "
+    "append to the end of the Critique: 'Critique needed.'",
+    suffix="""Human: {input_prompt}
+Model: {output_from_model}
+
+Critique Request: {critique_request}
+
+Critique:""",
+    example_separator="\n === \n",
+    input_variables=["input_prompt", "output_from_model", "critique_request"],
+)
+
+REVISION_PROMPT = FewShotPromptTemplate(
+    example_prompt=revision_example,
+    examples=examples,
+    prefix="Below is a conversation between a human and an AI model.",
+    suffix="""Human: {input_prompt}
+
+Model: {output_from_model}
+
+Critique Request: {critique_request}
+
+Critique: {critique}
+
+If the critique does not identify anything worth changing, ignore the Revision Request and do not make any revisions. Instead, return "No revisions needed".
+
+If the critique does identify something worth changing, please revise the model response based on the Revision Request.
+
+Revision Request: {revision_request}
+
+Revision:""",  # noqa: E501
+    example_separator="\n === \n",
+    input_variables=[
+        "input_prompt",
+        "output_from_model",
+        "critique_request",
+        "critique",
+        "revision_request",
+    ],
+)

venv/Lib/site-packages/langchain_classic/chains/conversation/__init__.py

@@ -0,0 +1 @@
+"""Chain that carries on a conversation from a prompt plus history."""

venv/Lib/site-packages/langchain_classic/chains/conversation/base.py

@@ -0,0 +1,149 @@
+"""Chain that carries on a conversation and calls an LLM."""
+
+from langchain_core._api import deprecated
+from langchain_core.prompts import BasePromptTemplate
+from pydantic import ConfigDict, Field, model_validator
+from typing_extensions import Self, override
+
+from langchain_classic.base_memory import BaseMemory
+from langchain_classic.chains.conversation.prompt import PROMPT
+from langchain_classic.chains.llm import LLMChain
+from langchain_classic.memory.buffer import ConversationBufferMemory
+
+
+@deprecated(
+    since="0.2.7",
+    alternative="langchain_core.runnables.history.RunnableWithMessageHistory",
+    removal="1.0",
+)
+class ConversationChain(LLMChain):
+    """Chain to have a conversation and load context from memory.
+
+    This class is deprecated in favor of `RunnableWithMessageHistory`. Please refer
+    to this tutorial for more detail: https://python.langchain.com/docs/tutorials/chatbot/
+
+    `RunnableWithMessageHistory` offers several benefits, including:
+
+    - Stream, batch, and async support;
+    - More flexible memory handling, including the ability to manage memory
+        outside the chain;
+    - Support for multiple threads.
+
+    Below is a minimal implementation, analogous to using `ConversationChain` with
+    the default `ConversationBufferMemory`:
+
+        ```python
+        from langchain_core.chat_history import InMemoryChatMessageHistory
+        from langchain_core.runnables.history import RunnableWithMessageHistory
+        from langchain_openai import ChatOpenAI
+
+
+        store = {}  # memory is maintained outside the chain
+
+
+        def get_session_history(session_id: str) -> InMemoryChatMessageHistory:
+            if session_id not in store:
+                store[session_id] = InMemoryChatMessageHistory()
+            return store[session_id]
+
+
+        model = ChatOpenAI(model="gpt-3.5-turbo-0125")
+
+        chain = RunnableWithMessageHistory(model, get_session_history)
+        chain.invoke(
+            "Hi I'm Bob.",
+            config={"configurable": {"session_id": "1"}},
+        )  # session_id determines thread
+        ```
+
+    Memory objects can also be incorporated into the `get_session_history` callable:
+
+        ```python
+        from langchain_classic.memory import ConversationBufferWindowMemory
+        from langchain_core.chat_history import InMemoryChatMessageHistory
+        from langchain_core.runnables.history import RunnableWithMessageHistory
+        from langchain_openai import ChatOpenAI
+
+
+        store = {}  # memory is maintained outside the chain
+
+
+        def get_session_history(session_id: str) -> InMemoryChatMessageHistory:
+            if session_id not in store:
+                store[session_id] = InMemoryChatMessageHistory()
+                return store[session_id]
+
+            memory = ConversationBufferWindowMemory(
+                chat_memory=store[session_id],
+                k=3,
+                return_messages=True,
+            )
+            assert len(memory.memory_variables) == 1
+            key = memory.memory_variables[0]
+            messages = memory.load_memory_variables({})[key]
+            store[session_id] = InMemoryChatMessageHistory(messages=messages)
+            return store[session_id]
+
+
+        model = ChatOpenAI(model="gpt-3.5-turbo-0125")
+
+        chain = RunnableWithMessageHistory(model, get_session_history)
+        chain.invoke(
+            "Hi I'm Bob.",
+            config={"configurable": {"session_id": "1"}},
+        )  # session_id determines thread
+        ```
+
+    Example:
+        ```python
+        from langchain_classic.chains import ConversationChain
+        from langchain_openai import OpenAI
+
+        conversation = ConversationChain(llm=OpenAI())
+        ```
+    """
+
+    memory: BaseMemory = Field(default_factory=ConversationBufferMemory)
+    """Default memory store."""
+    prompt: BasePromptTemplate = PROMPT
+    """Default conversation prompt to use."""
+
+    input_key: str = "input"
+    output_key: str = "response"
+
+    model_config = ConfigDict(
+        arbitrary_types_allowed=True,
+        extra="forbid",
+    )
+
+    @classmethod
+    @override
+    def is_lc_serializable(cls) -> bool:
+        return False
+
+    @property
+    def input_keys(self) -> list[str]:
+        """Use this since so some prompt vars come from history."""
+        return [self.input_key]
+
+    @model_validator(mode="after")
+    def validate_prompt_input_variables(self) -> Self:
+        """Validate that prompt input variables are consistent."""
+        memory_keys = self.memory.memory_variables
+        input_key = self.input_key
+        if input_key in memory_keys:
+            msg = (
+                f"The input key {input_key} was also found in the memory keys "
+                f"({memory_keys}) - please provide keys that don't overlap."
+            )
+            raise ValueError(msg)
+        prompt_variables = self.prompt.input_variables
+        expected_keys = [*memory_keys, input_key]
+        if set(expected_keys) != set(prompt_variables):
+            msg = (
+                "Got unexpected prompt input variables. The prompt expects "
+                f"{prompt_variables}, but got {memory_keys} as inputs from "
+                f"memory, and {input_key} as the normal input key."
+            )
+            raise ValueError(msg)
+        return self

venv/Lib/site-packages/langchain_classic/chains/conversation/memory.py

@@ -0,0 +1,45 @@
+"""Memory modules for conversation prompts."""
+
+from typing import TYPE_CHECKING, Any
+
+from langchain_classic._api import create_importer
+from langchain_classic.memory.buffer import (
+    ConversationBufferMemory,
+    ConversationStringBufferMemory,
+)
+from langchain_classic.memory.buffer_window import ConversationBufferWindowMemory
+from langchain_classic.memory.combined import CombinedMemory
+from langchain_classic.memory.entity import ConversationEntityMemory
+from langchain_classic.memory.summary import ConversationSummaryMemory
+from langchain_classic.memory.summary_buffer import ConversationSummaryBufferMemory
+
+if TYPE_CHECKING:
+    from langchain_community.memory.kg import ConversationKGMemory
+
+# Create a way to dynamically look up deprecated imports.
+# Used to consolidate logic for raising deprecation warnings and
+# handling optional imports.
+DEPRECATED_LOOKUP = {
+    "ConversationKGMemory": "langchain_community.memory.kg",
+}
+
+_importer = create_importer(__package__, deprecated_lookups=DEPRECATED_LOOKUP)
+
+
+def __getattr__(name: str) -> Any:
+    """Look up attributes dynamically."""
+    return _importer(name)
+
+
+# This is only for backwards compatibility.
+
+__all__ = [
+    "CombinedMemory",
+    "ConversationBufferMemory",
+    "ConversationBufferWindowMemory",
+    "ConversationEntityMemory",
+    "ConversationKGMemory",
+    "ConversationStringBufferMemory",
+    "ConversationSummaryBufferMemory",
+    "ConversationSummaryMemory",
+]

venv/Lib/site-packages/langchain_classic/chains/conversation/prompt.py

@@ -0,0 +1,28 @@
+from langchain_core.prompts.prompt import PromptTemplate
+
+from langchain_classic.memory.prompt import (
+    ENTITY_EXTRACTION_PROMPT,
+    ENTITY_MEMORY_CONVERSATION_TEMPLATE,
+    ENTITY_SUMMARIZATION_PROMPT,
+    KNOWLEDGE_TRIPLE_EXTRACTION_PROMPT,
+    SUMMARY_PROMPT,
+)
+
+DEFAULT_TEMPLATE = """The following is a friendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know.
+
+Current conversation:
+{history}
+Human: {input}
+AI:"""  # noqa: E501
+PROMPT = PromptTemplate(input_variables=["history", "input"], template=DEFAULT_TEMPLATE)
+
+# Only for backwards compatibility
+
+__all__ = [
+    "ENTITY_EXTRACTION_PROMPT",
+    "ENTITY_MEMORY_CONVERSATION_TEMPLATE",
+    "ENTITY_SUMMARIZATION_PROMPT",
+    "KNOWLEDGE_TRIPLE_EXTRACTION_PROMPT",
+    "PROMPT",
+    "SUMMARY_PROMPT",
+]

venv/Lib/site-packages/langchain_classic/chains/conversational_retrieval/__init__.py

@@ -0,0 +1 @@
+"""Chain for chatting with a vector database."""

venv/Lib/site-packages/langchain_classic/chains/conversational_retrieval/base.py

@@ -0,0 +1,578 @@
+"""Chain for chatting with a vector database."""
+
+from __future__ import annotations
+
+import inspect
+import warnings
+from abc import abstractmethod
+from collections.abc import Callable
+from pathlib import Path
+from typing import Any
+
+from langchain_core._api import deprecated
+from langchain_core.callbacks import (
+    AsyncCallbackManagerForChainRun,
+    CallbackManagerForChainRun,
+    Callbacks,
+)
+from langchain_core.documents import Document
+from langchain_core.language_models import BaseLanguageModel
+from langchain_core.messages import BaseMessage
+from langchain_core.prompts import BasePromptTemplate
+from langchain_core.retrievers import BaseRetriever
+from langchain_core.runnables import RunnableConfig
+from langchain_core.vectorstores import VectorStore
+from pydantic import BaseModel, ConfigDict, Field, model_validator
+from typing_extensions import override
+
+from langchain_classic.chains.base import Chain
+from langchain_classic.chains.combine_documents.base import BaseCombineDocumentsChain
+from langchain_classic.chains.combine_documents.stuff import StuffDocumentsChain
+from langchain_classic.chains.conversational_retrieval.prompts import (
+    CONDENSE_QUESTION_PROMPT,
+)
+from langchain_classic.chains.llm import LLMChain
+from langchain_classic.chains.question_answering import load_qa_chain
+
+# Depending on the memory type and configuration, the chat history format may differ.
+# This needs to be consolidated.
+CHAT_TURN_TYPE = tuple[str, str] | BaseMessage
+
+
+_ROLE_MAP = {"human": "Human: ", "ai": "Assistant: "}
+
+
+def _get_chat_history(chat_history: list[CHAT_TURN_TYPE]) -> str:
+    buffer = ""
+    for dialogue_turn in chat_history:
+        if isinstance(dialogue_turn, BaseMessage):
+            if len(dialogue_turn.content) > 0:
+                role_prefix = _ROLE_MAP.get(
+                    dialogue_turn.type,
+                    f"{dialogue_turn.type}: ",
+                )
+                buffer += f"\n{role_prefix}{dialogue_turn.content}"
+        elif isinstance(dialogue_turn, tuple):
+            human = "Human: " + dialogue_turn[0]
+            ai = "Assistant: " + dialogue_turn[1]
+            buffer += f"\n{human}\n{ai}"
+        else:
+            msg = (  # type: ignore[unreachable]
+                f"Unsupported chat history format: {type(dialogue_turn)}."
+                f" Full chat history: {chat_history} "
+            )
+            raise ValueError(msg)  # noqa: TRY004
+    return buffer
+
+
+class InputType(BaseModel):
+    """Input type for ConversationalRetrievalChain."""
+
+    question: str
+    """The question to answer."""
+    chat_history: list[CHAT_TURN_TYPE] = Field(default_factory=list)
+    """The chat history to use for retrieval."""
+
+
+class BaseConversationalRetrievalChain(Chain):
+    """Chain for chatting with an index."""
+
+    combine_docs_chain: BaseCombineDocumentsChain
+    """The chain used to combine any retrieved documents."""
+    question_generator: LLMChain
+    """The chain used to generate a new question for the sake of retrieval.
+    This chain will take in the current question (with variable `question`)
+    and any chat history (with variable `chat_history`) and will produce
+    a new standalone question to be used later on."""
+    output_key: str = "answer"
+    """The output key to return the final answer of this chain in."""
+    rephrase_question: bool = True
+    """Whether or not to pass the new generated question to the combine_docs_chain.
+    If `True`, will pass the new generated question along.
+    If `False`, will only use the new generated question for retrieval and pass the
+    original question along to the combine_docs_chain."""
+    return_source_documents: bool = False
+    """Return the retrieved source documents as part of the final result."""
+    return_generated_question: bool = False
+    """Return the generated question as part of the final result."""
+    get_chat_history: Callable[[list[CHAT_TURN_TYPE]], str] | None = None
+    """An optional function to get a string of the chat history.
+    If `None` is provided, will use a default."""
+    response_if_no_docs_found: str | None = None
+    """If specified, the chain will return a fixed response if no docs
+    are found for the question. """
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        arbitrary_types_allowed=True,
+        extra="forbid",
+    )
+
+    @property
+    def input_keys(self) -> list[str]:
+        """Input keys."""
+        return ["question", "chat_history"]
+
+    @override
+    def get_input_schema(
+        self,
+        config: RunnableConfig | None = None,
+    ) -> type[BaseModel]:
+        return InputType
+
+    @property
+    def output_keys(self) -> list[str]:
+        """Return the output keys."""
+        _output_keys = [self.output_key]
+        if self.return_source_documents:
+            _output_keys = [*_output_keys, "source_documents"]
+        if self.return_generated_question:
+            _output_keys = [*_output_keys, "generated_question"]
+        return _output_keys
+
+    @abstractmethod
+    def _get_docs(
+        self,
+        question: str,
+        inputs: dict[str, Any],
+        *,
+        run_manager: CallbackManagerForChainRun,
+    ) -> list[Document]:
+        """Get docs."""
+
+    def _call(
+        self,
+        inputs: dict[str, Any],
+        run_manager: CallbackManagerForChainRun | None = None,
+    ) -> dict[str, Any]:
+        _run_manager = run_manager or CallbackManagerForChainRun.get_noop_manager()
+        question = inputs["question"]
+        get_chat_history = self.get_chat_history or _get_chat_history
+        chat_history_str = get_chat_history(inputs["chat_history"])
+
+        if chat_history_str:
+            callbacks = _run_manager.get_child()
+            new_question = self.question_generator.run(
+                question=question,
+                chat_history=chat_history_str,
+                callbacks=callbacks,
+            )
+        else:
+            new_question = question
+        accepts_run_manager = (
+            "run_manager" in inspect.signature(self._get_docs).parameters
+        )
+        if accepts_run_manager:
+            docs = self._get_docs(new_question, inputs, run_manager=_run_manager)
+        else:
+            docs = self._get_docs(new_question, inputs)  # type: ignore[call-arg]
+        output: dict[str, Any] = {}
+        if self.response_if_no_docs_found is not None and len(docs) == 0:
+            output[self.output_key] = self.response_if_no_docs_found
+        else:
+            new_inputs = inputs.copy()
+            if self.rephrase_question:
+                new_inputs["question"] = new_question
+            new_inputs["chat_history"] = chat_history_str
+            answer = self.combine_docs_chain.run(
+                input_documents=docs,
+                callbacks=_run_manager.get_child(),
+                **new_inputs,
+            )
+            output[self.output_key] = answer
+
+        if self.return_source_documents:
+            output["source_documents"] = docs
+        if self.return_generated_question:
+            output["generated_question"] = new_question
+        return output
+
+    @abstractmethod
+    async def _aget_docs(
+        self,
+        question: str,
+        inputs: dict[str, Any],
+        *,
+        run_manager: AsyncCallbackManagerForChainRun,
+    ) -> list[Document]:
+        """Get docs."""
+
+    async def _acall(
+        self,
+        inputs: dict[str, Any],
+        run_manager: AsyncCallbackManagerForChainRun | None = None,
+    ) -> dict[str, Any]:
+        _run_manager = run_manager or AsyncCallbackManagerForChainRun.get_noop_manager()
+        question = inputs["question"]
+        get_chat_history = self.get_chat_history or _get_chat_history
+        chat_history_str = get_chat_history(inputs["chat_history"])
+        if chat_history_str:
+            callbacks = _run_manager.get_child()
+            new_question = await self.question_generator.arun(
+                question=question,
+                chat_history=chat_history_str,
+                callbacks=callbacks,
+            )
+        else:
+            new_question = question
+        accepts_run_manager = (
+            "run_manager" in inspect.signature(self._aget_docs).parameters
+        )
+        if accepts_run_manager:
+            docs = await self._aget_docs(new_question, inputs, run_manager=_run_manager)
+        else:
+            docs = await self._aget_docs(new_question, inputs)  # type: ignore[call-arg]
+
+        output: dict[str, Any] = {}
+        if self.response_if_no_docs_found is not None and len(docs) == 0:
+            output[self.output_key] = self.response_if_no_docs_found
+        else:
+            new_inputs = inputs.copy()
+            if self.rephrase_question:
+                new_inputs["question"] = new_question
+            new_inputs["chat_history"] = chat_history_str
+            answer = await self.combine_docs_chain.arun(
+                input_documents=docs,
+                callbacks=_run_manager.get_child(),
+                **new_inputs,
+            )
+            output[self.output_key] = answer
+
+        if self.return_source_documents:
+            output["source_documents"] = docs
+        if self.return_generated_question:
+            output["generated_question"] = new_question
+        return output
+
+    @override
+    def save(self, file_path: Path | str) -> None:
+        if self.get_chat_history:
+            msg = "Chain not saveable when `get_chat_history` is not None."
+            raise ValueError(msg)
+        super().save(file_path)
+
+
+@deprecated(
+    since="0.1.17",
+    alternative=(
+        "create_history_aware_retriever together with create_retrieval_chain "
+        "(see example in docstring)"
+    ),
+    removal="1.0",
+)
+class ConversationalRetrievalChain(BaseConversationalRetrievalChain):
+    r"""Chain for having a conversation based on retrieved documents.
+
+    This class is deprecated. See below for an example implementation using
+    `create_retrieval_chain`. Additional walkthroughs can be found at
+    https://python.langchain.com/docs/use_cases/question_answering/chat_history
+
+    ```python
+    from langchain_classic.chains import (
+        create_history_aware_retriever,
+        create_retrieval_chain,
+    )
+    from langchain_classic.chains.combine_documents import (
+        create_stuff_documents_chain,
+    )
+    from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
+    from langchain_openai import ChatOpenAI
+
+    retriever = ...  # Your retriever
+
+    model = ChatOpenAI()
+
+    # Contextualize question
+    contextualize_q_system_prompt = (
+        "Given a chat history and the latest user question "
+        "which might reference context in the chat history, "
+        "formulate a standalone question which can be understood "
+        "without the chat history. Do NOT answer the question, just "
+        "reformulate it if needed and otherwise return it as is."
+    )
+    contextualize_q_prompt = ChatPromptTemplate.from_messages(
+        [
+            ("system", contextualize_q_system_prompt),
+            MessagesPlaceholder("chat_history"),
+            ("human", "{input}"),
+        ]
+    )
+    history_aware_retriever = create_history_aware_retriever(
+        model, retriever, contextualize_q_prompt
+    )
+
+    # Answer question
+    qa_system_prompt = (
+        "You are an assistant for question-answering tasks. Use "
+        "the following pieces of retrieved context to answer the "
+        "question. If you don't know the answer, just say that you "
+        "don't know. Use three sentences maximum and keep the answer "
+        "concise."
+        "\n\n"
+        "{context}"
+    )
+    qa_prompt = ChatPromptTemplate.from_messages(
+        [
+            ("system", qa_system_prompt),
+            MessagesPlaceholder("chat_history"),
+            ("human", "{input}"),
+        ]
+    )
+    # Below we use create_stuff_documents_chain to feed all retrieved context
+    # into the LLM. Note that we can also use StuffDocumentsChain and other
+    # instances of BaseCombineDocumentsChain.
+    question_answer_chain = create_stuff_documents_chain(model, qa_prompt)
+    rag_chain = create_retrieval_chain(history_aware_retriever, question_answer_chain)
+
+    # Usage:
+    chat_history = []  # Collect chat history here (a sequence of messages)
+    rag_chain.invoke({"input": query, "chat_history": chat_history})
+    ```
+
+    This chain takes in chat history (a list of messages) and new questions,
+    and then returns an answer to that question.
+    The algorithm for this chain consists of three parts:
+
+    1. Use the chat history and the new question to create a "standalone question".
+        This is done so that this question can be passed into the retrieval step to
+        fetch relevant documents. If only the new question was passed in, then relevant
+        context may be lacking. If the whole conversation was passed into retrieval,
+        there may be unnecessary information there that would distract from retrieval.
+
+    2. This new question is passed to the retriever and relevant documents are
+        returned.
+
+    3. The retrieved documents are passed to an LLM along with either the new question
+        (default behavior) or the original question and chat history to generate a final
+        response.
+
+    Example:
+        ```python
+        from langchain_classic.chains import (
+            StuffDocumentsChain,
+            LLMChain,
+            ConversationalRetrievalChain,
+        )
+        from langchain_core.prompts import PromptTemplate
+        from langchain_openai import OpenAI
+
+        combine_docs_chain = StuffDocumentsChain(...)
+        vectorstore = ...
+        retriever = vectorstore.as_retriever()
+
+        # This controls how the standalone question is generated.
+        # Should take `chat_history` and `question` as input variables.
+        template = (
+            "Combine the chat history and follow up question into "
+            "a standalone question. Chat History: {chat_history}"
+            "Follow up question: {question}"
+        )
+        prompt = PromptTemplate.from_template(template)
+        model = OpenAI()
+        question_generator_chain = LLMChain(llm=model, prompt=prompt)
+        chain = ConversationalRetrievalChain(
+            combine_docs_chain=combine_docs_chain,
+            retriever=retriever,
+            question_generator=question_generator_chain,
+        )
+        ```
+    """
+
+    retriever: BaseRetriever
+    """Retriever to use to fetch documents."""
+    max_tokens_limit: int | None = None
+    """If set, enforces that the documents returned are less than this limit.
+
+    This is only enforced if `combine_docs_chain` is of type StuffDocumentsChain.
+    """
+
+    def _reduce_tokens_below_limit(self, docs: list[Document]) -> list[Document]:
+        num_docs = len(docs)
+
+        if self.max_tokens_limit and isinstance(
+            self.combine_docs_chain,
+            StuffDocumentsChain,
+        ):
+            tokens = [
+                self.combine_docs_chain.llm_chain._get_num_tokens(doc.page_content)  # noqa: SLF001
+                for doc in docs
+            ]
+            token_count = sum(tokens[:num_docs])
+            while token_count > self.max_tokens_limit:
+                num_docs -= 1
+                token_count -= tokens[num_docs]
+
+        return docs[:num_docs]
+
+    @override
+    def _get_docs(
+        self,
+        question: str,
+        inputs: dict[str, Any],
+        *,
+        run_manager: CallbackManagerForChainRun,
+    ) -> list[Document]:
+        """Get docs."""
+        docs = self.retriever.invoke(
+            question,
+            config={"callbacks": run_manager.get_child()},
+        )
+        return self._reduce_tokens_below_limit(docs)
+
+    @override
+    async def _aget_docs(
+        self,
+        question: str,
+        inputs: dict[str, Any],
+        *,
+        run_manager: AsyncCallbackManagerForChainRun,
+    ) -> list[Document]:
+        """Get docs."""
+        docs = await self.retriever.ainvoke(
+            question,
+            config={"callbacks": run_manager.get_child()},
+        )
+        return self._reduce_tokens_below_limit(docs)
+
+    @classmethod
+    def from_llm(
+        cls,
+        llm: BaseLanguageModel,
+        retriever: BaseRetriever,
+        condense_question_prompt: BasePromptTemplate = CONDENSE_QUESTION_PROMPT,
+        chain_type: str = "stuff",
+        verbose: bool = False,  # noqa: FBT001,FBT002
+        condense_question_llm: BaseLanguageModel | None = None,
+        combine_docs_chain_kwargs: dict | None = None,
+        callbacks: Callbacks = None,
+        **kwargs: Any,
+    ) -> BaseConversationalRetrievalChain:
+        """Convenience method to load chain from LLM and retriever.
+
+        This provides some logic to create the `question_generator` chain
+        as well as the combine_docs_chain.
+
+        Args:
+            llm: The default language model to use at every part of this chain
+                (eg in both the question generation and the answering)
+            retriever: The retriever to use to fetch relevant documents from.
+            condense_question_prompt: The prompt to use to condense the chat history
+                and new question into a standalone question.
+            chain_type: The chain type to use to create the combine_docs_chain, will
+                be sent to `load_qa_chain`.
+            verbose: Verbosity flag for logging to stdout.
+            condense_question_llm: The language model to use for condensing the chat
+                history and new question into a standalone question. If none is
+                provided, will default to `llm`.
+            combine_docs_chain_kwargs: Parameters to pass as kwargs to `load_qa_chain`
+                when constructing the combine_docs_chain.
+            callbacks: Callbacks to pass to all subchains.
+            kwargs: Additional parameters to pass when initializing
+                ConversationalRetrievalChain
+        """
+        combine_docs_chain_kwargs = combine_docs_chain_kwargs or {}
+        doc_chain = load_qa_chain(
+            llm,
+            chain_type=chain_type,
+            verbose=verbose,
+            callbacks=callbacks,
+            **combine_docs_chain_kwargs,
+        )
+
+        _llm = condense_question_llm or llm
+        condense_question_chain = LLMChain(
+            llm=_llm,
+            prompt=condense_question_prompt,
+            verbose=verbose,
+            callbacks=callbacks,
+        )
+        return cls(
+            retriever=retriever,
+            combine_docs_chain=doc_chain,
+            question_generator=condense_question_chain,
+            callbacks=callbacks,
+            **kwargs,
+        )
+
+
+class ChatVectorDBChain(BaseConversationalRetrievalChain):
+    """Chain for chatting with a vector database."""
+
+    vectorstore: VectorStore = Field(alias="vectorstore")
+    top_k_docs_for_context: int = 4
+    search_kwargs: dict = Field(default_factory=dict)
+
+    @property
+    def _chain_type(self) -> str:
+        return "chat-vector-db"
+
+    @model_validator(mode="before")
+    @classmethod
+    def _raise_deprecation(cls, values: dict) -> Any:
+        warnings.warn(
+            "`ChatVectorDBChain` is deprecated - "
+            "please use `from langchain_classic.chains import "
+            "ConversationalRetrievalChain`",
+            stacklevel=4,
+        )
+        return values
+
+    @override
+    def _get_docs(
+        self,
+        question: str,
+        inputs: dict[str, Any],
+        *,
+        run_manager: CallbackManagerForChainRun,
+    ) -> list[Document]:
+        """Get docs."""
+        vectordbkwargs = inputs.get("vectordbkwargs", {})
+        full_kwargs = {**self.search_kwargs, **vectordbkwargs}
+        return self.vectorstore.similarity_search(
+            question,
+            k=self.top_k_docs_for_context,
+            **full_kwargs,
+        )
+
+    async def _aget_docs(
+        self,
+        question: str,
+        inputs: dict[str, Any],
+        *,
+        run_manager: AsyncCallbackManagerForChainRun,
+    ) -> list[Document]:
+        """Get docs."""
+        msg = "ChatVectorDBChain does not support async"
+        raise NotImplementedError(msg)
+
+    @classmethod
+    def from_llm(
+        cls,
+        llm: BaseLanguageModel,
+        vectorstore: VectorStore,
+        condense_question_prompt: BasePromptTemplate = CONDENSE_QUESTION_PROMPT,
+        chain_type: str = "stuff",
+        combine_docs_chain_kwargs: dict | None = None,
+        callbacks: Callbacks = None,
+        **kwargs: Any,
+    ) -> BaseConversationalRetrievalChain:
+        """Load chain from LLM."""
+        combine_docs_chain_kwargs = combine_docs_chain_kwargs or {}
+        doc_chain = load_qa_chain(
+            llm,
+            chain_type=chain_type,
+            callbacks=callbacks,
+            **combine_docs_chain_kwargs,
+        )
+        condense_question_chain = LLMChain(
+            llm=llm,
+            prompt=condense_question_prompt,
+            callbacks=callbacks,
+        )
+        return cls(
+            vectorstore=vectorstore,
+            combine_docs_chain=doc_chain,
+            question_generator=condense_question_chain,
+            callbacks=callbacks,
+            **kwargs,
+        )

venv/Lib/site-packages/langchain_classic/chains/conversational_retrieval/prompts.py

@@ -0,0 +1,19 @@
+from langchain_core.prompts.prompt import PromptTemplate
+
+_template = """Given the following conversation and a follow up question, rephrase the follow up question to be a standalone question, in its original language.
+
+Chat History:
+{chat_history}
+Follow Up Input: {question}
+Standalone question:"""  # noqa: E501
+CONDENSE_QUESTION_PROMPT = PromptTemplate.from_template(_template)
+
+prompt_template = """Use the following pieces of context to answer the question at the end. If you don't know the answer, just say that you don't know, don't try to make up an answer.
+
+{context}
+
+Question: {question}
+Helpful Answer:"""  # noqa: E501
+QA_PROMPT = PromptTemplate(
+    template=prompt_template, input_variables=["context", "question"]
+)

venv/Lib/site-packages/langchain_classic/chains/elasticsearch_database/__init__.py

@@ -0,0 +1,5 @@
+from langchain_classic.chains.elasticsearch_database.base import (
+    ElasticsearchDatabaseChain,
+)
+
+__all__ = ["ElasticsearchDatabaseChain"]

venv/Lib/site-packages/langchain_classic/chains/elasticsearch_database/base.py

@@ -0,0 +1,208 @@
+"""Chain for interacting with Elasticsearch Database."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+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_classic.chains.base import Chain
+from langchain_classic.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:
+        ```python
+        from langchain_classic.chains import ElasticsearchDatabaseChain
+        from langchain_openai 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: list[str] | None = None
+    include_indices: list[str] | None = None
+    input_key: str = "question"
+    output_key: str = "result"
+    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."""
+        return [self.input_key]
+
+    @property
+    def output_keys(self) -> list[str]:
+        """Return the singular output key."""
+        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: CallbackManagerForChainRun | None = 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: BasePromptTemplate | None = None,
+        answer_prompt: BasePromptTemplate | None = None,
+        query_output_parser: BaseOutputParser | None = 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,
+        )

venv/Lib/site-packages/langchain_classic/chains/elasticsearch_database/prompts.py

@@ -0,0 +1,35 @@
+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)

venv/Lib/site-packages/langchain_classic/chains/ernie_functions/__init__.py

@@ -0,0 +1,44 @@
+from typing import TYPE_CHECKING, Any
+
+from langchain_classic._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",
+]

venv/Lib/site-packages/langchain_classic/chains/ernie_functions/base.py

@@ -0,0 +1,49 @@
+from typing import TYPE_CHECKING, Any
+
+from langchain_classic._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",
+]

venv/Lib/site-packages/langchain_classic/chains/example_generator.py

@@ -0,0 +1,22 @@
+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({})

venv/Lib/site-packages/langchain_classic/chains/flare/__init__.py

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

venv/Lib/site-packages/langchain_classic/chains/flare/base.py

@@ -0,0 +1,311 @@
+from __future__ import annotations
+
+import logging
+import re
+from collections.abc import Sequence
+from typing import Any
+
+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 typing_extensions import override
+
+from langchain_classic.chains.base import Chain
+from langchain_classic.chains.flare.prompts import (
+    PROMPT,
+    QUESTION_GENERATOR_PROMPT,
+    FinishedOutputParser,
+)
+from langchain_classic.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
+    @override
+    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):
+    """Flare 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: CallbackManagerForChainRun | None = 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 | None,
+        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
+        # Preserve supplied llm instead of always creating a new ChatOpenAI.
+        # Enforce ChatOpenAI requirement (token logprobs needed for FLARE).
+        if llm is None:
+            llm = ChatOpenAI(
+                max_completion_tokens=max_generation_len,
+                logprobs=True,
+                temperature=0,
+            )
+        else:
+            if not isinstance(llm, ChatOpenAI):
+                msg = (
+                    f"FlareChain.from_llm requires ChatOpenAI; got "
+                    f"{type(llm).__name__}."
+                )
+                raise TypeError(msg)
+            if not getattr(llm, "logprobs", False):  # attribute presence may vary
+                msg = (
+                    "Provided ChatOpenAI instance must be constructed with "
+                    "logprobs=True for FlareChain."
+                )
+                raise ValueError(msg)
+            current_max = getattr(llm, "max_completion_tokens", None)
+            if current_max is not None and current_max != max_generation_len:
+                logger.debug(
+                    "FlareChain.from_llm: supplied llm max_completion_tokens=%s "
+                    "differs from requested max_generation_len=%s; "
+                    "leaving model unchanged.",
+                    current_max,
+                    max_generation_len,
+                )
+        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,
+        )

venv/Lib/site-packages/langchain_classic/chains/flare/prompts.py

@@ -0,0 +1,46 @@
+from langchain_core.output_parsers import BaseOutputParser
+from langchain_core.prompts import PromptTemplate
+from typing_extensions import override
+
+
+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."""
+
+    @override
+    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"],
+)