MindsDB 25.2.3.0__py3-none-any.whl → 25.2.4.0__py3-none-any.whl

mindsdb/integrations/handlers/ray_serve_handler/ray_serve_handler.py

@@ -1,9 +1,11 @@
+import io
 import json
 
 import requests
 from typing import Dict, Optional
 
 import pandas as pd
+import pyarrow.parquet as pq
 
 from mindsdb.integrations.libs.base import BaseMLEngine
 
@@ -37,9 +39,17 @@ class RayServeHandler(BaseMLEngine):
         args['target'] = target
         self.model_storage.json_set('args', args)
         try:
-            resp = requests.post(args['train_url'],
-                                 json={'df': df.to_json(orient='records'), 'target': target},
-                                 headers={'content-type': 'application/json; format=pandas-records'})
+            if args.get('is_parquet', False):
+                buffer = io.BytesIO()
+                df.to_parquet(buffer)
+                resp = requests.post(args['train_url'],
+                                     files={"df": ("df", buffer.getvalue(), "application/octet-stream")},
+                                     data={"args": json.dumps(args), "target": target},
+                                     )
+            else:
+                resp = requests.post(args['train_url'],
+                                     json={'df': df.to_json(orient='records'), 'target': target, 'args': args},
+                                     headers={'content-type': 'application/json; format=pandas-records'})
         except requests.exceptions.InvalidSchema:
             raise Exception("Error: The URL provided for the training endpoint is invalid.")
 
@@ -59,14 +69,29 @@ class RayServeHandler(BaseMLEngine):
         args = {**(self.model_storage.json_get('args')), **args}  # merge incoming args
         pred_args = args.get('predict_params', {})
         args = {**args, **pred_args}  # merge pred_args
-        resp = requests.post(args['predict_url'],
-                             json={'df': df.to_json(orient='records'), 'pred_args': pred_args},
-                             headers={'content-type': 'application/json; format=pandas-records'})
-
+        if args.get('is_parquet', False):
+            buffer = io.BytesIO()
+            df.attrs['pred_args'] = pred_args
+            df.to_parquet(buffer)
+            resp = requests.post(args['predict_url'],
+                                 files={"df": ("df", buffer.getvalue(), "application/octet-stream")},
+                                 data={"pred_args": json.dumps(pred_args)},
+                                 )
+        else:
+            resp = requests.post(args['predict_url'],
+                                 json={'df': df.to_json(orient='records'), 'pred_args': pred_args},
+                                 headers={'content-type': 'application/json; format=pandas-records'})
         try:
-            response = resp.json()
+            if args.get('is_parquet', False):
+                buffer = io.BytesIO(resp.content)
+                table = pq.read_table(buffer)
+                response = table.to_pandas()
+            else:
+                response = resp.json()
         except json.JSONDecodeError:
             error = resp.text
+        except Exception:
+            error = 'Could not decode parquet.'
         else:
             if 'prediction' in response:
                 target = args['target']

mindsdb/integrations/handlers/web_handler/urlcrawl_helpers.py

@@ -220,8 +220,6 @@ def get_all_website_links_recursively(url, reviewed_urls, limit=None, crawl_dept
     if limit is not None:
         if len(reviewed_urls) >= limit:
             return reviewed_urls
-    if crawl_depth == current_depth:
-        return reviewed_urls
 
     if not filters:
         matches_filter = True
@@ -241,6 +239,9 @@ def get_all_website_links_recursively(url, reviewed_urls, limit=None, crawl_dept
                 "error": str(error_message),
             }
 
+    if crawl_depth is not None and crawl_depth == current_depth:
+        return reviewed_urls
+
     to_rev_url_list = []
 
     # create a list of new urls to review that don't exist in the already reviewed ones

mindsdb/integrations/handlers/web_handler/web_handler.py

@@ -1,62 +1,71 @@
+from typing import List
+
 import pandas as pd
 from mindsdb.integrations.libs.response import HandlerStatusResponse
-from mindsdb_sql_parser import ast
-from mindsdb.integrations.libs.api_handler import APIHandler, APITable
-from mindsdb.utilities.config import Config
-from mindsdb.integrations.utilities.sql_utils import extract_comparison_conditions, project_dataframe
+from mindsdb.utilities.config import config
 from mindsdb.utilities.security import validate_urls
 from .urlcrawl_helpers import get_all_websites
 
+from mindsdb.integrations.libs.api_handler import APIResource, APIHandler
+from mindsdb.integrations.utilities.sql_utils import (FilterCondition, FilterOperator)
 
-class CrawlerTable(APITable):
 
-    def __init__(self, handler: APIHandler):
-        super().__init__(handler)
-        self.config = Config()
+class CrawlerTable(APIResource):
 
-    def select(self, query: ast.Select) -> pd.DataFrame:
+    def list(
+            self,
+            conditions: List[FilterCondition] = None,
+            limit: int = None,
+            **kwargs
+    ) -> pd.DataFrame:
         """
         Selects data from the provided websites
 
-        Args:
-            query (ast.Select): Given SQL SELECT query
-
         Returns:
             dataframe: Dataframe containing the crawled data
 
         Raises:
             NotImplementedError: If the query is not supported
         """
-        conditions = extract_comparison_conditions(query.where)
         urls = []
-        for operator, arg1, arg2 in conditions:
-            if operator == 'or':
-                raise NotImplementedError('OR is not supported')
-            if arg1 == 'url':
-                if operator in ['=', 'in']:
-                    urls = [str(arg2)] if isinstance(arg2, str) else arg2
-                else:
-                    raise NotImplementedError('Invalid URL format. Please provide a single URL like url = "example.com" or'
-                                              'multiple URLs using the format url IN ("url1", "url2", ...)')
+        crawl_depth = None
+        per_url_limit = None
+        for condition in conditions:
+            if condition.column == 'url':
+                if condition.op == FilterOperator.IN:
+                    urls = condition.value
+                elif condition.op == FilterOperator.EQUAL:
+                    urls = [condition.value]
+                condition.applied = True
+            if condition.column == 'crawl_depth' and condition.op == FilterOperator.EQUAL:
+                crawl_depth = condition.value
+                condition.applied = True
+            if condition.column == 'per_url_limit' and condition.op == FilterOperator.EQUAL:
+                per_url_limit = condition.value
+                condition.applied = True
 
         if len(urls) == 0:
             raise NotImplementedError(
-                'You must specify what url you want to crawl, for example: SELECT * FROM crawl WHERE url = "someurl"')
+                'You must specify what url you want to crawl, for example: SELECT * FROM web.crawler WHERE url = "someurl"')
 
-        allowed_urls = self.config.get('web_crawling_allowed_sites', [])
+        allowed_urls = config.get('web_crawling_allowed_sites', [])
         if allowed_urls and not validate_urls(urls, allowed_urls):
             raise ValueError(f"The provided URL is not allowed for web crawling. Please use any of {', '.join(allowed_urls)}.")
 
-        if query.limit is None:
-            raise NotImplementedError('You must specify a LIMIT clause which defines the number of pages to crawl')
-
-        limit = query.limit.value
-
-        result = get_all_websites(urls, limit, html=False)
-        if len(result) > limit:
+        if limit is None and per_url_limit is None and crawl_depth is None:
+            per_url_limit = 1
+        if per_url_limit is not None:
+            # crawl every url separately
+            results = []
+            for url in urls:
+                results.append(get_all_websites([url], per_url_limit, crawl_depth=crawl_depth))
+            result = pd.concat(results)
+        else:
+            result = get_all_websites(urls, limit, crawl_depth=crawl_depth)
+
+        if limit is not None and len(result) > limit:
             result = result[:limit]
-        # filter targets
-        result = project_dataframe(result, query.targets, self.get_columns())
+
         return result
 
     def get_columns(self):

mindsdb/integrations/handlers/youtube_handler/__init__.py

@@ -5,6 +5,7 @@ from .__about__ import __version__ as version, __description__ as description
 
 try:
     from .youtube_handler import YoutubeHandler as Handler
+    from .connection_args import connection_args
     import_error = None
 except Exception as e:
     Handler = None
@@ -24,4 +25,5 @@ __all__ = [
     "description",
     "import_error",
     "icon_path",
+    "connection_args",
 ]

mindsdb/integrations/handlers/youtube_handler/connection_args.py

@@ -0,0 +1,32 @@
+from collections import OrderedDict
+
+from mindsdb.integrations.libs.const import HANDLER_CONNECTION_ARG_TYPE as ARG_TYPE
+
+
+connection_args = OrderedDict(
+    youtube_api_token={
+        'type': ARG_TYPE.STR,
+        'description': 'Youtube API Token',
+        'label': 'Youtube API Token',
+    },
+    credentials_url={
+        'type': ARG_TYPE.STR,
+        'description': 'URL to Service Account Keys',
+        'label': 'URL to Service Account Keys',
+    },
+    credentials_file={
+        'type': ARG_TYPE.STR,
+        'description': 'Location of Service Account Keys',
+        'label': 'Path to Service Account Keys',
+    },
+    credentials={
+        'type': ARG_TYPE.PATH,
+        'description': 'Service Account Keys',
+        'label': 'Upload Service Account Keys',
+    },
+    code={
+        'type': ARG_TYPE.STR,
+        'description': 'Code After Authorisation',
+        'label': 'Code After Authorisation',
+    },
+)

mindsdb/integrations/libs/llm/utils.py

@@ -115,6 +115,11 @@ def get_llm_config(provider: str, args: Dict) -> BaseLLMConfig:
     """
     temperature = min(1.0, max(0.0, args.get("temperature", 0.0)))
     if provider == "openai":
+
+        if any(x in args.get("model_name", "") for x in ['o1', 'o3']):
+            # for o1 and 03, 'temperature' does not support 0.0 with this model. Only the default (1) value is supported
+            temperature = 1
+
         return OpenAIConfig(
             model_name=args.get("model_name", DEFAULT_OPENAI_MODEL),
             temperature=temperature,

mindsdb/integrations/libs/process_cache.py

@@ -186,7 +186,6 @@ class ProcessCache:
         self._keep_alive = {}
         self._stop_event = threading.Event()
         self.cleaner_thread = None
-        self._start_clean()
 
     def __del__(self):
         self._stop_clean()
@@ -200,7 +199,7 @@ class ProcessCache:
         ):
             return
         self._stop_event.clear()
-        self.cleaner_thread = threading.Thread(target=self._clean)
+        self.cleaner_thread = threading.Thread(target=self._clean, name='ProcessCache.clean')
         self.cleaner_thread.daemon = True
         self.cleaner_thread.start()
 
@@ -258,6 +257,7 @@ class ProcessCache:
             Returns:
                 Future
         """
+        self._start_clean()
         handler_module_path = payload['handler_meta']['module_path']
         integration_id = payload['handler_meta']['integration_id']
         if task_type in (ML_TASK_TYPE.LEARN, ML_TASK_TYPE.FINETUNE):

mindsdb/integrations/utilities/rag/chains/local_context_summarizer_chain.py

@@ -0,0 +1,227 @@
+import asyncio
+from collections import namedtuple
+from typing import Any, Dict, List, Optional
+
+from mindsdb.interfaces.agents.langchain_agent import create_chat_model
+from langchain.chains.base import Chain
+from langchain.chains.combine_documents.stuff import StuffDocumentsChain
+from langchain.chains.llm import LLMChain
+from langchain.chains.combine_documents.map_reduce import MapReduceDocumentsChain, ReduceDocumentsChain
+from langchain_core.callbacks import dispatch_custom_event
+from langchain_core.callbacks.manager import CallbackManagerForChainRun
+from langchain_core.documents import Document
+from langchain_core.prompts import PromptTemplate
+from pandas import DataFrame
+
+from mindsdb.integrations.libs.vectordatabase_handler import VectorStoreHandler
+from mindsdb.integrations.utilities.rag.settings import SummarizationConfig
+from mindsdb.integrations.utilities.sql_utils import FilterCondition, FilterOperator
+from mindsdb.utilities import log
+
+logger = log.getLogger(__name__)
+
+Summary = namedtuple('Summary', ['source_id', 'content'])
+
+
+def create_map_reduce_documents_chain(summarization_config: SummarizationConfig, input: str) -> ReduceDocumentsChain:
+    """Creates a chain that map-reduces documents into a single consolidated summary."""
+    summarization_llm = create_chat_model({
+        'model_name': summarization_config.llm_config.model_name,
+        'provider': summarization_config.llm_config.provider,
+        **summarization_config.llm_config.params
+    })
+
+    reduce_prompt_template = summarization_config.reduce_prompt_template
+    reduce_prompt = PromptTemplate.from_template(reduce_prompt_template)
+    if 'input' in reduce_prompt.input_variables:
+        reduce_prompt = reduce_prompt.partial(input=input)
+
+    reduce_chain = LLMChain(llm=summarization_llm, prompt=reduce_prompt)
+
+    combine_documents_chain = StuffDocumentsChain(
+        llm_chain=reduce_chain,
+        document_variable_name='docs'
+    )
+
+    return ReduceDocumentsChain(
+        combine_documents_chain=combine_documents_chain,
+        collapse_documents_chain=combine_documents_chain,
+        token_max=summarization_config.max_summarization_tokens
+    )
+
+
+class LocalContextSummarizerChain(Chain):
+    """Summarizes M chunks before and after a given chunk in a document."""
+
+    doc_id_key: str = 'original_row_id'
+    chunk_index_key: str = 'chunk_index'
+
+    vector_store_handler: VectorStoreHandler
+    table_name: str = 'embeddings'
+    content_column_name: str = 'content'
+    metadata_column_name: str = 'metadata'
+
+    summarization_config: SummarizationConfig
+    map_reduce_documents_chain: Optional[ReduceDocumentsChain] = None
+
+    def _select_chunks_from_vector_store(self, doc_id: str) -> DataFrame:
+        condition = FilterCondition(
+            f"{self.metadata_column_name}->>'{self.doc_id_key}'",
+            FilterOperator.EQUAL,
+            doc_id
+        )
+        return self.vector_store_handler.select(
+            self.table_name,
+            columns=[self.content_column_name, self.metadata_column_name],
+            conditions=[condition]
+        )
+
+    async def _get_all_chunks_for_document(self, doc_id: str) -> List[Document]:
+        df = await asyncio.get_event_loop().run_in_executor(
+            None, self._select_chunks_from_vector_store, doc_id
+        )
+        chunks = []
+        for _, row in df.iterrows():
+            metadata = row.get(self.metadata_column_name, {})
+            metadata[self.chunk_index_key] = row.get('chunk_id', 0)
+            chunks.append(Document(page_content=row[self.content_column_name], metadata=metadata))
+
+        return sorted(chunks, key=lambda x: x.metadata.get(self.chunk_index_key, 0))
+
+    async def summarize_local_context(self, doc_id: str, target_chunk_index: int, M: int) -> Summary:
+        """
+        Summarizes M chunks before and after the given chunk.
+
+        Args:
+            doc_id (str): Document ID.
+            target_chunk_index (int): Index of the chunk to summarize around.
+            M (int): Number of chunks before and after to include.
+
+        Returns:
+            Summary: Summary object containing source_id and summary content.
+        """
+        logger.debug(f"Fetching chunks for document {doc_id}")
+        all_chunks = await self._get_all_chunks_for_document(doc_id)
+
+        if not all_chunks:
+            logger.warning(f"No chunks found for document {doc_id}")
+            return Summary(source_id=doc_id, content='')
+
+        # Determine window boundaries
+        start_idx = max(0, target_chunk_index - M)
+        end_idx = min(len(all_chunks), target_chunk_index + M + 1)
+        local_chunks = all_chunks[start_idx:end_idx]
+
+        logger.debug(f"Summarizing chunks {start_idx} to {end_idx - 1} for document {doc_id}")
+
+        if not self.map_reduce_documents_chain:
+            self.map_reduce_documents_chain = create_map_reduce_documents_chain(
+                self.summarization_config, input="Summarize these chunks."
+            )
+
+        summary_result = await self.map_reduce_documents_chain.ainvoke(local_chunks)
+        summary_text = summary_result.get('output_text', '')
+
+        logger.debug(f"Generated summary: {summary_text[:100]}...")
+
+        return Summary(source_id=doc_id, content=summary_text)
+
+    @property
+    def input_keys(self) -> List[str]:
+        return [self.context_key, self.question_key]
+
+    @property
+    def output_keys(self) -> List[str]:
+        return [self.context_key, self.question_key]
+
+    async def _get_source_summary(self, source_id: str, map_reduce_documents_chain: MapReduceDocumentsChain) -> Summary:
+        if not source_id:
+            logger.warning("Received empty source_id, returning empty summary")
+            return Summary(source_id='', content='')
+
+        logger.debug(f"Getting summary for source ID: {source_id}")
+        source_chunks = await self._get_all_chunks_for_document(source_id)
+
+        if not source_chunks:
+            logger.warning(f"No chunks found for source ID: {source_id}")
+            return Summary(source_id=source_id, content='')
+
+        logger.debug(f"Summarizing {len(source_chunks)} chunks for source ID: {source_id}")
+        summary = await map_reduce_documents_chain.ainvoke(source_chunks)
+        content = summary.get('output_text', '')
+        logger.debug(f"Generated summary for source ID {source_id}: {content[:100]}...")
+
+        # Stream summarization update.
+        dispatch_custom_event('summary', {'source_id': source_id, 'content': content})
+
+        return Summary(source_id=source_id, content=content)
+
+    async def _get_source_summaries(self, source_ids: List[str], map_reduce_documents_chain: MapReduceDocumentsChain) -> \
+            List[Summary]:
+        summaries = await asyncio.gather(
+            *[self._get_source_summary(source_id, map_reduce_documents_chain) for source_id in source_ids]
+        )
+        return summaries
+
+    def _call(
+            self,
+            inputs: Dict[str, Any],
+            run_manager: Optional[CallbackManagerForChainRun] = None
+    ) -> Dict[str, Any]:
+        # Step 1: Connect to vector store to ensure embeddings are accessible
+        self.vector_store_handler.connect()
+
+        context_chunks: List[Document] = inputs.get(self.context_key, [])
+        logger.debug(f"Found {len(context_chunks)} context chunks.")
+
+        # Step 2: Extract unique document IDs from the provided chunks
+        unique_document_ids = self._get_document_ids_from_chunks(context_chunks)
+        logger.debug(f"Extracted {len(unique_document_ids)} unique document IDs: {unique_document_ids}")
+
+        # Step 3: Initialize the summarization chain if not provided
+        question = inputs.get(self.question_key, '')
+        map_reduce_documents_chain = self.map_reduce_documents_chain or create_map_reduce_documents_chain(
+            self.summarization_config, question
+        )
+
+        # Step 4: Dispatch event to signal summarization start
+        if run_manager:
+            run_manager.on_text("Starting summarization for documents.", verbose=True)
+
+        # Step 5: Process each document ID to summarize chunks with local context
+        for doc_id in unique_document_ids:
+            logger.debug(f"Fetching and summarizing chunks for document ID: {doc_id}")
+
+            # Fetch all chunks for the document
+            chunks = asyncio.get_event_loop().run_until_complete(self._get_all_chunks_for_document(doc_id))
+            if not chunks:
+                logger.warning(f"No chunks found for document ID: {doc_id}")
+                continue
+
+            # Summarize each chunk with M neighboring chunks
+            M = self.neighbor_window
+            for i, chunk in enumerate(chunks):
+                window_chunks = chunks[max(0, i - M): min(len(chunks), i + M + 1)]
+                local_summary = asyncio.get_event_loop().run_until_complete(
+                    map_reduce_documents_chain.ainvoke(window_chunks)
+                )
+                chunk.metadata['summary'] = local_summary.get('output_text', '')
+                logger.debug(f"Chunk {i} summary: {chunk.metadata['summary'][:100]}...")
+
+        # Step 6: Update the original context chunks with the newly generated summaries
+        for chunk in context_chunks:
+            doc_id = str(chunk.metadata.get(self.doc_id_key, ''))
+            matching_chunk = next((c for c in chunks if c.metadata.get(self.doc_id_key) == doc_id and c.metadata.get(
+                'chunk_index') == chunk.metadata.get('chunk_index')), None)
+            if matching_chunk:
+                chunk.metadata['summary'] = matching_chunk.metadata.get('summary', '')
+            else:
+                chunk.metadata['summary'] = ''
+                logger.warning(f"No matching chunk found for doc_id: {doc_id}")
+
+        # Step 7: Signal summarization end
+        if run_manager:
+            run_manager.on_text("Summarization completed.", verbose=True)
+
+        logger.debug(f"Updated {len(context_chunks)} context chunks with summaries.")
+        return inputs

mindsdb/interfaces/agents/agents_controller.py

@@ -256,9 +256,9 @@ class AgentsController:
         if (
             is_demo and (
                 (name is not None and name != agent_name)
-                or (model_name or provider)
-                or (len(skills_to_add) > 0 or len(skills_to_remove) > 0 or len(skills_to_rewrite) > 0)
-                or (isinstance(params, dict) and len(params) > 1 and 'prompt_template' not in params)
+                or (model_name is not None and existing_agent.model_name != model_name)
+                or (provider is not None and existing_agent.provider != provider)
+                or (isinstance(params, dict) and len(params) > 0 and 'prompt_template' not in params)
             )
         ):
             raise ValueError("It is forbidden to change properties of the demo object")

mindsdb/interfaces/agents/callback_handlers.py

@@ -1,9 +1,13 @@
-from typing import Any, Dict, List, Union
+import io
 import logging
+import contextlib
+from typing import Any, Dict, List, Union, Callable
+
 from langchain_core.agents import AgentAction, AgentFinish
 from langchain_core.callbacks.base import BaseCallbackHandler
 from langchain_core.messages.base import BaseMessage
 from langchain_core.outputs import LLMResult
+from langchain_core.callbacks import StdOutCallbackHandler
 
 
 class ContextCaptureCallback(BaseCallbackHandler):
@@ -20,14 +24,49 @@ class ContextCaptureCallback(BaseCallbackHandler):
         return self.context
 
 
+class VerboseLogCallbackHandler(StdOutCallbackHandler):
+    def __init__(self, logger: logging.Logger, verbose: bool):
+        self.logger = logger
+        self.verbose = verbose
+        super().__init__()
+
+    def __call(self, method: Callable, *args: List[Any], **kwargs: Any) -> Any:
+        if self.verbose is False:
+            return
+        f = io.StringIO()
+        with contextlib.redirect_stdout(f):
+            method(*args, **kwargs)
+        output = f.getvalue()
+        self.logger.info(output)
+
+    def on_chain_start(self, *args: List[Any], **kwargs: Any) -> None:
+        self.__call(super().on_chain_start, *args, **kwargs)
+
+    def on_chain_end(self, *args: List[Any], **kwargs: Any) -> None:
+        self.__call(super().on_chain_end, *args, **kwargs)
+
+    def on_agent_action(self, *args: List[Any], **kwargs: Any) -> None:
+        self.__call(super().on_agent_action, *args, **kwargs)
+
+    def on_tool_end(self, *args: List[Any], **kwargs: Any) -> None:
+        self.__call(super().on_tool_end, *args, **kwargs)
+
+    def on_text(self, *args: List[Any], **kwargs: Any) -> None:
+        self.__call(super().on_text, *args, **kwargs)
+
+    def on_agent_finish(self, *args: List[Any], **kwargs: Any) -> None:
+        self.__call(super().on_agent_finish, *args, **kwargs)
+
+
 class LogCallbackHandler(BaseCallbackHandler):
     '''Langchain callback handler that logs agent and chain executions.'''
 
-    def __init__(self, logger: logging.Logger):
+    def __init__(self, logger: logging.Logger, verbose: bool = True):
         logger.setLevel('DEBUG')
         self.logger = logger
         self._num_running_chains = 0
         self.generated_sql = None
+        self.verbose_log_handler = VerboseLogCallbackHandler(logger, verbose)
 
     def on_llm_start(
         self, serialized: Dict[str, Any], prompts: List[str], **kwargs: Any
@@ -36,6 +75,7 @@ class LogCallbackHandler(BaseCallbackHandler):
         self.logger.debug('LLM started with prompts:')
         for prompt in prompts:
             self.logger.debug(prompt[:50])
+        self.verbose_log_handler.on_llm_start(serialized, prompts, **kwargs)
 
     def on_chat_model_start(
             self,
@@ -46,7 +86,7 @@ class LogCallbackHandler(BaseCallbackHandler):
         self.logger.debug('Chat model started with messages:')
         for message_list in messages:
             for message in message_list:
-                self.logger.debug(message.pretty_print())
+                self.logger.debug(message.pretty_repr())
 
     def on_llm_new_token(self, token: str, **kwargs: Any) -> Any:
         '''Run on new LLM token. Only available when streaming is enabled.'''
@@ -72,6 +112,8 @@ class LogCallbackHandler(BaseCallbackHandler):
             self._num_running_chains))
         self.logger.debug('Inputs: {}'.format(inputs))
 
+        self.verbose_log_handler.on_chain_start(serialized=serialized, inputs=inputs, **kwargs)
+
     def on_chain_end(self, outputs: Dict[str, Any], **kwargs: Any) -> Any:
         '''Run when chain ends running.'''
         self._num_running_chains -= 1
@@ -79,6 +121,8 @@ class LogCallbackHandler(BaseCallbackHandler):
             self._num_running_chains))
         self.logger.debug('Outputs: {}'.format(outputs))
 
+        self.verbose_log_handler.on_chain_end(outputs=outputs, **kwargs)
+
     def on_chain_error(
         self, error: Union[Exception, KeyboardInterrupt], **kwargs: Any
     ) -> Any:
@@ -96,7 +140,7 @@ class LogCallbackHandler(BaseCallbackHandler):
 
     def on_tool_end(self, output: str, **kwargs: Any) -> Any:
         '''Run when tool ends running.'''
-        pass
+        self.verbose_log_handler.on_tool_end(output=output, **kwargs)
 
     def on_tool_error(
         self, error: Union[Exception, KeyboardInterrupt], **kwargs: Any
@@ -106,7 +150,7 @@ class LogCallbackHandler(BaseCallbackHandler):
 
     def on_text(self, text: str, **kwargs: Any) -> Any:
         '''Run on arbitrary text.'''
-        pass
+        self.verbose_log_handler.on_text(text=text, **kwargs)
 
     def on_agent_action(self, action: AgentAction, **kwargs: Any) -> Any:
         '''Run on agent action.'''
@@ -124,7 +168,10 @@ class LogCallbackHandler(BaseCallbackHandler):
         # fix for mistral
         action.tool = action.tool.replace('\\', '')
 
+        self.verbose_log_handler.on_agent_action(action=action, **kwargs)
+
     def on_agent_finish(self, finish: AgentFinish, **kwargs: Any) -> Any:
         '''Run on agent end.'''
         self.logger.debug('Agent finished with return values:')
         self.logger.debug(str(finish.return_values))
+        self.verbose_log_handler.on_agent_finish(finish=finish, **kwargs)