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

langchain/chains/flare/base.py

@@ -69,7 +69,8 @@ def _low_confidence_spans(
             "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"
+            "optimal speed and efficiency, consider installing NumPy: pip install "
+            "numpy",
         )
         import math
 
@@ -171,7 +172,8 @@ class FlareChain(Chain):
         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
+                question_gen_inputs,
+                callbacks=callbacks,
             )
             questions = [
                 output[self.question_generator_chain.output_keys[0]]
@@ -179,10 +181,13 @@ class FlareChain(Chain):
             ]
         else:
             questions = self.question_generator_chain.batch(
-                question_gen_inputs, config={"callbacks": callbacks}
+                question_gen_inputs,
+                config={"callbacks": callbacks},
             )
         _run_manager.on_text(
-            f"Generated Questions: {questions}", color="yellow", end="\n"
+            f"Generated Questions: {questions}",
+            color="yellow",
+            end="\n",
         )
         return self._do_generation(questions, user_input, response, _run_manager)
 
@@ -197,15 +202,18 @@ class FlareChain(Chain):
 
         response = ""
 
-        for i in range(self.max_iter):
+        for _i in range(self.max_iter):
             _run_manager.on_text(
-                f"Current Response: {response}", color="blue", end="\n"
+                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()}
-                )
+                    _input,
+                    {"callbacks": _run_manager.get_child()},
+                ),
             )
             low_confidence_spans = _low_confidence_spans(
                 tokens,
@@ -236,7 +244,10 @@ class FlareChain(Chain):
 
     @classmethod
     def from_llm(
-        cls, llm: BaseLanguageModel, max_generation_len: int = 32, **kwargs: Any
+        cls,
+        llm: BaseLanguageModel,
+        max_generation_len: int = 32,
+        **kwargs: Any,
     ) -> FlareChain:
         """Creates a FlareChain from a language model.
 
@@ -250,14 +261,17 @@ class FlareChain(Chain):
         """
         try:
             from langchain_openai import ChatOpenAI
-        except ImportError:
-            raise ImportError(
+        except ImportError as e:
+            msg = (
                 "OpenAI is required for FlareChain. "
                 "Please install langchain-openai."
                 "pip install langchain-openai"
             )
+            raise ImportError(msg) from e
         llm = ChatOpenAI(
-            max_completion_tokens=max_generation_len, logprobs=True, temperature=0
+            max_completion_tokens=max_generation_len,
+            logprobs=True,
+            temperature=0,
         )
         response_chain = PROMPT | llm
         question_gen_chain = QUESTION_GENERATOR_PROMPT | llm | StrOutputParser()

langchain/chains/graph_qa/cypher.py

@@ -31,9 +31,9 @@ def __getattr__(name: str) -> Any:
 
 
 __all__ = [
-    "GraphCypherQAChain",
+    "CYPHER_GENERATION_PROMPT",
     "INTERMEDIATE_STEPS_KEY",
+    "GraphCypherQAChain",
     "construct_schema",
     "extract_cypher",
-    "CYPHER_GENERATION_PROMPT",
 ]

langchain/chains/graph_qa/falkordb.py

@@ -26,4 +26,4 @@ def __getattr__(name: str) -> Any:
     return _import_attribute(name)
 
 
-__all__ = ["FalkorDBQAChain", "INTERMEDIATE_STEPS_KEY", "extract_cypher"]
+__all__ = ["INTERMEDIATE_STEPS_KEY", "FalkorDBQAChain", "extract_cypher"]

langchain/chains/graph_qa/gremlin.py

@@ -30,7 +30,7 @@ def __getattr__(name: str) -> Any:
 
 __all__ = [
     "GRAPHDB_SPARQL_FIX_TEMPLATE",
-    "GremlinQAChain",
     "INTERMEDIATE_STEPS_KEY",
+    "GremlinQAChain",
     "extract_gremlin",
 ]

langchain/chains/graph_qa/neptune_sparql.py

@@ -30,7 +30,7 @@ def __getattr__(name: str) -> Any:
 
 __all__ = [
     "INTERMEDIATE_STEPS_KEY",
-    "NeptuneSparqlQAChain",
     "SPARQL_GENERATION_TEMPLATE",
+    "NeptuneSparqlQAChain",
     "extract_sparql",
 ]

langchain/chains/graph_qa/prompts.py

@@ -74,7 +74,9 @@ __all__ = [
     "AQL_FIX_TEMPLATE",
     "AQL_GENERATION_TEMPLATE",
     "AQL_QA_TEMPLATE",
+    "CYPHER_GENERATION_PROMPT",
     "CYPHER_GENERATION_TEMPLATE",
+    "CYPHER_QA_PROMPT",
     "CYPHER_QA_TEMPLATE",
     "GRAPHDB_QA_TEMPLATE",
     "GRAPHDB_SPARQL_FIX_TEMPLATE",
@@ -91,6 +93,4 @@ __all__ = [
     "SPARQL_GENERATION_UPDATE_TEMPLATE",
     "SPARQL_INTENT_TEMPLATE",
     "SPARQL_QA_TEMPLATE",
-    "CYPHER_QA_PROMPT",
-    "CYPHER_GENERATION_PROMPT",
 ]

langchain/chains/history_aware_retriever.py

@@ -49,10 +49,11 @@ def create_history_aware_retriever(
 
     """
     if "input" not in prompt.input_variables:
-        raise ValueError(
+        msg = (
             "Expected `input` to be a prompt variable, "
             f"but got {prompt.input_variables}"
         )
+        raise ValueError(msg)
 
     retrieve_documents: RetrieverOutputLike = RunnableBranch(
         (

langchain/chains/hyde/base.py

@@ -47,8 +47,7 @@ class HypotheticalDocumentEmbedder(Chain, Embeddings):
         """Output keys for Hyde's LLM chain."""
         if isinstance(self.llm_chain, LLMChain):
             return self.llm_chain.output_keys
-        else:
-            return ["text"]
+        return ["text"]
 
     def embed_documents(self, texts: list[str]) -> list[list[float]]:
         """Call the base embeddings."""
@@ -66,7 +65,7 @@ class HypotheticalDocumentEmbedder(Chain, Embeddings):
                 "HypotheticalDocumentEmbedder 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"
+                "efficiency, consider installing NumPy: pip install numpy",
             )
             if not embeddings:
                 return []
@@ -92,7 +91,8 @@ class HypotheticalDocumentEmbedder(Chain, Embeddings):
         """Call the internal llm chain."""
         _run_manager = run_manager or CallbackManagerForChainRun.get_noop_manager()
         return self.llm_chain.invoke(
-            inputs, config={"callbacks": _run_manager.get_child()}
+            inputs,
+            config={"callbacks": _run_manager.get_child()},
         )
 
     @classmethod
@@ -110,10 +110,11 @@ class HypotheticalDocumentEmbedder(Chain, Embeddings):
         elif prompt_key is not None and prompt_key in PROMPT_MAP:
             prompt = PROMPT_MAP[prompt_key]
         else:
-            raise ValueError(
+            msg = (
                 f"Must specify prompt_key if custom_prompt not provided. Should be one "
                 f"of {list(PROMPT_MAP.keys())}."
             )
+            raise ValueError(msg)
 
         llm_chain = prompt | llm | StrOutputParser()
         return cls(base_embeddings=base_embeddings, llm_chain=llm_chain, **kwargs)

langchain/chains/hyde/prompts.py

@@ -1,15 +1,14 @@
-# flake8: noqa
 from langchain_core.prompts.prompt import PromptTemplate
 
-web_search_template = """Please write a passage to answer the question 
+web_search_template = """Please write a passage to answer the question
 Question: {QUESTION}
 Passage:"""
 web_search = PromptTemplate(template=web_search_template, input_variables=["QUESTION"])
-sci_fact_template = """Please write a scientific paper passage to support/refute the claim 
+sci_fact_template = """Please write a scientific paper passage to support/refute the claim
 Claim: {Claim}
-Passage:"""
+Passage:"""  # noqa: E501
 sci_fact = PromptTemplate(template=sci_fact_template, input_variables=["Claim"])
-arguana_template = """Please write a counter argument for the passage 
+arguana_template = """Please write a counter argument for the passage
 Passage: {PASSAGE}
 Counter Argument:"""
 arguana = PromptTemplate(template=arguana_template, input_variables=["PASSAGE"])
@@ -33,7 +32,7 @@ Passage:"""
 trec_news = PromptTemplate(template=trec_news_template, input_variables=["TOPIC"])
 mr_tydi_template = """Please write a passage in Swahili/Korean/Japanese/Bengali to answer the question in detail.
 Question: {QUESTION}
-Passage:"""
+Passage:"""  # noqa: E501
 mr_tydi = PromptTemplate(template=mr_tydi_template, input_variables=["QUESTION"])
 PROMPT_MAP = {
     "web_search": web_search,

langchain/chains/llm.py

@@ -82,13 +82,14 @@ class LLMChain(Chain):
     prompt: BasePromptTemplate
     """Prompt object to use."""
     llm: Union[
-        Runnable[LanguageModelInput, str], Runnable[LanguageModelInput, BaseMessage]
+        Runnable[LanguageModelInput, str],
+        Runnable[LanguageModelInput, BaseMessage],
     ]
     """Language model to call."""
     output_key: str = "text"  #: :meta private:
     output_parser: BaseLLMOutputParser = Field(default_factory=StrOutputParser)
     """Output parser to use.
-    Defaults to one that takes the most likely string but does not change it 
+    Defaults to one that takes the most likely string but does not change it
     otherwise."""
     return_final_only: bool = True
     """Whether to return only the final parsed result. Defaults to True.
@@ -116,8 +117,7 @@ class LLMChain(Chain):
         """
         if self.return_final_only:
             return [self.output_key]
-        else:
-            return [self.output_key, "full_generation"]
+        return [self.output_key, "full_generation"]
 
     def _call(
         self,
@@ -142,17 +142,17 @@ class LLMChain(Chain):
                 callbacks=callbacks,
                 **self.llm_kwargs,
             )
-        else:
-            results = self.llm.bind(stop=stop, **self.llm_kwargs).batch(
-                cast(list, prompts), {"callbacks": callbacks}
-            )
-            generations: list[list[Generation]] = []
-            for res in results:
-                if isinstance(res, BaseMessage):
-                    generations.append([ChatGeneration(message=res)])
-                else:
-                    generations.append([Generation(text=res)])
-            return LLMResult(generations=generations)
+        results = self.llm.bind(stop=stop, **self.llm_kwargs).batch(
+            cast(list, prompts),
+            {"callbacks": callbacks},
+        )
+        generations: list[list[Generation]] = []
+        for res in results:
+            if isinstance(res, BaseMessage):
+                generations.append([ChatGeneration(message=res)])
+            else:
+                generations.append([Generation(text=res)])
+        return LLMResult(generations=generations)
 
     async def agenerate(
         self,
@@ -169,17 +169,17 @@ class LLMChain(Chain):
                 callbacks=callbacks,
                 **self.llm_kwargs,
             )
-        else:
-            results = await self.llm.bind(stop=stop, **self.llm_kwargs).abatch(
-                cast(list, prompts), {"callbacks": callbacks}
-            )
-            generations: list[list[Generation]] = []
-            for res in results:
-                if isinstance(res, BaseMessage):
-                    generations.append([ChatGeneration(message=res)])
-                else:
-                    generations.append([Generation(text=res)])
-            return LLMResult(generations=generations)
+        results = await self.llm.bind(stop=stop, **self.llm_kwargs).abatch(
+            cast(list, prompts),
+            {"callbacks": callbacks},
+        )
+        generations: list[list[Generation]] = []
+        for res in results:
+            if isinstance(res, BaseMessage):
+                generations.append([ChatGeneration(message=res)])
+            else:
+                generations.append([Generation(text=res)])
+        return LLMResult(generations=generations)
 
     def prep_prompts(
         self,
@@ -201,9 +201,8 @@ class LLMChain(Chain):
             if run_manager:
                 run_manager.on_text(_text, end="\n", verbose=self.verbose)
             if "stop" in inputs and inputs["stop"] != stop:
-                raise ValueError(
-                    "If `stop` is present in any inputs, should be present in all."
-                )
+                msg = "If `stop` is present in any inputs, should be present in all."
+                raise ValueError(msg)
             prompts.append(prompt)
         return prompts, stop
 
@@ -227,18 +226,21 @@ class LLMChain(Chain):
             if run_manager:
                 await run_manager.on_text(_text, end="\n", verbose=self.verbose)
             if "stop" in inputs and inputs["stop"] != stop:
-                raise ValueError(
-                    "If `stop` is present in any inputs, should be present in all."
-                )
+                msg = "If `stop` is present in any inputs, should be present in all."
+                raise ValueError(msg)
             prompts.append(prompt)
         return prompts, stop
 
     def apply(
-        self, input_list: list[dict[str, Any]], callbacks: Callbacks = None
+        self,
+        input_list: list[dict[str, Any]],
+        callbacks: Callbacks = None,
     ) -> list[dict[str, str]]:
         """Utilize the LLM generate method for speed gains."""
         callback_manager = CallbackManager.configure(
-            callbacks, self.callbacks, self.verbose
+            callbacks,
+            self.callbacks,
+            self.verbose,
         )
         run_manager = callback_manager.on_chain_start(
             None,
@@ -249,17 +251,21 @@ class LLMChain(Chain):
             response = self.generate(input_list, run_manager=run_manager)
         except BaseException as e:
             run_manager.on_chain_error(e)
-            raise e
+            raise
         outputs = self.create_outputs(response)
         run_manager.on_chain_end({"outputs": outputs})
         return outputs
 
     async def aapply(
-        self, input_list: list[dict[str, Any]], callbacks: Callbacks = None
+        self,
+        input_list: list[dict[str, Any]],
+        callbacks: Callbacks = None,
     ) -> list[dict[str, str]]:
         """Utilize the LLM generate method for speed gains."""
         callback_manager = AsyncCallbackManager.configure(
-            callbacks, self.callbacks, self.verbose
+            callbacks,
+            self.callbacks,
+            self.verbose,
         )
         run_manager = await callback_manager.on_chain_start(
             None,
@@ -270,7 +276,7 @@ class LLMChain(Chain):
             response = await self.agenerate(input_list, run_manager=run_manager)
         except BaseException as e:
             await run_manager.on_chain_error(e)
-            raise e
+            raise
         outputs = self.create_outputs(response)
         await run_manager.on_chain_end({"outputs": outputs})
         return outputs
@@ -336,62 +342,72 @@ class LLMChain(Chain):
         return (await self.acall(kwargs, callbacks=callbacks))[self.output_key]
 
     def predict_and_parse(
-        self, callbacks: Callbacks = None, **kwargs: Any
+        self,
+        callbacks: Callbacks = None,
+        **kwargs: Any,
     ) -> Union[str, list[str], dict[str, Any]]:
         """Call predict and then parse the results."""
         warnings.warn(
             "The predict_and_parse method is deprecated, "
-            "instead pass an output parser directly to LLMChain."
+            "instead pass an output parser directly to LLMChain.",
+            stacklevel=2,
         )
         result = self.predict(callbacks=callbacks, **kwargs)
         if self.prompt.output_parser is not None:
             return self.prompt.output_parser.parse(result)
-        else:
-            return result
+        return result
 
     async def apredict_and_parse(
-        self, callbacks: Callbacks = None, **kwargs: Any
+        self,
+        callbacks: Callbacks = None,
+        **kwargs: Any,
     ) -> Union[str, list[str], dict[str, str]]:
         """Call apredict and then parse the results."""
         warnings.warn(
             "The apredict_and_parse method is deprecated, "
-            "instead pass an output parser directly to LLMChain."
+            "instead pass an output parser directly to LLMChain.",
+            stacklevel=2,
         )
         result = await self.apredict(callbacks=callbacks, **kwargs)
         if self.prompt.output_parser is not None:
             return self.prompt.output_parser.parse(result)
-        else:
-            return result
+        return result
 
     def apply_and_parse(
-        self, input_list: list[dict[str, Any]], callbacks: Callbacks = None
+        self,
+        input_list: list[dict[str, Any]],
+        callbacks: Callbacks = None,
     ) -> Sequence[Union[str, list[str], dict[str, str]]]:
         """Call apply and then parse the results."""
         warnings.warn(
             "The apply_and_parse method is deprecated, "
-            "instead pass an output parser directly to LLMChain."
+            "instead pass an output parser directly to LLMChain.",
+            stacklevel=2,
         )
         result = self.apply(input_list, callbacks=callbacks)
         return self._parse_generation(result)
 
     def _parse_generation(
-        self, generation: list[dict[str, str]]
+        self,
+        generation: list[dict[str, str]],
     ) -> Sequence[Union[str, list[str], dict[str, str]]]:
         if self.prompt.output_parser is not None:
             return [
                 self.prompt.output_parser.parse(res[self.output_key])
                 for res in generation
             ]
-        else:
-            return generation
+        return generation
 
     async def aapply_and_parse(
-        self, input_list: list[dict[str, Any]], callbacks: Callbacks = None
+        self,
+        input_list: list[dict[str, Any]],
+        callbacks: Callbacks = None,
     ) -> Sequence[Union[str, list[str], dict[str, str]]]:
         """Call apply and then parse the results."""
         warnings.warn(
             "The aapply_and_parse method is deprecated, "
-            "instead pass an output parser directly to LLMChain."
+            "instead pass an output parser directly to LLMChain.",
+            stacklevel=2,
         )
         result = await self.aapply(input_list, callbacks=callbacks)
         return self._parse_generation(result)
@@ -413,14 +429,14 @@ class LLMChain(Chain):
 def _get_language_model(llm_like: Runnable) -> BaseLanguageModel:
     if isinstance(llm_like, BaseLanguageModel):
         return llm_like
-    elif isinstance(llm_like, RunnableBinding):
+    if isinstance(llm_like, RunnableBinding):
         return _get_language_model(llm_like.bound)
-    elif isinstance(llm_like, RunnableWithFallbacks):
+    if isinstance(llm_like, RunnableWithFallbacks):
         return _get_language_model(llm_like.runnable)
-    elif isinstance(llm_like, (RunnableBranch, DynamicRunnable)):
+    if isinstance(llm_like, (RunnableBranch, DynamicRunnable)):
         return _get_language_model(llm_like.default)
-    else:
-        raise ValueError(
-            f"Unable to extract BaseLanguageModel from llm_like object of type "
-            f"{type(llm_like)}"
-        )
+    msg = (
+        f"Unable to extract BaseLanguageModel from llm_like object of type "
+        f"{type(llm_like)}"
+    )
+    raise ValueError(msg)

langchain/chains/llm_bash/__init__.py

@@ -1,9 +1,10 @@
 def __getattr__(name: str = "") -> None:
     """Raise an error on import since is deprecated."""
-    raise AttributeError(
+    msg = (
         "This module has been moved to langchain-experimental. "
         "For more details: https://github.com/langchain-ai/langchain/discussions/11352."
         "To access this code, install it with `pip install langchain-experimental`."
         "`from langchain_experimental.llm_bash.base "
         "import LLMBashChain`"
     )
+    raise AttributeError(msg)

langchain/chains/llm_checker/base.py

@@ -55,13 +55,12 @@ def _load_question_to_checked_assertions_chain(
         check_assertions_chain,
         revised_answer_chain,
     ]
-    question_to_checked_assertions_chain = SequentialChain(
+    return SequentialChain(
         chains=chains,  # type: ignore[arg-type]
         input_variables=["question"],
         output_variables=["revised_statement"],
         verbose=True,
     )
-    return question_to_checked_assertions_chain
 
 
 @deprecated(
@@ -112,7 +111,8 @@ class LLMCheckerChain(Chain):
             warnings.warn(
                 "Directly instantiating an LLMCheckerChain with an llm is deprecated. "
                 "Please instantiate with question_to_checked_assertions_chain "
-                "or using the from_llm class method."
+                "or using the from_llm class method.",
+                stacklevel=5,
             )
             if (
                 "question_to_checked_assertions_chain" not in values
@@ -122,7 +122,8 @@ class LLMCheckerChain(Chain):
                     _load_question_to_checked_assertions_chain(
                         values["llm"],
                         values.get(
-                            "create_draft_answer_prompt", CREATE_DRAFT_ANSWER_PROMPT
+                            "create_draft_answer_prompt",
+                            CREATE_DRAFT_ANSWER_PROMPT,
                         ),
                         values.get("list_assertions_prompt", LIST_ASSERTIONS_PROMPT),
                         values.get("check_assertions_prompt", CHECK_ASSERTIONS_PROMPT),
@@ -159,7 +160,8 @@ class LLMCheckerChain(Chain):
         question = inputs[self.input_key]
 
         output = self.question_to_checked_assertions_chain(
-            {"question": question}, callbacks=_run_manager.get_child()
+            {"question": question},
+            callbacks=_run_manager.get_child(),
         )
         return {self.output_key: output["revised_statement"]}
 

langchain/chains/llm_checker/prompt.py

@@ -1,4 +1,3 @@
-# flake8: noqa
 from langchain_core.prompts.prompt import PromptTemplate
 
 _CREATE_DRAFT_ANSWER_TEMPLATE = """{question}\n\n"""
@@ -8,14 +7,14 @@ CREATE_DRAFT_ANSWER_PROMPT = PromptTemplate(
 
 _LIST_ASSERTIONS_TEMPLATE = """Here is a statement:
 {statement}
-Make a bullet point list of the assumptions you made when producing the above statement.\n\n"""
+Make a bullet point list of the assumptions you made when producing the above statement.\n\n"""  # noqa: E501
 LIST_ASSERTIONS_PROMPT = PromptTemplate(
     input_variables=["statement"], template=_LIST_ASSERTIONS_TEMPLATE
 )
 
 _CHECK_ASSERTIONS_TEMPLATE = """Here is a bullet point list of assertions:
 {assertions}
-For each assertion, determine whether it is true or false. If it is false, explain why.\n\n"""
+For each assertion, determine whether it is true or false. If it is false, explain why.\n\n"""  # noqa: E501
 CHECK_ASSERTIONS_PROMPT = PromptTemplate(
     input_variables=["assertions"], template=_CHECK_ASSERTIONS_TEMPLATE
 )
@@ -24,7 +23,7 @@ _REVISED_ANSWER_TEMPLATE = """{checked_assertions}
 
 Question: In light of the above assertions and checks, how would you answer the question '{question}'?
 
-Answer:"""
+Answer:"""  # noqa: E501
 REVISED_ANSWER_PROMPT = PromptTemplate(
     input_variables=["checked_assertions", "question"],
     template=_REVISED_ANSWER_TEMPLATE,

langchain/chains/llm_math/base.py

@@ -26,7 +26,7 @@ from langchain.chains.llm_math.prompt import PROMPT
     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
+        "https://api.python.langchain.com/en/latest/chains/langchain.chains.llm_math.base.LLMMathChain.html"
     ),
     removal="1.0",
 )
@@ -166,16 +166,18 @@ class LLMMathChain(Chain):
     def raise_deprecation(cls, values: dict) -> Any:
         try:
             import numexpr  # noqa: F401
-        except ImportError:
-            raise ImportError(
+        except ImportError as e:
+            msg = (
                 "LLMMathChain requires the numexpr package. "
                 "Please install it with `pip install numexpr`."
             )
+            raise ImportError(msg) from e
         if "llm" in values:
             warnings.warn(
                 "Directly instantiating an LLMMathChain with an llm is deprecated. "
                 "Please instantiate with llm_chain argument or using the from_llm "
-                "class method."
+                "class method.",
+                stacklevel=5,
             )
             if "llm_chain" not in values and values["llm"] is not None:
                 prompt = values.get("prompt", PROMPT)
@@ -208,19 +210,22 @@ class LLMMathChain(Chain):
                     expression.strip(),
                     global_dict={},  # restrict access to globals
                     local_dict=local_dict,  # add common mathematical functions
-                )
+                ),
             )
         except Exception as e:
-            raise ValueError(
+            msg = (
                 f'LLMMathChain._evaluate("{expression}") raised error: {e}.'
                 " Please try again with a valid numerical expression"
             )
+            raise ValueError(msg) from e
 
         # Remove any leading and trailing brackets from the output
         return re.sub(r"^\[|\]$", "", output)
 
     def _process_llm_result(
-        self, llm_output: str, run_manager: CallbackManagerForChainRun
+        self,
+        llm_output: str,
+        run_manager: CallbackManagerForChainRun,
     ) -> dict[str, str]:
         run_manager.on_text(llm_output, color="green", verbose=self.verbose)
         llm_output = llm_output.strip()
@@ -236,7 +241,8 @@ class LLMMathChain(Chain):
         elif "Answer:" in llm_output:
             answer = "Answer: " + llm_output.split("Answer:")[-1]
         else:
-            raise ValueError(f"unknown format from LLM: {llm_output}")
+            msg = f"unknown format from LLM: {llm_output}"
+            raise ValueError(msg)
         return {self.output_key: answer}
 
     async def _aprocess_llm_result(
@@ -258,7 +264,8 @@ class LLMMathChain(Chain):
         elif "Answer:" in llm_output:
             answer = "Answer: " + llm_output.split("Answer:")[-1]
         else:
-            raise ValueError(f"unknown format from LLM: {llm_output}")
+            msg = f"unknown format from LLM: {llm_output}"
+            raise ValueError(msg)
         return {self.output_key: answer}
 
     def _call(