MindsDB 25.6.3.0__py3-none-any.whl → 25.6.3.1__py3-none-any.whl

mindsdb/__about__.py

@@ -1,6 +1,6 @@
 __title__ = "MindsDB"
 __package_name__ = "mindsdb"
-__version__ = "25.6.3.0"
+__version__ = "25.6.3.1"
 __description__ = "MindsDB's AI SQL Server enables developers to build AI tools that need access to real-time data to perform their tasks"
 __email__ = "jorge@mindsdb.com"
 __author__ = "MindsDB Inc"

mindsdb/api/executor/datahub/datanodes/project_datanode.py

@@ -154,7 +154,7 @@ class ProjectDataNode(DataNode):
 
                 return DataHubResponse(data_frame=df, columns=columns_info)
 
-            raise EntityNotExistsError(f"Can't select from {query_table} in project")
+            raise EntityNotExistsError(f"Can't select from <{query_table}> in project")
         else:
             raise NotImplementedError(f"Query not supported {query}")
 

mindsdb/api/executor/utilities/sql.py

@@ -64,26 +64,25 @@ def query_df_with_type_infer_fallback(query_str: str, dataframes: dict, user_fun
         pandas.columns
     """
 
-    for name, value in dataframes.items():
-        locals()[name] = value
-
-    con = duckdb.connect(database=":memory:")
-    if user_functions:
-        user_functions.register(con)
-
-    exception = None
-    for sample_size in [1000, 10000, 1000000]:
-        try:
-            con.execute(f"set global pandas_analyze_sample={sample_size};")
-            result_df = con.execute(query_str).fetchdf()
-        except InvalidInputException as e:
-            exception = e
+    with duckdb.connect(database=":memory:") as con:
+        if user_functions:
+            user_functions.register(con)
+
+        for name, value in dataframes.items():
+            con.register(name, value)
+
+        exception = None
+        for sample_size in [1000, 10000, 1000000]:
+            try:
+                con.execute(f"set global pandas_analyze_sample={sample_size};")
+                result_df = con.execute(query_str).fetchdf()
+            except InvalidInputException as e:
+                exception = e
+            else:
+                break
         else:
-            break
-    else:
-        raise exception
-    description = con.description
-    con.close()
+            raise exception
+        description = con.description
 
     return result_df, description
 

mindsdb/integrations/handlers/lindorm_handler/requirements.txt

@@ -1,3 +1,3 @@
 pyphoenix
 phoenixdb
-protobuf==3.20.3
+protobuf==4.25.8

mindsdb/interfaces/agents/mindsdb_database_agent.py

@@ -111,24 +111,12 @@ class MindsDBSQL(SQLDatabase):
             )
 
             # Convert ExecuteAnswer to a DataFrame for easier manipulation
-            df = None
-            if hasattr(result, "data") and hasattr(result.data, "data_frame"):
-                df = result.data.data_frame
+            if result.data is not None:
+                df = result.data.to_df()
+                return df.to_string(index=False)
+
             else:
-                # Fallback to to_df when data_frame attr not available
-                try:
-                    df = result.data.to_df()
-                except Exception:
-                    df = None
-
-            # Default behaviour (string)
-            if df is not None:
-                if not df.empty:
-                    return df.to_string(index=False)
-                else:
-                    return "Query executed successfully, but returned no data."
-
-            return str(result)
+                return "Query executed successfully, but returned no data."
 
         except Exception as e:
             logger.error(f"Error executing SQL command: {str(e)}\n{traceback.format_exc()}")

mindsdb/interfaces/knowledge_base/controller.py

@@ -9,6 +9,7 @@ import numpy as np
 
 from mindsdb_sql_parser.ast import BinaryOperation, Constant, Identifier, Select, Update, Delete, Star
 from mindsdb_sql_parser.ast.mindsdb import CreatePredictor
+from mindsdb_sql_parser import parse_sql
 
 from mindsdb.integrations.utilities.query_traversal import query_traversal
 
@@ -52,6 +53,13 @@ def get_model_params(model_params: dict, default_config_key: str):
     """
     Get model parameters by combining default config with user provided parameters.
     """
+    # If the default config key is for reranking and the switch to use the default LLM is enabled,
+    # switch to the default LLM model.
+    if default_config_key == "default_reranking_model" and config.get("default_reranking_model").get(
+        "use_default_llm", False
+    ):
+        default_config_key = "default_llm_model"
+
     combined_model_params = copy.deepcopy(config.get(default_config_key, {}))
 
     if model_params:
@@ -97,6 +105,8 @@ def get_reranking_model_from_params(reranking_model_params: dict):
         params_copy["api_key"] = get_api_key(provider, params_copy, strict=False)
     params_copy["model"] = params_copy.pop("model_name", None)
 
+    params_copy.pop("use_default_llm", None)
+
     return BaseLLMReranker(**params_copy)
 
 
@@ -359,23 +369,30 @@ class KnowledgeBaseTable:
 
     def insert_query_result(self, query: str, project_name: str):
         """Process and insert SQL query results"""
-        if not self.document_loader:
-            raise ValueError("Document loader not configured")
+        ast_query = parse_sql(query)
 
-        documents = list(self.document_loader.load_query_result(query, project_name))
-        if documents:
-            self.insert_documents(documents)
+        command_executor = ExecuteCommands(self.session)
+        response = command_executor.execute_command(ast_query, project_name)
+
+        if response.error_code is not None:
+            raise ValueError(f"Error executing query: {response.error_message}")
+
+        if response.data is None:
+            raise ValueError("Query returned no data")
+
+        records = response.data.records
+        df = pd.DataFrame(records)
+
+        self.insert(df)
 
     def insert_rows(self, rows: List[Dict]):
         """Process and insert raw data rows"""
         if not rows:
             return
 
-        documents = [
-            Document(content=row.get("content", ""), id=row.get("id"), metadata=row.get("metadata", {})) for row in rows
-        ]
+        df = pd.DataFrame(rows)
 
-        self.insert_documents(documents)
+        self.insert(df)
 
     def insert_documents(self, documents: List[Document]):
         """Process and insert documents with preprocessing if configured"""

mindsdb/interfaces/knowledge_base/preprocessing/document_loader.py

@@ -2,7 +2,6 @@ import os
 from typing import List, Iterator
 from langchain_core.documents import Document as LangchainDocument
 from langchain_text_splitters import MarkdownHeaderTextSplitter
-import pandas as pd
 
 from mindsdb.interfaces.file.file_controller import FileController
 from mindsdb.integrations.utilities.rag.loaders.file_loader import FileLoader
@@ -20,12 +19,12 @@ class DocumentLoader:
     """Handles loading documents from various sources including SQL queries"""
 
     def __init__(
-            self,
-            file_controller: FileController,
-            file_splitter: FileSplitter,
-            markdown_splitter: MarkdownHeaderTextSplitter,
-            file_loader_class=FileLoader,
-            mysql_proxy=None
+        self,
+        file_controller: FileController,
+        file_splitter: FileSplitter,
+        markdown_splitter: MarkdownHeaderTextSplitter,
+        file_loader_class=FileLoader,
+        mysql_proxy=None,
     ):
         """
         Initialize with required dependencies
@@ -52,8 +51,8 @@ class DocumentLoader:
             for doc in loader.lazy_load():
                 # Add file extension to metadata for proper splitting
                 extension = os.path.splitext(file_path)[1].lower()
-                doc.metadata['extension'] = extension
-                doc.metadata['source'] = file_name
+                doc.metadata["extension"] = extension
+                doc.metadata["source"] = file_name
 
                 # Use FileSplitter to handle the document based on its type
                 split_docs = self.file_splitter.split_documents([doc])
@@ -62,34 +61,22 @@ class DocumentLoader:
                     metadata = doc.metadata.copy()
                     metadata.update(split_doc.metadata or {})
 
-                    yield Document(
-                        content=split_doc.page_content,
-                        metadata=metadata
-                    )
+                    yield Document(content=split_doc.page_content, metadata=metadata)
 
     def load_web_pages(
-            self,
-            urls: List[str],
-            crawl_depth: int,
-            limit: int,
-            filters: List[str] = None,
+        self,
+        urls: List[str],
+        crawl_depth: int,
+        limit: int,
+        filters: List[str] = None,
     ) -> Iterator[Document]:
         """Load and split documents from web pages"""
-        websites_df = get_all_websites(
-            urls,
-            crawl_depth=crawl_depth,
-            limit=limit,
-            filters=filters
-        )
+        websites_df = get_all_websites(urls, crawl_depth=crawl_depth, limit=limit, filters=filters)
 
         for _, row in websites_df.iterrows():
             # Create a document with HTML extension for proper splitting
             doc = LangchainDocument(
-                page_content=row['text_content'],
-                metadata={
-                    'extension': '.html',
-                    'url': row['url']
-                }
+                page_content=row["text_content"], metadata={"extension": ".html", "url": row["url"]}
             )
 
             # Use FileSplitter to handle HTML content
@@ -98,60 +85,4 @@ class DocumentLoader:
                 metadata = doc.metadata.copy()
                 metadata.update(split_doc.metadata or {})
 
-                yield Document(
-                    content=split_doc.page_content,
-                    metadata=metadata
-                )
-
-    def load_query_result(self, query: str, project_name: str) -> Iterator[Document]:
-        """
-        Load documents from SQL query results
-
-        Args:
-            query: SQL query to execute
-            project_name: Name of the project context
-
-        Returns:
-            Iterator of Document objects
-
-        Raises:
-            ValueError: If mysql_proxy is not configured or query returns no data
-        """
-        if not self.mysql_proxy:
-            raise ValueError("MySQL proxy not configured")
-
-        if not query:
-            return
-
-        # Set project context and execute query
-        self.mysql_proxy.set_context({'db': project_name})
-        query_result = self.mysql_proxy.process_query(query)
-
-        if query_result.type != 'table':
-            raise ValueError('Query returned no data')
-
-        # Convert query result to DataFrame
-        df = query_result.data.to_df()
-
-        # Process each row into a Document
-        for _, row in df.iterrows():
-            # Extract id, content  and metadata
-            content = str(row.get('content', ''))
-            id = row.get('id', None)
-
-            # Convert remaining columns to metadata
-            metadata = {
-                col: str(row[col])
-                for col in df.columns
-                if col != 'content' and not pd.isna(row[col])
-            }
-            metadata['source'] = 'query'
-
-            # Split content using recursive splitter
-            if content:
-
-                yield Document(
-                    id=id,
-                    content=content,
-                    metadata=metadata
-                )
+                yield Document(content=split_doc.page_content, metadata=metadata)

mindsdb/interfaces/skills/custom/text2sql/mindsdb_kb_tools.py

@@ -3,6 +3,7 @@ import re
 import json
 from pydantic import BaseModel, Field
 from langchain_core.tools import BaseTool
+from mindsdb_sql_parser.ast import Describe, Select, Identifier, Constant, Star
 
 
 class KnowledgeBaseListToolInput(BaseModel):
@@ -55,6 +56,26 @@ class KnowledgeBaseInfoTool(BaseTool):
         except (json.JSONDecodeError, TypeError):
             pass
 
+        def strip(s):
+            length = -1
+            while length != len(s):
+                length = len(s)
+
+                # remove ```
+                if s.startswith("```"):
+                    s = s[3:]
+                if s.endswith("```"):
+                    s = s[:-3]
+
+                # remove trailing new lines
+                s = s.strip("\n")
+
+                # remove extra quotes
+                for q in ('"', "'", "`"):
+                    if s.count(q) == 1:
+                        s = s.strip(q)
+            return s
+
         # Finally, try the original regex pattern for $START$ and $STOP$ markers
         match = re.search(r"\$START\$(.*?)\$STOP\$", tool_input, re.DOTALL)
         if not match:
@@ -63,12 +84,14 @@ class KnowledgeBaseInfoTool(BaseTool):
                 return [kb.strip() for kb in tool_input.split(",")]
             # If it's just a single string without formatting, return it as a single item
             if tool_input.strip():
-                return [tool_input.strip()]
+                return [strip(tool_input)]
             return []
 
         # Extract and clean the knowledge base names
         kb_names_str = match.group(1).strip()
         kb_names = re.findall(r"`([^`]+)`", kb_names_str)
+
+        kb_names = [strip(n) for n in kb_names]
         return kb_names
 
     def _run(self, tool_input: str) -> str:
@@ -83,7 +106,7 @@ class KnowledgeBaseInfoTool(BaseTool):
         for kb_name in kb_names:
             try:
                 # Get knowledge base schema
-                schema_result = self.db.run_no_throw(f"DESCRIBE KNOWLEDGE_BASE `{kb_name}`;")
+                schema_result = self.db.run_no_throw(str(Describe(kb_name, type="knowledge_base")))
 
                 if not schema_result:
                     results.append(f"Knowledge base `{kb_name}` not found or has no schema information.")
@@ -111,7 +134,9 @@ class KnowledgeBaseInfoTool(BaseTool):
                 kb_info += "```\n\n"
 
                 # Get sample data
-                sample_data = self.db.run_no_throw(f"SELECT * FROM `{kb_name}` LIMIT 10;")
+                sample_data = self.db.run_no_throw(
+                    str(Select(targets=[Star()], from_table=Identifier(kb_name), limit=Constant(20)))
+                )
 
                 # Sample data
                 kb_info += "### Sample Data:\n"

mindsdb/interfaces/skills/sql_agent.py

@@ -76,7 +76,7 @@ def split_table_name(table_name: str) -> List[str]:
         result.append(current.strip("`"))
 
     # ensure we split the table name
-    result = [r.split(".") for r in result][0]
+    # result = [r.split(".") for r in result][0]
 
     return result