langchain 0.4.0.dev0__py3-none-any.whl → 1.0.0a2__py3-none-any.whl

langchain/chains/router/llm_router.py

@@ -1,198 +0,0 @@
-"""Base classes for LLM-powered router chains."""
-
-from __future__ import annotations
-
-from typing import Any, Optional, cast
-
-from langchain_core._api import deprecated
-from langchain_core.callbacks import (
-    AsyncCallbackManagerForChainRun,
-    CallbackManagerForChainRun,
-)
-from langchain_core.exceptions import OutputParserException
-from langchain_core.language_models import BaseLanguageModel
-from langchain_core.output_parsers import BaseOutputParser
-from langchain_core.prompts import BasePromptTemplate
-from langchain_core.utils.json import parse_and_check_json_markdown
-from pydantic import model_validator
-from typing_extensions import Self, override
-
-from langchain.chains import LLMChain
-from langchain.chains.router.base import RouterChain
-
-
-@deprecated(
-    since="0.2.12",
-    removal="1.0",
-    message=(
-        "Use RunnableLambda to select from multiple prompt templates. See example "
-        "in API reference: "
-        "https://api.python.langchain.com/en/latest/chains/langchain.chains.router.llm_router.LLMRouterChain.html"
-    ),
-)
-class LLMRouterChain(RouterChain):
-    """A router chain that uses an LLM chain to perform routing.
-
-    This class is deprecated. See below for a replacement, which offers several
-    benefits, including streaming and batch support.
-
-    Below is an example implementation:
-
-        .. code-block:: python
-
-            from operator import itemgetter
-            from typing import Literal
-            from typing_extensions import TypedDict
-
-            from langchain_core.output_parsers import StrOutputParser
-            from langchain_core.prompts import ChatPromptTemplate
-            from langchain_core.runnables import RunnableLambda, RunnablePassthrough
-            from langchain_openai import ChatOpenAI
-
-            llm = ChatOpenAI(model="gpt-4o-mini")
-
-            prompt_1 = ChatPromptTemplate.from_messages(
-                [
-                    ("system", "You are an expert on animals."),
-                    ("human", "{query}"),
-                ]
-            )
-            prompt_2 = ChatPromptTemplate.from_messages(
-                [
-                    ("system", "You are an expert on vegetables."),
-                    ("human", "{query}"),
-                ]
-            )
-
-            chain_1 = prompt_1 | llm | StrOutputParser()
-            chain_2 = prompt_2 | llm | StrOutputParser()
-
-            route_system = "Route the user's query to either the animal or vegetable expert."
-            route_prompt = ChatPromptTemplate.from_messages(
-                [
-                    ("system", route_system),
-                    ("human", "{query}"),
-                ]
-            )
-
-
-            class RouteQuery(TypedDict):
-                \"\"\"Route query to destination.\"\"\"
-                destination: Literal["animal", "vegetable"]
-
-
-            route_chain = (
-                route_prompt
-                | llm.with_structured_output(RouteQuery)
-                | itemgetter("destination")
-            )
-
-            chain = {
-                "destination": route_chain,  # "animal" or "vegetable"
-                "query": lambda x: x["query"],  # pass through input query
-            } | RunnableLambda(
-                # if animal, chain_1. otherwise, chain_2.
-                lambda x: chain_1 if x["destination"] == "animal" else chain_2,
-            )
-
-            chain.invoke({"query": "what color are carrots"})
-
-    """  # noqa: E501
-
-    llm_chain: LLMChain
-    """LLM chain used to perform routing"""
-
-    @model_validator(mode="after")
-    def _validate_prompt(self) -> Self:
-        prompt = self.llm_chain.prompt
-        if prompt.output_parser is None:
-            msg = (
-                "LLMRouterChain requires base llm_chain prompt to have an output"
-                " parser that converts LLM text output to a dictionary with keys"
-                " 'destination' and 'next_inputs'. Received a prompt with no output"
-                " parser."
-            )
-            raise ValueError(msg)
-        return self
-
-    @property
-    def input_keys(self) -> list[str]:
-        """Will be whatever keys the LLM chain prompt expects.
-
-        :meta private:
-        """
-        return self.llm_chain.input_keys
-
-    def _validate_outputs(self, outputs: dict[str, Any]) -> None:
-        super()._validate_outputs(outputs)
-        if not isinstance(outputs["next_inputs"], dict):
-            raise ValueError  # noqa: TRY004
-
-    def _call(
-        self,
-        inputs: dict[str, Any],
-        run_manager: Optional[CallbackManagerForChainRun] = None,
-    ) -> dict[str, Any]:
-        _run_manager = run_manager or CallbackManagerForChainRun.get_noop_manager()
-        callbacks = _run_manager.get_child()
-
-        prediction = self.llm_chain.predict(callbacks=callbacks, **inputs)
-        return cast(
-            "dict[str, Any]",
-            self.llm_chain.prompt.output_parser.parse(prediction),
-        )
-
-    async def _acall(
-        self,
-        inputs: dict[str, Any],
-        run_manager: Optional[AsyncCallbackManagerForChainRun] = None,
-    ) -> dict[str, Any]:
-        _run_manager = run_manager or CallbackManagerForChainRun.get_noop_manager()
-        callbacks = _run_manager.get_child()
-        return cast(
-            "dict[str, Any]",
-            await self.llm_chain.apredict_and_parse(callbacks=callbacks, **inputs),
-        )
-
-    @classmethod
-    def from_llm(
-        cls,
-        llm: BaseLanguageModel,
-        prompt: BasePromptTemplate,
-        **kwargs: Any,
-    ) -> LLMRouterChain:
-        """Convenience constructor."""
-        llm_chain = LLMChain(llm=llm, prompt=prompt)
-        return cls(llm_chain=llm_chain, **kwargs)
-
-
-class RouterOutputParser(BaseOutputParser[dict[str, str]]):
-    """Parser for output of router chain in the multi-prompt chain."""
-
-    default_destination: str = "DEFAULT"
-    next_inputs_type: type = str
-    next_inputs_inner_key: str = "input"
-
-    @override
-    def parse(self, text: str) -> dict[str, Any]:
-        try:
-            expected_keys = ["destination", "next_inputs"]
-            parsed = parse_and_check_json_markdown(text, expected_keys)
-            if not isinstance(parsed["destination"], str):
-                msg = "Expected 'destination' to be a string."
-                raise TypeError(msg)
-            if not isinstance(parsed["next_inputs"], self.next_inputs_type):
-                msg = f"Expected 'next_inputs' to be {self.next_inputs_type}."
-                raise TypeError(msg)
-            parsed["next_inputs"] = {self.next_inputs_inner_key: parsed["next_inputs"]}
-            if (
-                parsed["destination"].strip().lower()
-                == self.default_destination.lower()
-            ):
-                parsed["destination"] = None
-            else:
-                parsed["destination"] = parsed["destination"].strip()
-        except Exception as e:
-            msg = f"Parsing text\n{text}\n raised following error:\n{e}"
-            raise OutputParserException(msg) from e
-        return parsed

langchain/chains/router/multi_prompt.py

@@ -1,184 +0,0 @@
-"""Use a single chain to route an input to one of multiple llm chains."""
-
-from __future__ import annotations
-
-from typing import Any, Optional
-
-from langchain_core._api import deprecated
-from langchain_core.language_models import BaseLanguageModel
-from langchain_core.prompts import PromptTemplate
-from typing_extensions import override
-
-from langchain.chains import ConversationChain
-from langchain.chains.base import Chain
-from langchain.chains.llm import LLMChain
-from langchain.chains.router.base import MultiRouteChain
-from langchain.chains.router.llm_router import LLMRouterChain, RouterOutputParser
-from langchain.chains.router.multi_prompt_prompt import MULTI_PROMPT_ROUTER_TEMPLATE
-
-
-@deprecated(
-    since="0.2.12",
-    removal="1.0",
-    message=(
-        "Please see migration guide here for recommended implementation: "
-        "https://python.langchain.com/docs/versions/migrating_chains/multi_prompt_chain/"
-    ),
-)
-class MultiPromptChain(MultiRouteChain):
-    """A multi-route chain that uses an LLM router chain to choose amongst prompts.
-
-    This class is deprecated. See below for a replacement, which offers several
-    benefits, including streaming and batch support.
-
-    Below is an example implementation:
-
-        .. code-block:: python
-
-            from operator import itemgetter
-            from typing import Literal
-
-            from langchain_core.output_parsers import StrOutputParser
-            from langchain_core.prompts import ChatPromptTemplate
-            from langchain_core.runnables import RunnableConfig
-            from langchain_openai import ChatOpenAI
-            from langgraph.graph import END, START, StateGraph
-            from typing_extensions import TypedDict
-
-            llm = ChatOpenAI(model="gpt-4o-mini")
-
-            # Define the prompts we will route to
-            prompt_1 = ChatPromptTemplate.from_messages(
-                [
-                    ("system", "You are an expert on animals."),
-                    ("human", "{input}"),
-                ]
-            )
-            prompt_2 = ChatPromptTemplate.from_messages(
-                [
-                    ("system", "You are an expert on vegetables."),
-                    ("human", "{input}"),
-                ]
-            )
-
-            # Construct the chains we will route to. These format the input query
-            # into the respective prompt, run it through a chat model, and cast
-            # the result to a string.
-            chain_1 = prompt_1 | llm | StrOutputParser()
-            chain_2 = prompt_2 | llm | StrOutputParser()
-
-
-            # Next: define the chain that selects which branch to route to.
-            # Here we will take advantage of tool-calling features to force
-            # the output to select one of two desired branches.
-            route_system = "Route the user's query to either the animal or vegetable expert."
-            route_prompt = ChatPromptTemplate.from_messages(
-                [
-                    ("system", route_system),
-                    ("human", "{input}"),
-                ]
-            )
-
-
-            # Define schema for output:
-            class RouteQuery(TypedDict):
-                \"\"\"Route query to destination expert.\"\"\"
-
-                destination: Literal["animal", "vegetable"]
-
-
-            route_chain = route_prompt | llm.with_structured_output(RouteQuery)
-
-
-            # For LangGraph, we will define the state of the graph to hold the query,
-            # destination, and final answer.
-            class State(TypedDict):
-                query: str
-                destination: RouteQuery
-                answer: str
-
-
-            # We define functions for each node, including routing the query:
-            async def route_query(state: State, config: RunnableConfig):
-                destination = await route_chain.ainvoke(state["query"], config)
-                return {"destination": destination}
-
-
-            # And one node for each prompt
-            async def prompt_1(state: State, config: RunnableConfig):
-                return {"answer": await chain_1.ainvoke(state["query"], config)}
-
-
-            async def prompt_2(state: State, config: RunnableConfig):
-                return {"answer": await chain_2.ainvoke(state["query"], config)}
-
-
-            # We then define logic that selects the prompt based on the classification
-            def select_node(state: State) -> Literal["prompt_1", "prompt_2"]:
-                if state["destination"] == "animal":
-                    return "prompt_1"
-                else:
-                    return "prompt_2"
-
-
-            # Finally, assemble the multi-prompt chain. This is a sequence of two steps:
-            # 1) Select "animal" or "vegetable" via the route_chain, and collect the answer
-            # alongside the input query.
-            # 2) Route the input query to chain_1 or chain_2, based on the
-            # selection.
-            graph = StateGraph(State)
-            graph.add_node("route_query", route_query)
-            graph.add_node("prompt_1", prompt_1)
-            graph.add_node("prompt_2", prompt_2)
-
-            graph.add_edge(START, "route_query")
-            graph.add_conditional_edges("route_query", select_node)
-            graph.add_edge("prompt_1", END)
-            graph.add_edge("prompt_2", END)
-            app = graph.compile()
-
-            result = await app.ainvoke({"query": "what color are carrots"})
-            print(result["destination"])
-            print(result["answer"])
-
-    """  # noqa: E501
-
-    @property
-    @override
-    def output_keys(self) -> list[str]:
-        return ["text"]
-
-    @classmethod
-    def from_prompts(
-        cls,
-        llm: BaseLanguageModel,
-        prompt_infos: list[dict[str, str]],
-        default_chain: Optional[Chain] = None,
-        **kwargs: Any,
-    ) -> MultiPromptChain:
-        """Convenience constructor for instantiating from destination prompts."""
-        destinations = [f"{p['name']}: {p['description']}" for p in prompt_infos]
-        destinations_str = "\n".join(destinations)
-        router_template = MULTI_PROMPT_ROUTER_TEMPLATE.format(
-            destinations=destinations_str,
-        )
-        router_prompt = PromptTemplate(
-            template=router_template,
-            input_variables=["input"],
-            output_parser=RouterOutputParser(),
-        )
-        router_chain = LLMRouterChain.from_llm(llm, router_prompt)
-        destination_chains = {}
-        for p_info in prompt_infos:
-            name = p_info["name"]
-            prompt_template = p_info["prompt_template"]
-            prompt = PromptTemplate(template=prompt_template, input_variables=["input"])
-            chain = LLMChain(llm=llm, prompt=prompt)
-            destination_chains[name] = chain
-        _default_chain = default_chain or ConversationChain(llm=llm, output_key="text")
-        return cls(
-            router_chain=router_chain,
-            destination_chains=destination_chains,
-            default_chain=_default_chain,
-            **kwargs,
-        )

langchain/chains/router/multi_prompt_prompt.py

@@ -1,32 +0,0 @@
-"""Prompt for the router chain in the multi-prompt chain."""
-
-MULTI_PROMPT_ROUTER_TEMPLATE = """\
-Given a raw text input to a language model select the model prompt best suited for \
-the input. You will be given the names of the available prompts and a description of \
-what the prompt is best suited for. You may also revise the original input if you \
-think that revising it will ultimately lead to a better response from the language \
-model.
-
-<< FORMATTING >>
-Return a markdown code snippet with a JSON object formatted to look like:
-```json
-{{{{
-    "destination": string \\ name of the prompt to use or "DEFAULT"
-    "next_inputs": string \\ a potentially modified version of the original input
-}}}}
-```
-
-REMEMBER: "destination" MUST be one of the candidate prompt names specified below OR \
-it can be "DEFAULT" if the input is not well suited for any of the candidate prompts.
-REMEMBER: "next_inputs" can just be the original input if you don't think any \
-modifications are needed.
-
-<< CANDIDATE PROMPTS >>
-{destinations}
-
-<< INPUT >>
-{{input}}
-
-<< OUTPUT (must include ```json at the start of the response) >>
-<< OUTPUT (must end with ```) >>
-"""

langchain/chains/router/multi_retrieval_prompt.py

@@ -1,30 +0,0 @@
-"""Prompt for the router chain in the multi-retrieval qa chain."""
-
-MULTI_RETRIEVAL_ROUTER_TEMPLATE = """\
-Given a query to a question answering system select the system best suited \
-for the input. You will be given the names of the available systems and a description \
-of what questions the system is best suited for. You may also revise the original \
-input if you think that revising it will ultimately lead to a better response.
-
-<< FORMATTING >>
-Return a markdown code snippet with a JSON object formatted to look like:
-```json
-{{{{
-    "destination": string \\ name of the question answering system to use or "DEFAULT"
-    "next_inputs": string \\ a potentially modified version of the original input
-}}}}
-```
-
-REMEMBER: "destination" MUST be one of the candidate prompt names specified below OR \
-it can be "DEFAULT" if the input is not well suited for any of the candidate prompts.
-REMEMBER: "next_inputs" can just be the original input if you don't think any \
-modifications are needed.
-
-<< CANDIDATE PROMPTS >>
-{destinations}
-
-<< INPUT >>
-{{input}}
-
-<< OUTPUT >>
-"""

langchain/chains/router/multi_retrieval_qa.py

@@ -1,127 +0,0 @@
-"""Use a single chain to route an input to one of multiple retrieval qa chains."""
-
-from __future__ import annotations
-
-from collections.abc import Mapping
-from typing import Any, Optional
-
-from langchain_core.language_models import BaseLanguageModel
-from langchain_core.prompts import PromptTemplate
-from langchain_core.retrievers import BaseRetriever
-from typing_extensions import override
-
-from langchain.chains import ConversationChain
-from langchain.chains.base import Chain
-from langchain.chains.conversation.prompt import DEFAULT_TEMPLATE
-from langchain.chains.retrieval_qa.base import BaseRetrievalQA, RetrievalQA
-from langchain.chains.router.base import MultiRouteChain
-from langchain.chains.router.llm_router import LLMRouterChain, RouterOutputParser
-from langchain.chains.router.multi_retrieval_prompt import (
-    MULTI_RETRIEVAL_ROUTER_TEMPLATE,
-)
-
-
-class MultiRetrievalQAChain(MultiRouteChain):
-    """A multi-route chain that uses an LLM router chain to choose amongst retrieval
-    qa chains."""
-
-    router_chain: LLMRouterChain
-    """Chain for deciding a destination chain and the input to it."""
-    destination_chains: Mapping[str, BaseRetrievalQA]
-    """Map of name to candidate chains that inputs can be routed to."""
-    default_chain: Chain
-    """Default chain to use when router doesn't map input to one of the destinations."""
-
-    @property
-    @override
-    def output_keys(self) -> list[str]:
-        return ["result"]
-
-    @classmethod
-    def from_retrievers(
-        cls,
-        llm: BaseLanguageModel,
-        retriever_infos: list[dict[str, Any]],
-        default_retriever: Optional[BaseRetriever] = None,
-        default_prompt: Optional[PromptTemplate] = None,
-        default_chain: Optional[Chain] = None,
-        *,
-        default_chain_llm: Optional[BaseLanguageModel] = None,
-        **kwargs: Any,
-    ) -> MultiRetrievalQAChain:
-        """Create a multi retrieval qa chain from an LLM and a default chain.
-
-        Args:
-            llm: The language model to use.
-            retriever_infos: Dictionaries containing retriever information.
-            default_retriever: Optional default retriever to use if no default chain
-                is provided.
-            default_prompt: Optional prompt template to use for the default retriever.
-            default_chain: Optional default chain to use when router doesn't map input
-                to one of the destinations.
-            default_chain_llm: Optional language model to use if no default chain and
-                no default retriever are provided.
-            **kwargs: Additional keyword arguments to pass to the chain.
-        Returns:
-            An instance of the multi retrieval qa chain.
-        """
-        if default_prompt and not default_retriever:
-            msg = (
-                "`default_retriever` must be specified if `default_prompt` is "
-                "provided. Received only `default_prompt`."
-            )
-            raise ValueError(msg)
-        destinations = [f"{r['name']}: {r['description']}" for r in retriever_infos]
-        destinations_str = "\n".join(destinations)
-        router_template = MULTI_RETRIEVAL_ROUTER_TEMPLATE.format(
-            destinations=destinations_str,
-        )
-        router_prompt = PromptTemplate(
-            template=router_template,
-            input_variables=["input"],
-            output_parser=RouterOutputParser(next_inputs_inner_key="query"),
-        )
-        router_chain = LLMRouterChain.from_llm(llm, router_prompt)
-        destination_chains = {}
-        for r_info in retriever_infos:
-            prompt = r_info.get("prompt")
-            retriever = r_info["retriever"]
-            chain = RetrievalQA.from_llm(llm, prompt=prompt, retriever=retriever)
-            name = r_info["name"]
-            destination_chains[name] = chain
-        if default_chain:
-            _default_chain = default_chain
-        elif default_retriever:
-            _default_chain = RetrievalQA.from_llm(
-                llm,
-                prompt=default_prompt,
-                retriever=default_retriever,
-            )
-        else:
-            prompt_template = DEFAULT_TEMPLATE.replace("input", "query")
-            prompt = PromptTemplate(
-                template=prompt_template,
-                input_variables=["history", "query"],
-            )
-            if default_chain_llm is None:
-                msg = (
-                    "conversation_llm must be provided if default_chain is not "
-                    "specified. This API has been changed to avoid instantiating "
-                    "default LLMs on behalf of users."
-                    "You can provide a conversation LLM like so:\n"
-                    "from langchain_openai import ChatOpenAI\n"
-                    "llm = ChatOpenAI()"
-                )
-                raise NotImplementedError(msg)
-            _default_chain = ConversationChain(
-                llm=default_chain_llm,
-                prompt=prompt,
-                input_key="query",
-                output_key="result",
-            )
-        return cls(
-            router_chain=router_chain,
-            destination_chains=destination_chains,
-            default_chain=_default_chain,
-            **kwargs,
-        )