verbose flag (#683)

Author: hwchase17

langchain/agents/agent.py

@@ -241,8 +241,9 @@ def _should_continue(self, iterations: int) -> bool:
             return iterations < self.max_iterations
 
     def _return(self, output: AgentFinish, intermediate_steps: list) -> Dict[str, Any]:
-        if self.verbose:
-            self.callback_manager.on_agent_finish(output, color="green")
+        self.callback_manager.on_agent_finish(
+            output, color="green", verbose=self.verbose
+        )
         final_output = output.return_values
         if self.return_intermediate_steps:
             final_output["intermediate_steps"] = intermediate_steps
@@ -272,35 +273,35 @@ def _call(self, inputs: Dict[str, str]) -> Dict[str, Any]:
             # Otherwise we lookup the tool
             if output.tool in name_to_tool_map:
                 tool = name_to_tool_map[output.tool]
-                if self.verbose:
-                    self.callback_manager.on_tool_start(
-                        {"name": str(tool.func)[:60] + "..."}, output, color="green"
-                    )
+                self.callback_manager.on_tool_start(
+                    {"name": str(tool.func)[:60] + "..."},
+                    output,
+                    color="green",
+                    verbose=self.verbose,
+                )
                 try:
                     # We then call the tool on the tool input to get an observation
                     observation = tool.func(output.tool_input)
                     color = color_mapping[output.tool]
                     return_direct = tool.return_direct
                 except Exception as e:
-                    if self.verbose:
-                        self.callback_manager.on_tool_error(e)
+                    self.callback_manager.on_tool_error(e, verbose=self.verbose)
                     raise e
             else:
-                if self.verbose:
-                    self.callback_manager.on_tool_start(
-                        {"name": "N/A"}, output, color="green"
-                    )
+                self.callback_manager.on_tool_start(
+                    {"name": "N/A"}, output, color="green", verbose=self.verbose
+                )
                 observation = f"{output.tool} is not a valid tool, try another one."
                 color = None
                 return_direct = False
-            if self.verbose:
-                llm_prefix = "" if return_direct else self.agent.llm_prefix
-                self.callback_manager.on_tool_end(
-                    observation,
-                    color=color,
-                    observation_prefix=self.agent.observation_prefix,
-                    llm_prefix=llm_prefix,
-                )
+            llm_prefix = "" if return_direct else self.agent.llm_prefix
+            self.callback_manager.on_tool_end(
+                observation,
+                color=color,
+                observation_prefix=self.agent.observation_prefix,
+                llm_prefix=llm_prefix,
+                verbose=self.verbose,
+            )
             intermediate_steps.append((output, observation))
             if return_direct:
                 # Set the log to "" because we do not want to log it.

langchain/callbacks/base.py

@@ -15,21 +15,23 @@ class BaseCallbackHandler(BaseModel, ABC):
     ignore_chain: bool = False
     ignore_agent: bool = False
 
+    @property
+    def always_verbose(self) -> bool:
+        """Whether to call verbose callbacks even if verbose is False."""
+        return False
+
     @abstractmethod
     def on_llm_start(
         self, serialized: Dict[str, Any], prompts: List[str], **kwargs: Any
     ) -> None:
         """Run when LLM starts running."""
 
     @abstractmethod
-    def on_llm_end(
-        self,
-        response: LLMResult,
-    ) -> None:
+    def on_llm_end(self, response: LLMResult, **kwargs: Any) -> None:
         """Run when LLM ends running."""
 
     @abstractmethod
-    def on_llm_error(self, error: Exception) -> None:
+    def on_llm_error(self, error: Exception, **kwargs: Any) -> None:
         """Run when LLM errors."""
 
     @abstractmethod
@@ -39,11 +41,11 @@ def on_chain_start(
         """Run when chain starts running."""
 
     @abstractmethod
-    def on_chain_end(self, outputs: Dict[str, Any]) -> None:
+    def on_chain_end(self, outputs: Dict[str, Any], **kwargs: Any) -> None:
         """Run when chain ends running."""
 
     @abstractmethod
-    def on_chain_error(self, error: Exception) -> None:
+    def on_chain_error(self, error: Exception, **kwargs: Any) -> None:
         """Run when chain errors."""
 
     @abstractmethod
@@ -57,7 +59,7 @@ def on_tool_end(self, output: str, **kwargs: Any) -> None:
         """Run when tool ends running."""
 
     @abstractmethod
-    def on_tool_error(self, error: Exception) -> None:
+    def on_tool_error(self, error: Exception, **kwargs: Any) -> None:
         """Run when tool errors."""
 
     @abstractmethod
@@ -91,78 +93,110 @@ class CallbackManager(BaseCallbackManager):
     handlers: List[BaseCallbackHandler]
 
     def on_llm_start(
-        self, serialized: Dict[str, Any], prompts: List[str], **kwargs: Any
+        self,
+        serialized: Dict[str, Any],
+        prompts: List[str],
+        verbose: bool = False,
+        **kwargs: Any
     ) -> None:
         """Run when LLM starts running."""
         for handler in self.handlers:
             if not handler.ignore_llm:
-                handler.on_llm_start(serialized, prompts, **kwargs)
+                if verbose or handler.always_verbose:
+                    handler.on_llm_start(serialized, prompts, **kwargs)
 
     def on_llm_end(
-        self,
-        response: LLMResult,
+        self, response: LLMResult, verbose: bool = False, **kwargs: Any
     ) -> None:
         """Run when LLM ends running."""
         for handler in self.handlers:
             if not handler.ignore_llm:
-                handler.on_llm_end(response)
+                if verbose or handler.always_verbose:
+                    handler.on_llm_end(response)
 
-    def on_llm_error(self, error: Exception) -> None:
+    def on_llm_error(
+        self, error: Exception, verbose: bool = False, **kwargs: Any
+    ) -> None:
         """Run when LLM errors."""
         for handler in self.handlers:
             if not handler.ignore_llm:
-                handler.on_llm_error(error)
+                if verbose or handler.always_verbose:
+                    handler.on_llm_error(error)
 
     def on_chain_start(
-        self, serialized: Dict[str, Any], inputs: Dict[str, Any], **kwargs: Any
+        self,
+        serialized: Dict[str, Any],
+        inputs: Dict[str, Any],
+        verbose: bool = False,
+        **kwargs: Any
     ) -> None:
         """Run when chain starts running."""
         for handler in self.handlers:
             if not handler.ignore_chain:
-                handler.on_chain_start(serialized, inputs, **kwargs)
+                if verbose or handler.always_verbose:
+                    handler.on_chain_start(serialized, inputs, **kwargs)
 
-    def on_chain_end(self, outputs: Dict[str, Any]) -> None:
+    def on_chain_end(
+        self, outputs: Dict[str, Any], verbose: bool = False, **kwargs: Any
+    ) -> None:
         """Run when chain ends running."""
         for handler in self.handlers:
             if not handler.ignore_chain:
-                handler.on_chain_end(outputs)
+                if verbose or handler.always_verbose:
+                    handler.on_chain_end(outputs)
 
-    def on_chain_error(self, error: Exception) -> None:
+    def on_chain_error(
+        self, error: Exception, verbose: bool = False, **kwargs: Any
+    ) -> None:
         """Run when chain errors."""
         for handler in self.handlers:
             if not handler.ignore_chain:
-                handler.on_chain_error(error)
+                if verbose or handler.always_verbose:
+                    handler.on_chain_error(error)
 
     def on_tool_start(
-        self, serialized: Dict[str, Any], action: AgentAction, **kwargs: Any
+        self,
+        serialized: Dict[str, Any],
+        action: AgentAction,
+        verbose: bool = False,
+        **kwargs: Any
     ) -> None:
         """Run when tool starts running."""
         for handler in self.handlers:
             if not handler.ignore_agent:
-                handler.on_tool_start(serialized, action, **kwargs)
+                if verbose or handler.always_verbose:
+                    handler.on_tool_start(serialized, action, **kwargs)
 
-    def on_tool_end(self, output: str, **kwargs: Any) -> None:
+    def on_tool_end(self, output: str, verbose: bool = False, **kwargs: Any) -> None:
         """Run when tool ends running."""
         for handler in self.handlers:
             if not handler.ignore_agent:
-                handler.on_tool_end(output, **kwargs)
+                if verbose or handler.always_verbose:
+                    handler.on_tool_end(output, **kwargs)
 
-    def on_tool_error(self, error: Exception) -> None:
+    def on_tool_error(
+        self, error: Exception, verbose: bool = False, **kwargs: Any
+    ) -> None:
         """Run when tool errors."""
         for handler in self.handlers:
             if not handler.ignore_agent:
-                handler.on_tool_error(error)
+                if verbose or handler.always_verbose:
+                    handler.on_tool_error(error)
 
-    def on_text(self, text: str, **kwargs: Any) -> None:
+    def on_text(self, text: str, verbose: bool = False, **kwargs: Any) -> None:
         """Run on additional input from chains and agents."""
         for handler in self.handlers:
-            handler.on_text(text, **kwargs)
+            if verbose or handler.always_verbose:
+                handler.on_text(text, **kwargs)
 
-    def on_agent_finish(self, finish: AgentFinish, **kwargs: Any) -> None:
+    def on_agent_finish(
+        self, finish: AgentFinish, verbose: bool = False, **kwargs: Any
+    ) -> None:
         """Run on agent end."""
         for handler in self.handlers:
             if not handler.ignore_agent:
-                handler.on_agent_finish(finish, **kwargs)
+                if verbose or handler.always_verbose:
+                    handler.on_agent_finish(finish, **kwargs)
 
     def add_handler(self, handler: BaseCallbackHandler) -> None:
         """Add a handler to the callback manager."""

langchain/callbacks/shared.py

@@ -41,18 +41,15 @@ def on_llm_start(
         with self._lock:
             self._callback_manager.on_llm_start(serialized, prompts, **kwargs)
 
-    def on_llm_end(
-        self,
-        response: LLMResult,
-    ) -> None:
+    def on_llm_end(self, response: LLMResult, **kwargs: Any) -> None:
         """Run when LLM ends running."""
         with self._lock:
-            self._callback_manager.on_llm_end(response)
+            self._callback_manager.on_llm_end(response, **kwargs)
 
-    def on_llm_error(self, error: Exception) -> None:
+    def on_llm_error(self, error: Exception, **kwargs: Any) -> None:
         """Run when LLM errors."""
         with self._lock:
-            self._callback_manager.on_llm_error(error)
+            self._callback_manager.on_llm_error(error, **kwargs)
 
     def on_chain_start(
         self, serialized: Dict[str, Any], inputs: Dict[str, Any], **kwargs: Any
@@ -61,15 +58,15 @@ def on_chain_start(
         with self._lock:
             self._callback_manager.on_chain_start(serialized, inputs, **kwargs)
 
-    def on_chain_end(self, outputs: Dict[str, Any]) -> None:
+    def on_chain_end(self, outputs: Dict[str, Any], **kwargs: Any) -> None:
         """Run when chain ends running."""
         with self._lock:
-            self._callback_manager.on_chain_end(outputs)
+            self._callback_manager.on_chain_end(outputs, **kwargs)
 
-    def on_chain_error(self, error: Exception) -> None:
+    def on_chain_error(self, error: Exception, **kwargs: Any) -> None:
         """Run when chain errors."""
         with self._lock:
-            self._callback_manager.on_chain_error(error)
+            self._callback_manager.on_chain_error(error, **kwargs)
 
     def on_tool_start(
         self, serialized: Dict[str, Any], action: AgentAction, **kwargs: Any
@@ -83,10 +80,10 @@ def on_tool_end(self, output: str, **kwargs: Any) -> None:
         with self._lock:
             self._callback_manager.on_tool_end(output, **kwargs)
 
-    def on_tool_error(self, error: Exception) -> None:
+    def on_tool_error(self, error: Exception, **kwargs: Any) -> None:
         """Run when tool errors."""
         with self._lock:
-            self._callback_manager.on_tool_error(error)
+            self._callback_manager.on_tool_error(error, **kwargs)
 
     def on_text(self, text: str, **kwargs: Any) -> None:
         """Run on arbitrary text."""

langchain/callbacks/stdout.py

@@ -15,11 +15,11 @@ def on_llm_start(
         """Print out the prompts."""
         pass
 
-    def on_llm_end(self, response: LLMResult) -> None:
+    def on_llm_end(self, response: LLMResult, **kwargs: Any) -> None:
         """Do nothing."""
         pass
 
-    def on_llm_error(self, error: Exception) -> None:
+    def on_llm_error(self, error: Exception, **kwargs: Any) -> None:
         """Do nothing."""
         pass
 
@@ -30,11 +30,11 @@ def on_chain_start(
         class_name = serialized["name"]
         print(f"\n\n\033[1m> Entering new {class_name} chain...\033[0m")
 
-    def on_chain_end(self, outputs: Dict[str, Any]) -> None:
+    def on_chain_end(self, outputs: Dict[str, Any], **kwargs: Any) -> None:
         """Print out that we finished a chain."""
         print("\n\033[1m> Finished chain.\033[0m")
 
-    def on_chain_error(self, error: Exception) -> None:
+    def on_chain_error(self, error: Exception, **kwargs: Any) -> None:
         """Do nothing."""
         pass
 
@@ -61,7 +61,7 @@ def on_tool_end(
         print_text(output, color=color)
         print_text(f"\n{llm_prefix}")
 
-    def on_tool_error(self, error: Exception) -> None:
+    def on_tool_error(self, error: Exception, **kwargs: Any) -> None:
         """Do nothing."""
         pass
 

langchain/callbacks/streamlit.py

@@ -18,11 +18,11 @@ def on_llm_start(
         for prompt in prompts:
             st.write(prompt)
 
-    def on_llm_end(self, response: LLMResult) -> None:
+    def on_llm_end(self, response: LLMResult, **kwargs: Any) -> None:
         """Do nothing."""
         pass
 
-    def on_llm_error(self, error: Exception) -> None:
+    def on_llm_error(self, error: Exception, **kwargs: Any) -> None:
         """Do nothing."""
         pass
 
@@ -33,11 +33,11 @@ def on_chain_start(
         class_name = serialized["name"]
         st.write(f"Entering new {class_name} chain...")
 
-    def on_chain_end(self, outputs: Dict[str, Any]) -> None:
+    def on_chain_end(self, outputs: Dict[str, Any], **kwargs: Any) -> None:
         """Print out that we finished a chain."""
         st.write("Finished chain.")
 
-    def on_chain_error(self, error: Exception) -> None:
+    def on_chain_error(self, error: Exception, **kwargs: Any) -> None:
         """Do nothing."""
         pass
 
@@ -62,7 +62,7 @@ def on_tool_end(
         st.write(f"{observation_prefix}{output}")
         st.write(llm_prefix)
 
-    def on_tool_error(self, error: Exception) -> None:
+    def on_tool_error(self, error: Exception, **kwargs: Any) -> None:
         """Do nothing."""
         pass
 

langchain/chains/api/base.py

@@ -66,11 +66,13 @@ def _call(self, inputs: Dict[str, str]) -> Dict[str, str]:
         api_url = self.api_request_chain.predict(
             question=question, api_docs=self.api_docs
         )
-        if self.verbose:
-            self.callback_manager.on_text(api_url, color="green", end="\n")
+        self.callback_manager.on_text(
+            api_url, color="green", end="\n", verbose=self.verbose
+        )
         api_response = self.requests_wrapper.run(api_url)
-        if self.verbose:
-            self.callback_manager.on_text(api_response, color="yellow", end="\n")
+        self.callback_manager.on_text(
+            api_response, color="yellow", end="\n", verbose=self.verbose
+        )
         answer = self.api_answer_chain.predict(
             question=question,
             api_docs=self.api_docs,