langchain 0.2.14__py3-none-any.whl → 0.2.16__py3-none-any.whl

langchain/chains/flare/base.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import re
-from abc import abstractmethod
 from typing import Any, Dict, List, Optional, Sequence, Tuple
 
 import numpy as np
@@ -9,10 +8,12 @@ from langchain_core.callbacks import (
     CallbackManagerForChainRun,
 )
 from langchain_core.language_models import BaseLanguageModel
-from langchain_core.outputs import Generation
+from langchain_core.messages import AIMessage
+from langchain_core.output_parsers import StrOutputParser
 from langchain_core.prompts import BasePromptTemplate
 from langchain_core.pydantic_v1 import Field
 from langchain_core.retrievers import BaseRetriever
+from langchain_core.runnables import Runnable
 
 from langchain.chains.base import Chain
 from langchain.chains.flare.prompts import (
@@ -23,51 +24,14 @@ from langchain.chains.flare.prompts import (
 from langchain.chains.llm import LLMChain
 
 
-class _ResponseChain(LLMChain):
-    """Base class for chains that generate responses."""
-
-    prompt: BasePromptTemplate = PROMPT
-
-    @classmethod
-    def is_lc_serializable(cls) -> bool:
-        return False
-
-    @property
-    def input_keys(self) -> List[str]:
-        return self.prompt.input_variables
-
-    def generate_tokens_and_log_probs(
-        self,
-        _input: Dict[str, Any],
-        *,
-        run_manager: Optional[CallbackManagerForChainRun] = None,
-    ) -> Tuple[Sequence[str], Sequence[float]]:
-        llm_result = self.generate([_input], run_manager=run_manager)
-        return self._extract_tokens_and_log_probs(llm_result.generations[0])
-
-    @abstractmethod
-    def _extract_tokens_and_log_probs(
-        self, generations: List[Generation]
-    ) -> Tuple[Sequence[str], Sequence[float]]:
-        """Extract tokens and log probs from response."""
-
-
-class _OpenAIResponseChain(_ResponseChain):
-    """Chain that generates responses from user input and context."""
-
-    llm: BaseLanguageModel
-
-    def _extract_tokens_and_log_probs(
-        self, generations: List[Generation]
-    ) -> Tuple[Sequence[str], Sequence[float]]:
-        tokens = []
-        log_probs = []
-        for gen in generations:
-            if gen.generation_info is None:
-                raise ValueError
-            tokens.extend(gen.generation_info["logprobs"]["tokens"])
-            log_probs.extend(gen.generation_info["logprobs"]["token_logprobs"])
-        return tokens, log_probs
+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):
@@ -109,11 +73,14 @@ def _low_confidence_spans(
 
 class FlareChain(Chain):
     """Chain that combines a retriever, a question generator,
-    and a response generator."""
+    and a response generator.
 
-    question_generator_chain: QuestionGeneratorChain
+    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: _ResponseChain
+    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."""
@@ -152,12 +119,16 @@ class FlareChain(Chain):
         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.predict(
-            user_input=user_input,
-            context=context,
-            response=response,
-            callbacks=callbacks,
+        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
 
@@ -178,13 +149,18 @@ class FlareChain(Chain):
             for span in low_confidence_spans
         ]
         callbacks = _run_manager.get_child()
-        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
-        ]
+        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"
         )
@@ -206,8 +182,10 @@ class FlareChain(Chain):
                 f"Current Response: {response}", color="blue", end="\n"
             )
             _input = {"user_input": user_input, "context": "", "response": response}
-            tokens, log_probs = self.response_chain.generate_tokens_and_log_probs(
-                _input, run_manager=_run_manager
+            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,
@@ -251,18 +229,16 @@ class FlareChain(Chain):
             FlareChain class with the given language model.
         """
         try:
-            from langchain_openai import OpenAI
+            from langchain_openai import ChatOpenAI
         except ImportError:
             raise ImportError(
                 "OpenAI is required for FlareChain. "
                 "Please install langchain-openai."
                 "pip install langchain-openai"
             )
-        question_gen_chain = QuestionGeneratorChain(llm=llm)
-        response_llm = OpenAI(
-            max_tokens=max_generation_len, model_kwargs={"logprobs": 1}, temperature=0
-        )
-        response_chain = _OpenAIResponseChain(llm=response_llm)
+        llm = ChatOpenAI(max_tokens=max_generation_len, logprobs=True, temperature=0)
+        response_chain = PROMPT | llm
+        question_gen_chain = QUESTION_GENERATOR_PROMPT | llm | StrOutputParser()
         return cls(
             question_generator_chain=question_gen_chain,
             response_chain=response_chain,

langchain/chains/hyde/base.py

@@ -11,7 +11,9 @@ import numpy as np
 from langchain_core.callbacks import CallbackManagerForChainRun
 from langchain_core.embeddings import Embeddings
 from langchain_core.language_models import BaseLanguageModel
+from langchain_core.output_parsers import StrOutputParser
 from langchain_core.prompts import BasePromptTemplate
+from langchain_core.runnables import Runnable
 
 from langchain.chains.base import Chain
 from langchain.chains.hyde.prompts import PROMPT_MAP
@@ -25,7 +27,7 @@ class HypotheticalDocumentEmbedder(Chain, Embeddings):
     """
 
     base_embeddings: Embeddings
-    llm_chain: LLMChain
+    llm_chain: Runnable
 
     class Config:
         arbitrary_types_allowed = True
@@ -34,12 +36,15 @@ class HypotheticalDocumentEmbedder(Chain, Embeddings):
     @property
     def input_keys(self) -> List[str]:
         """Input keys for Hyde's LLM chain."""
-        return self.llm_chain.input_keys
+        return self.llm_chain.input_schema.schema()["required"]
 
     @property
     def output_keys(self) -> List[str]:
         """Output keys for Hyde's LLM chain."""
-        return self.llm_chain.output_keys
+        if isinstance(self.llm_chain, LLMChain):
+            return self.llm_chain.output_keys
+        else:
+            return ["text"]
 
     def embed_documents(self, texts: List[str]) -> List[List[float]]:
         """Call the base embeddings."""
@@ -51,9 +56,12 @@ class HypotheticalDocumentEmbedder(Chain, Embeddings):
 
     def embed_query(self, text: str) -> List[float]:
         """Generate a hypothetical document and embedded it."""
-        var_name = self.llm_chain.input_keys[0]
-        result = self.llm_chain.generate([{var_name: text}])
-        documents = [generation.text for generation in result.generations[0]]
+        var_name = self.input_keys[0]
+        result = self.llm_chain.invoke({var_name: text})
+        if isinstance(self.llm_chain, LLMChain):
+            documents = [result[self.output_keys[0]]]
+        else:
+            documents = [result]
         embeddings = self.embed_documents(documents)
         return self.combine_embeddings(embeddings)
 
@@ -64,7 +72,9 @@ class HypotheticalDocumentEmbedder(Chain, Embeddings):
     ) -> Dict[str, str]:
         """Call the internal llm chain."""
         _run_manager = run_manager or CallbackManagerForChainRun.get_noop_manager()
-        return self.llm_chain(inputs, callbacks=_run_manager.get_child())
+        return self.llm_chain.invoke(
+            inputs, config={"callbacks": _run_manager.get_child()}
+        )
 
     @classmethod
     def from_llm(
@@ -86,7 +96,7 @@ class HypotheticalDocumentEmbedder(Chain, Embeddings):
                 f"of {list(PROMPT_MAP.keys())}."
             )
 
-        llm_chain = LLMChain(llm=llm, prompt=prompt)
+        llm_chain = prompt | llm | StrOutputParser()
         return cls(base_embeddings=base_embeddings, llm_chain=llm_chain, **kwargs)
 
     @property

langchain/chains/llm_math/base.py

@@ -7,6 +7,7 @@ import re
 import warnings
 from typing import Any, Dict, List, Optional
 
+from langchain_core._api import deprecated
 from langchain_core.callbacks import (
     AsyncCallbackManagerForChainRun,
     CallbackManagerForChainRun,
@@ -20,16 +21,132 @@ from langchain.chains.llm import LLMChain
 from langchain.chains.llm_math.prompt import PROMPT
 
 
+@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.llm_math.base.LLMMathChain.html"  # noqa: E501
+    ),
+    removal="1.0",
+)
 class LLMMathChain(Chain):
     """Chain that interprets a prompt and executes python code to do math.
 
+    Note: this class is deprecated. See below for a replacement implementation
+        using LangGraph. The benefits of this implementation are:
+
+        - Uses LLM tool calling features;
+        - 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:
+
+        .. code-block:: bash
+
+            pip install -U langgraph
+
+        .. code-block:: python
+
+            import math
+            from typing import Annotated, Sequence
+
+            from langchain_core.messages import BaseMessage
+            from langchain_core.runnables import RunnableConfig
+            from langchain_core.tools import tool
+            from langchain_openai import ChatOpenAI
+            from langgraph.graph import END, StateGraph
+            from langgraph.graph.message import add_messages
+            from langgraph.prebuilt.tool_node import ToolNode
+            import numexpr
+            from typing_extensions import TypedDict
+
+            @tool
+            def calculator(expression: str) -> str:
+                \"\"\"Calculate expression using Python's numexpr library.
+
+                Expression should be a single line mathematical expression
+                that solves the problem.
+
+                Examples:
+                    "37593 * 67" for "37593 times 67"
+                    "37593**(1/5)" for "37593^(1/5)"
+                \"\"\"
+                local_dict = {"pi": math.pi, "e": math.e}
+                return str(
+                    numexpr.evaluate(
+                        expression.strip(),
+                        global_dict={},  # restrict access to globals
+                        local_dict=local_dict,  # add common mathematical functions
+                    )
+                )
+
+            llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)
+            tools = [calculator]
+            llm_with_tools = llm.bind_tools(tools, tool_choice="any")
+
+            class ChainState(TypedDict):
+                \"\"\"LangGraph state.\"\"\"
+
+                messages: Annotated[Sequence[BaseMessage], add_messages]
+
+            async def acall_chain(state: ChainState, config: RunnableConfig):
+                last_message = state["messages"][-1]
+                response = await llm_with_tools.ainvoke(state["messages"], config)
+                return {"messages": [response]}
+
+            async def acall_model(state: ChainState, config: RunnableConfig):
+                response = await llm.ainvoke(state["messages"], config)
+                return {"messages": [response]}
+
+            graph_builder = StateGraph(ChainState)
+            graph_builder.add_node("call_tool", acall_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()
+
+        .. code-block:: python
+
+            example_query = "What is 551368 divided by 82"
+
+            events = chain.astream(
+                {"messages": [("user", example_query)]},
+                stream_mode="values",
+            )
+            async for event in events:
+                event["messages"][-1].pretty_print()
+
+        .. code-block:: none
+
+            ================================ Human Message =================================
+
+            What is 551368 divided by 82
+            ================================== Ai Message ==================================
+            Tool Calls:
+            calculator (call_MEiGXuJjJ7wGU4aOT86QuGJS)
+            Call ID: call_MEiGXuJjJ7wGU4aOT86QuGJS
+            Args:
+                expression: 551368 / 82
+            ================================= Tool Message =================================
+            Name: calculator
+
+            6724.0
+            ================================== Ai Message ==================================
+
+            551368 divided by 82 equals 6724.
+
     Example:
         .. code-block:: python
 
             from langchain.chains import LLMMathChain
             from langchain_community.llms import OpenAI
             llm_math = LLMMathChain.from_llm(OpenAI())
-    """
+    """  # noqa: E501
 
     llm_chain: LLMChain
     llm: Optional[BaseLanguageModel] = None

langchain/chains/moderation.py

@@ -38,7 +38,7 @@ class OpenAIModerationChain(Chain):
     output_key: str = "output"  #: :meta private:
     openai_api_key: Optional[str] = None
     openai_organization: Optional[str] = None
-    _openai_pre_1_0: bool = Field(default=None)
+    openai_pre_1_0: bool = Field(default=None)
 
     @root_validator(pre=True)
     def validate_environment(cls, values: Dict) -> Dict:
@@ -58,16 +58,17 @@ class OpenAIModerationChain(Chain):
             openai.api_key = openai_api_key
             if openai_organization:
                 openai.organization = openai_organization
-            values["_openai_pre_1_0"] = False
+            values["openai_pre_1_0"] = False
             try:
                 check_package_version("openai", gte_version="1.0")
             except ValueError:
-                values["_openai_pre_1_0"] = True
-            if values["_openai_pre_1_0"]:
+                values["openai_pre_1_0"] = True
+            if values["openai_pre_1_0"]:
                 values["client"] = openai.Moderation
             else:
                 values["client"] = openai.OpenAI()
                 values["async_client"] = openai.AsyncOpenAI()
+
         except ImportError:
             raise ImportError(
                 "Could not import openai python package. "
@@ -92,7 +93,7 @@ class OpenAIModerationChain(Chain):
         return [self.output_key]
 
     def _moderate(self, text: str, results: Any) -> str:
-        if self._openai_pre_1_0:
+        if self.openai_pre_1_0:
             condition = results["flagged"]
         else:
             condition = results.flagged
@@ -110,7 +111,7 @@ class OpenAIModerationChain(Chain):
         run_manager: Optional[CallbackManagerForChainRun] = None,
     ) -> Dict[str, Any]:
         text = inputs[self.input_key]
-        if self._openai_pre_1_0:
+        if self.openai_pre_1_0:
             results = self.client.create(text)
             output = self._moderate(text, results["results"][0])
         else:
@@ -123,7 +124,7 @@ class OpenAIModerationChain(Chain):
         inputs: Dict[str, Any],
         run_manager: Optional[AsyncCallbackManagerForChainRun] = None,
     ) -> Dict[str, Any]:
-        if self._openai_pre_1_0:
+        if self.openai_pre_1_0:
             return await super()._acall(inputs, run_manager=run_manager)
         text = inputs[self.input_key]
         results = await self.async_client.moderations.create(input=text)

langchain/chains/natbot/base.py

@@ -5,15 +5,27 @@ from __future__ import annotations
 import warnings
 from typing import Any, Dict, List, Optional
 
+from langchain_core._api import deprecated
 from langchain_core.callbacks import CallbackManagerForChainRun
 from langchain_core.language_models import BaseLanguageModel
+from langchain_core.output_parsers import StrOutputParser
 from langchain_core.pydantic_v1 import root_validator
+from langchain_core.runnables import Runnable
 
 from langchain.chains.base import Chain
-from langchain.chains.llm import LLMChain
 from langchain.chains.natbot.prompt import PROMPT
 
 
+@deprecated(
+    since="0.2.13",
+    message=(
+        "Importing NatBotChain from langchain is deprecated and will be removed in "
+        "langchain 1.0. Please import from langchain_community instead: "
+        "from langchain_community.chains.natbot import NatBotChain. "
+        "You may need to pip install -U langchain-community."
+    ),
+    removal="1.0",
+)
 class NatBotChain(Chain):
     """Implement an LLM driven browser.
 
@@ -37,7 +49,7 @@ class NatBotChain(Chain):
             natbot = NatBotChain.from_default("Buy me a new hat.")
     """
 
-    llm_chain: LLMChain
+    llm_chain: Runnable
     objective: str
     """Objective that NatBot is tasked with completing."""
     llm: Optional[BaseLanguageModel] = None
@@ -60,7 +72,7 @@ class NatBotChain(Chain):
                 "class method."
             )
             if "llm_chain" not in values and values["llm"] is not None:
-                values["llm_chain"] = LLMChain(llm=values["llm"], prompt=PROMPT)
+                values["llm_chain"] = PROMPT | values["llm"] | StrOutputParser()
         return values
 
     @classmethod
@@ -77,7 +89,7 @@ class NatBotChain(Chain):
         cls, llm: BaseLanguageModel, objective: str, **kwargs: Any
     ) -> NatBotChain:
         """Load from LLM."""
-        llm_chain = LLMChain(llm=llm, prompt=PROMPT)
+        llm_chain = PROMPT | llm | StrOutputParser()
         return cls(llm_chain=llm_chain, objective=objective, **kwargs)
 
     @property
@@ -104,12 +116,14 @@ class NatBotChain(Chain):
         _run_manager = run_manager or CallbackManagerForChainRun.get_noop_manager()
         url = inputs[self.input_url_key]
         browser_content = inputs[self.input_browser_content_key]
-        llm_cmd = self.llm_chain.predict(
-            objective=self.objective,
-            url=url[:100],
-            previous_command=self.previous_command,
-            browser_content=browser_content[:4500],
-            callbacks=_run_manager.get_child(),
+        llm_cmd = self.llm_chain.invoke(
+            {
+                "objective": self.objective,
+                "url": url[:100],
+                "previous_command": self.previous_command,
+                "browser_content": browser_content[:4500],
+            },
+            config={"callbacks": _run_manager.get_child()},
         )
         llm_cmd = llm_cmd.strip()
         self.previous_command = llm_cmd

langchain/chains/query_constructor/parser.py

@@ -35,6 +35,7 @@ GRAMMAR = r"""
     ?value: SIGNED_INT -> int
         | SIGNED_FLOAT -> float
         | DATE -> date
+        | DATETIME -> datetime
         | list
         | string
         | ("false" | "False" | "FALSE") -> false
@@ -42,6 +43,7 @@ GRAMMAR = r"""
 
     args: expr ("," expr)*
     DATE.2: /["']?(\d{4}-[01]\d-[0-3]\d)["']?/
+    DATETIME.2: /["']?\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d:[0-5]\d[Zz]?["']?/
     string: /'[^']*'/ | ESCAPED_STRING
     list: "[" [args] "]"
 
@@ -61,6 +63,13 @@ class ISO8601Date(TypedDict):
     type: Literal["date"]
 
 
+class ISO8601DateTime(TypedDict):
+    """A datetime in ISO 8601 format (YYYY-MM-DDTHH:MM:SS)."""
+
+    datetime: str
+    type: Literal["datetime"]
+
+
 @v_args(inline=True)
 class QueryTransformer(Transformer):
     """Transform a query string into an intermediate representation."""
@@ -149,6 +158,20 @@ class QueryTransformer(Transformer):
             )
         return {"date": item, "type": "date"}
 
+    def datetime(self, item: Any) -> ISO8601DateTime:
+        item = str(item).strip("\"'")
+        try:
+            # Parse full ISO 8601 datetime format
+            datetime.datetime.strptime(item, "%Y-%m-%dT%H:%M:%S%z")
+        except ValueError:
+            try:
+                datetime.datetime.strptime(item, "%Y-%m-%dT%H:%M:%S")
+            except ValueError:
+                raise ValueError(
+                    "Datetime values are expected to be in ISO 8601 format."
+                )
+        return {"datetime": item, "type": "datetime"}
+
     def string(self, item: Any) -> str:
         # Remove escaped quotes
         return str(item).strip("\"'")

langchain/retrievers/document_compressors/chain_extract.py

@@ -8,8 +8,9 @@ from typing import Any, Callable, Dict, Optional, Sequence, cast
 from langchain_core.callbacks.manager import Callbacks
 from langchain_core.documents import Document
 from langchain_core.language_models import BaseLanguageModel
-from langchain_core.output_parsers import BaseOutputParser
+from langchain_core.output_parsers import BaseOutputParser, StrOutputParser
 from langchain_core.prompts import PromptTemplate
+from langchain_core.runnables import Runnable
 
 from langchain.chains.llm import LLMChain
 from langchain.retrievers.document_compressors.base import BaseDocumentCompressor
@@ -49,12 +50,15 @@ class LLMChainExtractor(BaseDocumentCompressor):
     """Document compressor that uses an LLM chain to extract
     the relevant parts of documents."""
 
-    llm_chain: LLMChain
+    llm_chain: Runnable
     """LLM wrapper to use for compressing documents."""
 
     get_input: Callable[[str, Document], dict] = default_get_input
     """Callable for constructing the chain input from the query and a Document."""
 
+    class Config:
+        arbitrary_types_allowed = True
+
     def compress_documents(
         self,
         documents: Sequence[Document],
@@ -65,10 +69,13 @@ class LLMChainExtractor(BaseDocumentCompressor):
         compressed_docs = []
         for doc in documents:
             _input = self.get_input(query, doc)
-            output_dict = self.llm_chain.invoke(_input, config={"callbacks": callbacks})
-            output = output_dict[self.llm_chain.output_key]
-            if self.llm_chain.prompt.output_parser is not None:
-                output = self.llm_chain.prompt.output_parser.parse(output)
+            output_ = self.llm_chain.invoke(_input, config={"callbacks": callbacks})
+            if isinstance(self.llm_chain, LLMChain):
+                output = output_[self.llm_chain.output_key]
+                if self.llm_chain.prompt.output_parser is not None:
+                    output = self.llm_chain.prompt.output_parser.parse(output)
+            else:
+                output = output_
             if len(output) == 0:
                 continue
             compressed_docs.append(
@@ -85,9 +92,7 @@ class LLMChainExtractor(BaseDocumentCompressor):
         """Compress page content of raw documents asynchronously."""
         outputs = await asyncio.gather(
             *[
-                self.llm_chain.apredict_and_parse(
-                    **self.get_input(query, doc), callbacks=callbacks
-                )
+                self.llm_chain.ainvoke(self.get_input(query, doc), callbacks=callbacks)
                 for doc in documents
             ]
         )
@@ -111,5 +116,9 @@ class LLMChainExtractor(BaseDocumentCompressor):
         """Initialize from LLM."""
         _prompt = prompt if prompt is not None else _get_default_chain_prompt()
         _get_input = get_input if get_input is not None else default_get_input
-        llm_chain = LLMChain(llm=llm, prompt=_prompt, **(llm_chain_kwargs or {}))
+        if _prompt.output_parser is not None:
+            parser = _prompt.output_parser
+        else:
+            parser = StrOutputParser()
+        llm_chain = _prompt | llm | parser
         return cls(llm_chain=llm_chain, get_input=_get_input)  # type: ignore[arg-type]