MindsDB 25.7.3.0__py3-none-any.whl → 25.8.2.0__py3-none-any.whl

mindsdb/interfaces/jobs/jobs_controller.py

@@ -21,29 +21,29 @@ from mindsdb.utilities import log
 
 logger = log.getLogger(__name__)
 
-default_project = config.get('default_project')
+default_project = config.get("default_project")
 
 
 def split_sql(sql):
     # split sql by ';' ignoring delimiter in quotes
-    pattern = re.compile(r'''((?:[^;"']|"[^"]*"|'[^']*')+)''')
+    pattern = re.compile(r"""((?:[^;"']|"[^"]*"|'[^']*')+)""")
     return pattern.split(sql)[1::2]
 
 
 def calc_next_date(schedule_str, base_date: dt.datetime):
     schedule_str = schedule_str.lower().strip()
 
-    repeat_prefix = 'every '
+    repeat_prefix = "every "
     if schedule_str.startswith(repeat_prefix):
-        repeat_str = schedule_str[len(repeat_prefix):]
+        repeat_str = schedule_str[len(repeat_prefix) :]
     else:
         # TODO cron format
-        raise NotImplementedError(f'Schedule: {schedule_str}')
+        raise NotImplementedError(f"Schedule: {schedule_str}")
 
     items = repeat_str.split()
 
     if len(items) == 1:
-        value = '1'
+        value = "1"
         period = items[0]
     elif len(items) == 2:
         value, period = items
@@ -53,15 +53,15 @@ def calc_next_date(schedule_str, base_date: dt.datetime):
     if not value.isdigit():
         raise Exception(f"Number expected: {value}")
     value = int(value)
-    if period in ('minute', 'minutes', 'min'):
+    if period in ("minute", "minutes", "min"):
         delta = dt.timedelta(minutes=value)
-    elif period in ('hour', 'hours'):
+    elif period in ("hour", "hours"):
         delta = dt.timedelta(hours=value)
-    elif period in ('day', 'days'):
+    elif period in ("day", "days"):
         delta = dt.timedelta(days=value)
-    elif period in ('week', 'weeks'):
+    elif period in ("week", "weeks"):
         delta = dt.timedelta(days=value * 7)  # 1 week = 7 days
-    elif period in ('month', 'months'):
+    elif period in ("month", "months"):
         delta = relativedelta(months=value)
     else:
         raise Exception(f"Unknown period: {period}")
@@ -85,10 +85,10 @@ def parse_job_date(date_str: str) -> dt.datetime:
     :return:
     """
 
-    if date_str.upper() == 'NOW':
+    if date_str.upper() == "NOW":
         return dt.datetime.now()
 
-    date_formats = ['%Y-%m-%d %H:%M:%S', '%Y-%m-%d']
+    date_formats = ["%Y-%m-%d %H:%M:%S", "%Y-%m-%d"]
     date = None
     for date_format in date_formats:
         try:
@@ -128,39 +128,41 @@ class JobsController:
             at the moment supports: 'every <number> <dimension>' or 'every <dimension>'
         :return: name of created job
         """
+        if not name.islower():
+            raise ValueError(f"The name must be in lower case: {name}")
 
         project_controller = ProjectController()
         project = project_controller.get(name=project_name)
 
         # check if exists
         if self.get(name, project_name) is not None:
-            raise EntityExistsError('Job already exists', name)
+            raise EntityExistsError("Job already exists", name)
 
         if start_at is None:
             start_at = dt.datetime.now()
 
         if end_at is not None and end_at < start_at:
-            raise Exception(f'Wrong end date {start_at} > {end_at}')
+            raise Exception(f"Wrong end date {start_at} > {end_at}")
 
         # check sql = try to parse it
         for sql in split_sql(query):
             try:
                 # replace template variables with null
-                sql = re.sub(r'\{\{[\w\d]+}}', "", sql)
+                sql = re.sub(r"\{\{[\w\d]+}}", "", sql)
 
                 parse_sql(sql)
             except ParsingException as e:
-                raise ParsingException(f'Unable to parse: {sql}: {e}')
+                raise ParsingException(f"Unable to parse: {sql}: {e}")
 
         if if_query is not None:
             for sql in split_sql(if_query):
                 try:
                     # replace template variables with null
-                    sql = re.sub(r'\{\{[\w\d]+}}', "", sql)
+                    sql = re.sub(r"\{\{[\w\d]+}}", "", sql)
 
                     parse_sql(sql)
                 except ParsingException as e:
-                    raise ParsingException(f'Unable to parse: {sql}: {e}')
+                    raise ParsingException(f"Unable to parse: {sql}: {e}")
 
         # plan next run
         next_run_at = start_at
@@ -185,7 +187,7 @@ class JobsController:
             start_at=start_at,
             end_at=end_at,
             next_run_at=next_run_at,
-            schedule_str=schedule_str
+            schedule_str=schedule_str,
         )
         db.session.add(record)
         db.session.commit()
@@ -219,10 +221,11 @@ class JobsController:
 
         schedule_str = None
         if query.repeat_str is not None:
-            schedule_str = 'every ' + query.repeat_str
+            schedule_str = "every " + query.repeat_str
 
         return self.add(
-            name, project_name,
+            name,
+            project_name,
             query=query_str,
             start_at=start_at,
             end_at=end_at,
@@ -231,36 +234,30 @@ class JobsController:
         )
 
     def delete(self, name, project_name):
-
         project_controller = ProjectController()
         project = project_controller.get(name=project_name)
 
         # check if exists
-        record = db.session.query(db.Jobs).filter_by(
-            company_id=ctx.company_id,
-            name=name,
-            project_id=project.id,
-            deleted_at=sa.null()
-        ).first()
+        record = (
+            db.session.query(db.Jobs)
+            .filter_by(company_id=ctx.company_id, name=name, project_id=project.id, deleted_at=sa.null())
+            .first()
+        )
         if record is None:
-            raise EntityNotExistsError('Job does not exist', name)
+            raise EntityNotExistsError("Job does not exist", name)
 
         self._delete_record(record)
         db.session.commit()
 
         # delete context
-        query_context_controller.drop_query_context('job', record.id)
-        query_context_controller.drop_query_context('job-if', record.id)
+        query_context_controller.drop_query_context("job", record.id)
+        query_context_controller.drop_query_context("job-if", record.id)
 
     def _delete_record(self, record):
         record.deleted_at = dt.datetime.now()
 
     def get_list(self, project_name=None):
-
-        query = db.session.query(db.Jobs).filter_by(
-            company_id=ctx.company_id,
-            deleted_at=sa.null()
-        )
+        query = db.session.query(db.Jobs).filter_by(company_id=ctx.company_id, deleted_at=sa.null())
 
         project_controller = ProjectController()
         if project_name is not None:
@@ -268,23 +265,22 @@ class JobsController:
             query = query.filter_by(project_id=project.id)
 
         data = []
-        project_names = {
-            i.id: i.name
-            for i in project_controller.get_list()
-        }
+        project_names = {i.id: i.name for i in project_controller.get_list()}
         for record in query:
-            data.append({
-                'id': record.id,
-                'name': record.name,
-                'project': project_names[record.project_id],
-                'start_at': record.start_at,
-                'end_at': record.end_at,
-                'next_run_at': record.next_run_at,
-                'schedule_str': record.schedule_str,
-                'query': record.query_str,
-                'if_query': record.if_query_str,
-                'variables': query_context_controller.get_context_vars('job', record.id)
-            })
+            data.append(
+                {
+                    "id": record.id,
+                    "name": record.name,
+                    "project": project_names[record.project_id],
+                    "start_at": record.start_at,
+                    "end_at": record.end_at,
+                    "next_run_at": record.next_run_at,
+                    "schedule_str": record.schedule_str,
+                    "query": record.query_str,
+                    "if_query": record.if_query_str,
+                    "variables": query_context_controller.get_context_vars("job", record.id),
+                }
+            )
         return data
 
     def get(self, name: str, project_name: str) -> dict:
@@ -298,25 +294,24 @@ class JobsController:
         project_controller = ProjectController()
         project = project_controller.get(name=project_name)
 
-        record = db.session.query(db.Jobs).filter_by(
-            company_id=ctx.company_id,
-            name=name,
-            project_id=project.id,
-            deleted_at=sa.null()
-        ).first()
+        record = (
+            db.session.query(db.Jobs)
+            .filter_by(company_id=ctx.company_id, name=name, project_id=project.id, deleted_at=sa.null())
+            .first()
+        )
 
         if record is not None:
             return {
-                'id': record.id,
-                'name': record.name,
-                'project': project_name,
-                'start_at': record.start_at,
-                'end_at': record.end_at,
-                'next_run_at': record.next_run_at,
-                'schedule_str': record.schedule_str,
-                'query': record.query_str,
-                'if_query': record.if_query_str,
-                'variables': query_context_controller.get_context_vars('job', record.id)
+                "id": record.id,
+                "name": record.name,
+                "project": project_name,
+                "start_at": record.start_at,
+                "end_at": record.end_at,
+                "next_run_at": record.next_run_at,
+                "schedule_str": record.schedule_str,
+                "query": record.query_str,
+                "if_query": record.if_query_str,
+                "variables": query_context_controller.get_context_vars("job", record.id),
             }
 
     def get_history(self, name: str, project_name: str) -> List[dict]:
@@ -331,27 +326,33 @@ class JobsController:
 
         query = Select(
             targets=[Star()],
-            from_table=Identifier('jobs_history'),
-            where=BinaryOperation(op='and', args=[
-                BinaryOperation(op='=', args=[Identifier('name'), Constant(name)]),
-                BinaryOperation(op='=', args=[Identifier('project'), Constant(project_name)])
-            ])
+            from_table=Identifier("jobs_history"),
+            where=BinaryOperation(
+                op="and",
+                args=[
+                    BinaryOperation(op="=", args=[Identifier("name"), Constant(name)]),
+                    BinaryOperation(op="=", args=[Identifier("project"), Constant(project_name)]),
+                ],
+            ),
         )
         response = logs_db_controller.query(query)
 
-        names = [i['name'] for i in response.columns]
-        return response.data_frame[names].to_dict(orient='records')
+        names = [i["name"] for i in response.columns]
+        return response.data_frame[names].to_dict(orient="records")
 
 
 class JobsExecutor:
-
     def get_next_tasks(self):
         # filter next_run < now
-        query = db.session.query(db.Jobs).filter(
-            db.Jobs.next_run_at < dt.datetime.now(),
-            db.Jobs.deleted_at == sa.null(),
-            db.Jobs.active == True,  # noqa
-        ).order_by(db.Jobs.next_run_at)
+        query = (
+            db.session.query(db.Jobs)
+            .filter(
+                db.Jobs.next_run_at < dt.datetime.now(),
+                db.Jobs.deleted_at == sa.null(),
+                db.Jobs.active == True,  # noqa
+            )
+            .order_by(db.Jobs.next_run_at)
+        )
 
         return query.all()
 
@@ -389,12 +390,7 @@ class JobsExecutor:
         record = db.Jobs.query.get(record_id)
 
         try:
-
-            history_record = db.JobsHistory(
-                job_id=record.id,
-                start_at=record.next_run_at,
-                company_id=record.company_id
-            )
+            history_record = db.JobsHistory(job_id=record.id, start_at=record.next_run_at, company_id=record.company_id)
 
             db.session.add(history_record)
             db.session.commit()
@@ -408,9 +404,7 @@ class JobsExecutor:
 
             # check if it is an old lock
             history_record = db.JobsHistory.query.filter_by(
-                job_id=record.id,
-                start_at=record.next_run_at,
-                company_id=record.company_id
+                job_id=record.id, start_at=record.next_run_at, company_id=record.company_id
             ).first()
             if history_record.updated_at < dt.datetime.now() - dt.timedelta(seconds=30):
                 db.session.delete(history_record)
@@ -419,13 +413,14 @@ class JobsExecutor:
         return None
 
     def __fill_variables(self, sql, record, history_record):
-        if '{{PREVIOUS_START_DATETIME}}' in sql:
+        if "{{PREVIOUS_START_DATETIME}}" in sql:
             # get previous run date
-            history_prev = db.session.query(db.JobsHistory.start_at) \
-                .filter(db.JobsHistory.job_id == record.id,
-                        db.JobsHistory.id != history_record.id) \
-                .order_by(db.JobsHistory.id.desc()) \
+            history_prev = (
+                db.session.query(db.JobsHistory.start_at)
+                .filter(db.JobsHistory.job_id == record.id, db.JobsHistory.id != history_record.id)
+                .order_by(db.JobsHistory.id.desc())
                 .first()
+            )
             if history_prev is None:
                 # start date of the job
                 value = record.created_at
@@ -433,18 +428,17 @@ class JobsExecutor:
                 # fix for twitter: created_at filter must be minimum of 10 seconds prior to the current time
                 value = history_prev.start_at - dt.timedelta(seconds=60)
             value = value.strftime("%Y-%m-%d %H:%M:%S")
-            sql = sql.replace('{{PREVIOUS_START_DATETIME}}', value)
+            sql = sql.replace("{{PREVIOUS_START_DATETIME}}", value)
 
-        if '{{START_DATE}}' in sql:
+        if "{{START_DATE}}" in sql:
             value = history_record.start_at.strftime("%Y-%m-%d")
-            sql = sql.replace('{{START_DATE}}', value)
-        if '{{START_DATETIME}}' in sql:
+            sql = sql.replace("{{START_DATE}}", value)
+        if "{{START_DATETIME}}" in sql:
             value = history_record.start_at.strftime("%Y-%m-%d %H:%M:%S")
-            sql = sql.replace('{{START_DATETIME}}', value)
+            sql = sql.replace("{{START_DATETIME}}", value)
         return sql
 
     def execute_task_local(self, record_id, history_id=None):
-
         record = db.Jobs.query.get(record_id)
 
         # set up environment
@@ -470,7 +464,7 @@ class JobsExecutor:
 
         project_controller = ProjectController()
         project = project_controller.get(record.project_id)
-        executed_sql = ''
+        executed_sql = ""
 
         from mindsdb.api.executor.controllers.session_controller import SessionController
         from mindsdb.api.executor.command_executor import ExecuteCommands
@@ -480,8 +474,8 @@ class JobsExecutor:
         command_executor = ExecuteCommands(sql_session)
 
         # job with condition?
-        query_context_controller.set_context('job-if', record.id)
-        error = ''
+        query_context_controller.set_context("job-if", record.id)
+        error = ""
         to_execute_query = True
         if record.if_query_str is not None:
             data = None
@@ -491,7 +485,7 @@ class JobsExecutor:
                     sql = self.__fill_variables(sql, record, history_record)
 
                     query = parse_sql(sql)
-                    executed_sql += sql + '; '
+                    executed_sql += sql + "; "
 
                     ret = command_executor.execute_command(query)
                     if ret.error_code is not None:
@@ -508,17 +502,16 @@ class JobsExecutor:
             if error or data is None or len(data) == 0:
                 to_execute_query = False
 
-        query_context_controller.release_context('job-if', record.id)
+        query_context_controller.release_context("job-if", record.id)
         if to_execute_query:
-
-            query_context_controller.set_context('job', record.id)
+            query_context_controller.set_context("job", record.id)
             for sql in split_sql(record.query_str):
                 try:
                     #  fill template variables
                     sql = self.__fill_variables(sql, record, history_record)
 
                     query = parse_sql(sql)
-                    executed_sql += sql + '; '
+                    executed_sql += sql + "; "
 
                     ret = command_executor.execute_command(query)
                     if ret.error_code is not None:

mindsdb/interfaces/knowledge_base/controller.py

@@ -60,6 +60,7 @@ class KnowledgeBaseInputParams(BaseModel):
     is_sparse: bool = False
     vector_size: int | None = None
     reranking_model: Dict[Text, Any] | None = None
+    preprocessing: Dict[Text, Any] | None = None
 
     class Config:
         extra = "forbid"
@@ -244,9 +245,9 @@ class KnowledgeBaseTable:
         keyword_search_cols_and_values = []
         query_text = None
         relevance_threshold = None
-        reranking_enabled_flag = True
         hybrid_search_enabled_flag = False
         query_conditions = db_handler.extract_conditions(query.where)
+        hybrid_search_alpha = None  # Default to None, meaning no alpha weighted blending
         if query_conditions is not None:
             for item in query_conditions:
                 if item.column == "relevance" and item.op.value == FilterOperator.GREATER_THAN_OR_EQUAL.value:
@@ -261,10 +262,8 @@ class KnowledgeBaseTable:
                         logger.error(error_msg)
                         raise ValueError(error_msg)
                 elif item.column == "reranking":
-                    reranking_enabled_flag = item.value
-                    # cast to boolean
-                    if isinstance(reranking_enabled_flag, str):
-                        reranking_enabled_flag = reranking_enabled_flag.lower() not in ("false")
+                    if item.value is False or (isinstance(item.value, str) and item.value.lower() == "false"):
+                        disable_reranking = True
                 elif item.column == "hybrid_search":
                     hybrid_search_enabled_flag = item.value
                     # cast to boolean
@@ -272,6 +271,14 @@ class KnowledgeBaseTable:
                         hybrid_search_enabled_flag = hybrid_search_enabled_flag.lower() not in ("false")
                     if item.value is False or (isinstance(item.value, str) and item.value.lower() == "false"):
                         disable_reranking = True
+                elif item.column == "hybrid_search_alpha":
+                    # validate item.value is a float
+                    if not isinstance(item.value, (float, int)):
+                        raise ValueError(f"Invalid hybrid_search_alpha value: {item.value}. Must be a float or int.")
+                    # validate hybrid search alpha is between 0 and 1
+                    if not (0 <= item.value <= 1):
+                        raise ValueError(f"Invalid hybrid_search_alpha value: {item.value}. Must be between 0 and 1.")
+                    hybrid_search_alpha = item.value
                 elif item.column == "relevance" and item.op.value != FilterOperator.GREATER_THAN_OR_EQUAL.value:
                     raise ValueError(
                         f"Invalid operator for relevance: {item.op.value}. Only GREATER_THAN_OR_EQUAL is allowed."
@@ -345,7 +352,15 @@ class KnowledgeBaseTable:
                         f"Keyword search returned different columns: {df_keyword_select.columns} "
                         f"than expected: {df.columns}"
                     )
+                if hybrid_search_alpha:
+                    df_keyword_select[TableField.DISTANCE.value] = (
+                        hybrid_search_alpha * df_keyword_select[TableField.DISTANCE.value]
+                    )
+                    df[TableField.DISTANCE.value] = (1 - hybrid_search_alpha) * df[TableField.DISTANCE.value]
                 df = pd.concat([df, df_keyword_select], ignore_index=True)
+                # sort by distance if distance column exists
+                if TableField.DISTANCE.value in df.columns:
+                    df = df.sort_values(by=TableField.DISTANCE.value, ascending=True)
                 # if chunk_id column exists remove duplicates based on chunk_id
                 if "chunk_id" in df.columns:
                     df = df.drop_duplicates(subset=["chunk_id"])
@@ -519,6 +534,9 @@ class KnowledgeBaseTable:
 
             query.update_columns[emb_col] = Constant(self._content_to_embeddings(content))
 
+        if "metadata" not in query.update_columns:
+            query.update_columns["metadata"] = Constant({})
+
         # TODO search content in where clause?
 
         # set table name
@@ -1010,6 +1028,9 @@ class KnowledgeBaseController:
         :param is_sparse: Whether to use sparse vectors for embeddings
         :param vector_size: Optional size specification for vectors, required when is_sparse=True
         """
+        if not name.islower():
+            raise ValueError(f"The name must be in lower case: {name}")
+
         # fill variables
         params = variables_controller.fill_parameters(params)
 
@@ -1118,8 +1139,14 @@ class KnowledgeBaseController:
         else:
             vector_db_name, vector_table_name = storage.parts
 
+        data_node = self.session.datahub.get(vector_db_name)
+        if data_node:
+            vector_store_handler = data_node.integration_handler
+        else:
+            raise ValueError(
+                f"Unable to find database named {vector_db_name}, please make sure {vector_db_name} is defined"
+            )
         # create table in vectordb before creating KB
-        vector_store_handler = self.session.datahub.get(vector_db_name).integration_handler
         vector_store_handler.create_table(vector_table_name)
         if keyword_search_enabled:
             vector_store_handler.add_full_text_index(vector_table_name, TableField.CONTENT.value)

mindsdb/interfaces/knowledge_base/evaluate.py

@@ -118,7 +118,8 @@ class EvaluateBase:
 
             dn, table_name = self._get_dn_table(query.from_table)
             query.from_table = table_name
-            query.limit = Constant(self.DEFAULT_SAMPLE_SIZE)
+            if query.limit is None:
+                query.limit = Constant(self.DEFAULT_SAMPLE_SIZE)
 
             response = dn.query(query=query, session=self.session)
             df = response.data_frame

mindsdb/interfaces/knowledge_base/executor.py

@@ -217,6 +217,17 @@ class KnowledgeBaseQueryExecutor:
                 f'Operator "{content_condition.op}" is not supported for condition: {content_condition}'
             )
 
+    @staticmethod
+    def to_include_content(content_condition: BinaryOperation) -> List[str]:
+        """
+        Handles positive conditions for content. Returns list of content values
+        """
+        if content_condition.op == "IN":
+            return [item.value for item in content_condition.args[1].items]
+
+        elif content_condition.op in ("=", "LIKE"):
+            return [content_condition.args[1].value]
+
     def to_excluded_ids(
         self, content_condition: BinaryOperation, other_conditions: List[BinaryOperation]
     ) -> Optional[List[str]]:
@@ -290,11 +301,17 @@ class KnowledgeBaseQueryExecutor:
             if len(content_filters) > 0:
                 content_filters2 = []
                 exclude_ids = set()
+                include_contents = set()
                 # exclude content conditions
                 for condition in content_filters:
                     ids = self.to_excluded_ids(condition, other_filters)
                     if ids is not None:
                         exclude_ids.update(ids)
+                        continue
+                    contents = self.to_include_content(condition)
+                    if contents is not None:
+                        include_contents.update(contents)
+                        continue
                     else:
                         # keep origin content filter
                         content_filters2.append(condition)
@@ -305,6 +322,13 @@ class KnowledgeBaseQueryExecutor:
                     condition = BinaryOperation(op="NOT IN", args=[Identifier(self.id_column), Tuple(values)])
                     other_filters.append(condition)
                 # execute content filters
+                if include_contents:
+                    content = " AND ".join(include_contents)
+                    result = self.execute_content_condition(
+                        BinaryOperation(op="=", args=[Identifier(self.content_column), Constant(content)]),
+                        other_filters,
+                    )
+                    results.append(result)
                 for condition in content_filters2:
                     result = self.execute_content_condition(condition, other_filters)
                     results.append(result)

mindsdb/interfaces/knowledge_base/preprocessing/document_preprocessor.py

@@ -4,8 +4,7 @@ import asyncio
 from typing import List, Dict, Optional, Any
 
 import pandas as pd
-from langchain_text_splitters import RecursiveCharacterTextSplitter
-from langchain_core.documents import Document as LangchainDocument
+from mindsdb.interfaces.knowledge_base.preprocessing.text_splitter import TextSplitter
 
 from mindsdb.integrations.utilities.rag.splitters.file_splitter import (
     FileSplitter,
@@ -22,7 +21,6 @@ from mindsdb.interfaces.knowledge_base.preprocessing.models import (
 )
 from mindsdb.utilities import log
 
-
 logger = log.getLogger(__name__)
 
 _DEFAULT_CONTENT_COLUMN_NAME = "content"
@@ -49,11 +47,10 @@ class DocumentPreprocessor:
         if self.splitter is None:
             raise ValueError("Splitter not configured")
 
-        # Convert to langchain Document for splitting
-        langchain_doc = LangchainDocument(page_content=doc.content, metadata=doc.metadata or {})
+        metadata = doc.metadata or {}
         # Split and convert back to our Document type
-        split_docs = self.splitter.split_documents([langchain_doc])
-        return [Document(content=split_doc.page_content, metadata=split_doc.metadata) for split_doc in split_docs]
+        split_texts = self.splitter.split_text(doc.content)
+        return [Document(content=text, metadata=metadata) for text in split_texts]
 
     def _get_source(self) -> str:
         """Get the source identifier for this preprocessor"""
@@ -266,16 +263,15 @@ Please give a short succinct context to situate this chunk within the overall do
 
 
 class TextChunkingPreprocessor(DocumentPreprocessor):
-    """Default text chunking preprocessor using RecursiveCharacterTextSplitter"""
+    """Default text chunking preprocessor using TextSplitter"""
 
     def __init__(self, config: Optional[TextChunkingConfig] = None):
         """Initialize with text chunking configuration"""
         super().__init__()
         self.config = config or TextChunkingConfig()
-        self.splitter = RecursiveCharacterTextSplitter(
+        self.splitter = TextSplitter(
             chunk_size=self.config.chunk_size,
             chunk_overlap=self.config.chunk_overlap,
-            length_function=self.config.length_function,
             separators=self.config.separators,
         )