MindsDB 25.1.4.0__py3-none-any.whl → 25.1.5.1__py3-none-any.whl

mindsdb/integrations/utilities/rag/settings.py

@@ -3,7 +3,6 @@ from typing import List, Union, Any, Optional, Dict
 
 from langchain_community.vectorstores.chroma import Chroma
 from langchain_community.vectorstores.pgvector import PGVector
-from langchain_community.tools.sql_database.prompt import QUERY_CHECKER as DEFAULT_QUERY_CHECKER_PROMPT_TEMPLATE
 from langchain_core.documents import Document
 from langchain_core.embeddings import Embeddings
 from langchain_core.language_models import BaseChatModel
@@ -94,6 +93,25 @@ Output only a single better search query and nothing else like in the example.
 Here is the user input: {input}
 '''
 
+DEFAULT_METADATA_FILTERS_PROMPT_TEMPLATE = '''Construct a list of PostgreSQL metadata filters to filter documents in the database based on the user input.
+
+<< INSTRUCTIONS >>
+{format_instructions}
+
+RETURN ONLY THE FINAL JSON. DO NOT EXPLAIN, JUST RETURN THE FINAL JSON.
+
+<< TABLES YOU HAVE ACCESS TO >>
+
+{schema}
+
+<< EXAMPLES >>
+
+{examples}
+
+Here is the user input:
+{input}
+'''
+
 DEFAULT_SQL_PROMPT_TEMPLATE = '''
 Construct a valid {dialect} SQL query to select documents relevant to the user input.
 Source documents are found in the {source_table} table. You may need to join with other tables to get additional document metadata.
@@ -377,6 +395,13 @@ class MetadataSchema(BaseModel):
     columns: List[ColumnSchema] = Field(
         description="List of column schemas describing the metadata columns available for the table"
     )
+    join: str = Field(
+        description="SQL join string to join this table with source documents table",
+        default=''
+    )
+
+    class Config:
+        frozen = True
 
 
 class LLMExample(BaseModel):
@@ -393,19 +418,9 @@ class SQLRetrieverConfig(BaseModel):
         default_factory=LLMConfig,
         description="LLM configuration to use for generating the final SQL query for retrieval"
     )
-    sql_prompt_template: str = Field(
-        default=DEFAULT_SQL_PROMPT_TEMPLATE,
-        description="""Prompt template to generate the SQL query to execute against the vector database. Currently only pgvector is supported.
-        Has 'dialect', 'input', 'embeddings_table', 'source_table', 'embeddings', 'distance_function', 'schema', and 'examples' input variables.
-        """
-    )
-    query_checker_template: str = Field(
-        default=DEFAULT_QUERY_CHECKER_PROMPT_TEMPLATE,
-        description="Prompt template to use for double checking SQL queries before execution. Has 'query' and 'dialect' input variables."
-    )
-    query_retry_template: str = Field(
-        default=DEFAULT_QUERY_RETRY_PROMPT_TEMPLATE,
-        description="Prompt template to rewrite SQL query that failed. Has 'dialect', 'query', and 'error' input variables."
+    metadata_filters_prompt_template: str = Field(
+        default=DEFAULT_METADATA_FILTERS_PROMPT_TEMPLATE,
+        description="Prompt template to generate PostgreSQL metadata filters. Has 'format_instructions', 'schema', 'examples', and 'input' input variables"
     )
     num_retries: int = Field(
         default=DEFAULT_NUM_QUERY_RETRIES,

mindsdb/interfaces/agents/agents_controller.py

@@ -1,5 +1,5 @@
 import datetime
-from typing import Dict, Iterator, List, Union, Tuple
+from typing import Dict, Iterator, List, Union, Tuple, Optional
 
 from langchain_core.tools import BaseTool
 from sqlalchemy.orm.attributes import flag_modified
@@ -70,7 +70,7 @@ class AgentsController:
 
         return model, provider
 
-    def get_agent(self, agent_name: str, project_name: str = 'mindsdb') -> db.Agents:
+    def get_agent(self, agent_name: str, project_name: str = 'mindsdb') -> Optional[db.Agents]:
         '''
         Gets an agent by name.
 
@@ -79,7 +79,7 @@ class AgentsController:
             project_name (str): The name of the containing project - must exist
 
         Returns:
-            agent (db.Agents): The database agent object
+            agent (Optional[db.Agents]): The database agent object
         '''
 
         project = self.project_controller.get(name=project_name)
@@ -252,6 +252,16 @@ class AgentsController:
         existing_agent = self.get_agent(agent_name, project_name=project_name)
         if existing_agent is None:
             raise EntityNotExistsError(f'Agent with name not found: {agent_name}')
+        is_demo = (existing_agent.params or {}).get('is_demo', False)
+        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)
+            )
+        ):
+            raise ValueError("It is forbidden to change properties of the demo object")
 
         if name is not None and name != agent_name:
             # Check to see if updated name already exists
@@ -352,6 +362,8 @@ class AgentsController:
         agent = self.get_agent(agent_name, project_name)
         if agent is None:
             raise ValueError(f'Agent with name does not exist: {agent_name}')
+        if isinstance(agent.params, dict) and agent.params.get('is_demo') is True:
+            raise ValueError('Unable to delete demo object')
         agent.deleted_at = datetime.datetime.now()
         db.session.commit()
 

mindsdb/interfaces/agents/constants.py

@@ -165,6 +165,7 @@ PROVIDER_TO_MODELS = MappingProxyType(
 
 ASSISTANT_COLUMN = "answer"
 CONTEXT_COLUMN = "context"
+TRACE_ID_COLUMN = "trace_id"
 DEFAULT_AGENT_TIMEOUT_SECONDS = 300
 # These should require no additional arguments.
 DEFAULT_AGENT_TOOLS = []

mindsdb/interfaces/agents/langchain_agent.py

@@ -49,7 +49,7 @@ from .constants import (
     NVIDIA_NIM_CHAT_MODELS,
     USER_COLUMN,
     ASSISTANT_COLUMN,
-    CONTEXT_COLUMN
+    CONTEXT_COLUMN, TRACE_ID_COLUMN
 )
 from mindsdb.interfaces.skills.skill_tool import skill_tool, SkillData
 from langchain_anthropic import ChatAnthropic
@@ -371,9 +371,9 @@ class LangchainAgent:
         for row in df[:-1].to_dict("records"):
             question = row[user_column]
             answer = row[assistant_column]
-            if question:
+            if isinstance(question, str) and len(question) > 0:
                 memory.chat_memory.add_user_message(question)
-            if answer:
+            if isinstance(answer, str) and len(answer) > 0:
                 memory.chat_memory.add_ai_message(answer)
 
         agent_type = args.get("agent_type", DEFAULT_AGENT_TYPE)
@@ -455,9 +455,7 @@ class LangchainAgent:
 
         # custom tracer
         if self.mdb_langfuse_callback_handler is None:
-            trace_id = None
-            if self.langfuse_client_wrapper.trace is not None:
-                trace_id = args.get("trace_id", self.langfuse_client_wrapper.trace.id)
+            trace_id = self.langfuse_client_wrapper.get_trace_id()
 
             span_id = None
             if self.run_completion_span is not None:
@@ -562,6 +560,7 @@ AI: {response}"""
                 CONTEXT_COLUMN: [
                     json.dumps(ctx) for ctx in contexts
                 ],  # Serialize context to JSON string
+                TRACE_ID_COLUMN: self.langfuse_client_wrapper.get_trace_id()
             }
         )
 
@@ -570,6 +569,12 @@ AI: {response}"""
 
         return pred_df
 
+    def add_chunk_metadata(self, chunk: Dict) -> Dict:
+        logger.debug(f'Adding metadata to chunk: {chunk}')
+        logger.debug(f'Trace ID: {self.langfuse_client_wrapper.get_trace_id()}')
+        chunk["trace_id"] = self.langfuse_client_wrapper.get_trace_id()
+        return chunk
+
     def stream_agent(self, df: pd.DataFrame, agent_executor: AgentExecutor, args: Dict) -> Iterable[Dict]:
         base_template = args.get('prompt_template', args['prompt_template'])
         input_variables = re.findall(r"{{(.*?)}}", base_template)
@@ -579,7 +584,7 @@ AI: {response}"""
 
         callbacks, context_callback = prepare_callbacks(self, args)
 
-        yield {"type": "start", "prompt": prompts[0]}
+        yield self.add_chunk_metadata({"type": "start", "prompt": prompts[0]})
 
         if not hasattr(agent_executor, 'stream') or not callable(agent_executor.stream):
             raise AttributeError("The agent_executor does not have a 'stream' method")
@@ -591,10 +596,10 @@ AI: {response}"""
             raise TypeError("The stream method did not return an iterable")
 
         for chunk in stream_iterator:
-            logger.info(f'Processing streaming chunk {chunk}')
+            logger.debug(f'Processing streaming chunk {chunk}')
             processed_chunk = self.process_chunk(chunk)
             logger.info(f'Processed chunk: {processed_chunk}')
-            yield processed_chunk
+            yield self.add_chunk_metadata(processed_chunk)
 
         if return_context:
             # Yield context if required
@@ -604,7 +609,7 @@ AI: {response}"""
 
         if self.log_callback_handler.generated_sql:
             # Yield generated SQL if available
-            yield {"type": "sql", "content": self.log_callback_handler.generated_sql}
+            yield self.add_chunk_metadata({"type": "sql", "content": self.log_callback_handler.generated_sql})
 
         # End the run completion span and update the metadata with tool usage
         self.langfuse_client_wrapper.end_span_stream(span=self.run_completion_span)

mindsdb/interfaces/agents/langfuse_callback_handler.py

@@ -66,6 +66,10 @@ class LangfuseCallbackHandler(BaseCallbackHandler):
     ) -> Any:
         """Run when chain starts running."""
         run_uuid = kwargs.get('run_id', uuid4()).hex
+
+        if serialized is None:
+            serialized = {}
+
         chain_span = self.langfuse.span(
             name=f'{serialized.get("name", "chain")}-{run_uuid}',
             trace_id=self.trace_id,

mindsdb/interfaces/agents/mindsdb_database_agent.py

@@ -11,6 +11,17 @@ from mindsdb.interfaces.skills.sql_agent import SQLAgent
 logger = log.getLogger(__name__)
 
 
+def extract_essential(input: str) -> str:
+    """ Sometimes LLM include to input unnecessary data. We can't control stochastic nature of LLM, so we need to
+        'clean' input somehow. LLM prompt contains instruction to enclose input between '$START$' and '$STOP$'.
+    """
+    if '$START$' in input:
+        input = input.partition('$START$')[-1]
+    if '$STOP$' in input:
+        input = input.partition('$STOP$')[0]
+    return input.strip(' ')
+
+
 class MindsDBSQL(SQLDatabase):
     @staticmethod
     def custom_init(
@@ -50,7 +61,10 @@ class MindsDBSQL(SQLDatabase):
         return self._sql_agent.get_usable_table_names()
 
     def get_table_info_no_throw(self, table_names: Optional[List[str]] = None) -> str:
+        for i in range(len(table_names)):
+            table_names[i] = extract_essential(table_names[i])
         return self._sql_agent.get_table_info_safe(table_names)
 
     def run_no_throw(self, command: str, fetch: str = "all") -> str:
+        command = extract_essential(command)
         return self._sql_agent.query_safe(command)

mindsdb/interfaces/database/integrations.py

@@ -215,6 +215,8 @@ class IntegrationController:
     def modify(self, name, data):
         self.handlers_cache.delete(name)
         integration_record = self._get_integration_record(name)
+        if isinstance(integration_record.data, dict) and integration_record.data.get('is_demo') is True:
+            raise ValueError("It is forbidden to change properties of the demo object")
         old_data = deepcopy(integration_record.data)
         for k in old_data:
             if k not in data:
@@ -234,9 +236,11 @@ class IntegrationController:
             handler = self.handler_modules[name]
 
             if getattr(handler, 'permanent', False) is True:
-                raise Exception('Unable to drop: is permanent integration')
+                raise Exception('Unable to drop permanent integration')
 
         integration_record = self._get_integration_record(name)
+        if isinstance(integration_record.data, dict) and integration_record.data.get('is_demo') is True:
+            raise Exception('Unable to drop demo object')
 
         # if this is ml engine
         engine_models = get_model_records(ml_handler_name=name, deleted_at=None)

mindsdb/interfaces/database/projects.py

@@ -7,6 +7,7 @@ import sqlalchemy as sa
 import numpy as np
 
 from mindsdb_sql_parser.ast.base import ASTNode
+from mindsdb_sql_parser.ast import Select, Star, Constant, Identifier
 from mindsdb_sql_parser import parse_sql
 
 from mindsdb.interfaces.storage import db
@@ -16,6 +17,9 @@ from mindsdb.interfaces.database.views import ViewController
 from mindsdb.utilities.context import context as ctx
 from mindsdb.utilities.exception import EntityExistsError, EntityNotExistsError
 import mindsdb.utilities.profiler as profiler
+from mindsdb.api.executor.sql_query import SQLQuery
+from mindsdb.api.executor.utilities.sql import query_df
+from mindsdb.interfaces.query_context.context_controller import query_context_controller
 
 
 class Project:
@@ -111,7 +115,7 @@ class Project:
             project_name=self.name
         )
 
-    def query_view(self, query: ASTNode) -> ASTNode:
+    def get_view_meta(self, query: ASTNode) -> ASTNode:
         view_name = query.from_table.parts[-1]
         view_meta = ViewController().get(
             name=view_name,
@@ -120,6 +124,30 @@ class Project:
         view_meta['query_ast'] = parse_sql(view_meta['query'])
         return view_meta
 
+    def query_view(self, query, session):
+
+        view_meta = self.get_view_meta(query)
+
+        query_context_controller.set_context('view', view_meta['id'])
+
+        try:
+            sqlquery = SQLQuery(
+                view_meta['query_ast'],
+                session=session
+            )
+            result = sqlquery.fetch(view='dataframe')
+
+        finally:
+            query_context_controller.release_context('view', view_meta['id'])
+
+        if result['success'] is False:
+            raise Exception(f"Cant execute view query: {view_meta['query_ast']}")
+        df = result['result']
+        # remove duplicated columns
+        df = df.loc[:, ~df.columns.duplicated()]
+
+        return query_df(df, query, session=session)
+
     @staticmethod
     def _get_model_data(predictor_record, integraion_record, with_secrets: bool = True):
         from mindsdb.interfaces.database.integrations import integration_controller
@@ -341,6 +369,15 @@ class Project:
                 columns = predictor_record.to_predict
                 if not isinstance(columns, list):
                     columns = [columns]
+            return columns
+        if self.get_view(table_name):
+            query = Select(targets=[Star()], from_table=Identifier(table_name), limit=Constant(1))
+
+            from mindsdb.api.executor.controllers.session_controller import SessionController
+            session = SessionController()
+            session.database = self.name
+            df = self.query_view(query, session)
+            return df.columns
         else:
             # is it agent?
             agent = db.Agents.query.filter_by(

mindsdb/interfaces/knowledge_base/controller.py

@@ -26,6 +26,9 @@ from mindsdb.integrations.libs.vectordatabase_handler import (
 )
 from mindsdb.integrations.utilities.rag.rag_pipeline_builder import RAG
 from mindsdb.integrations.utilities.rag.config_loader import load_rag_config
+from mindsdb.integrations.utilities.sql_utils import (
+    extract_comparison_conditions, filter_dataframe, FilterCondition, FilterOperator
+)
 from mindsdb.interfaces.agents.constants import DEFAULT_EMBEDDINGS_MODEL_CLASS
 from mindsdb.interfaces.agents.langchain_agent import create_chat_model, get_llm_provider
 from mindsdb.interfaces.database.projects import ProjectController
@@ -101,18 +104,30 @@ class KnowledgeBaseTable:
         # Get response from vector db
         db_handler = self.get_vector_db()
         logger.debug(f"Using vector db handler: {type(db_handler)}")
-        resp = db_handler.query(query)
 
-        if resp.data_frame is not None:
-            logger.debug(f"Query returned {len(resp.data_frame)} rows")
-            logger.debug(f"Columns in response: {resp.data_frame.columns.tolist()}")
+        vector_filters, outer_filters = [], []
+        # update vector handlers, mark conditions as applied inside
+        for op, arg1, arg2 in extract_comparison_conditions(query.where):
+            condition = FilterCondition(arg1, FilterOperator(op.upper()), arg2)
+            if arg1 in (TableField.ID.value, TableField.CONTENT.value, TableField.EMBEDDINGS.value):
+                vector_filters.append(condition)
+            else:
+                outer_filters.append([op, arg1, arg2])
+
+        df = db_handler.dispatch_select(query, conditions=vector_filters)
+
+        if df is not None:
+            df = filter_dataframe(df, outer_filters)
+
+            logger.debug(f"Query returned {len(df)} rows")
+            logger.debug(f"Columns in response: {df.columns.tolist()}")
             # Log a sample of IDs to help diagnose issues
-            if not resp.data_frame.empty:
-                logger.debug(f"Sample of IDs in response: {resp.data_frame['id'].head().tolist()}")
+            if not df.empty:
+                logger.debug(f"Sample of IDs in response: {df['id'].head().tolist()}")
         else:
             logger.warning("Query returned no data")
 
-        return resp.data_frame
+        return df
 
     def insert_files(self, file_names: List[str]):
         """Process and insert files"""
@@ -713,10 +728,6 @@ class KnowledgeBaseController:
                         vector_db_params['vector_size'] = vector_size
                 vector_db_name = self._create_persistent_pgvector(vector_db_params)
 
-                # create table in vectordb before creating KB
-                self.session.datahub.get(vector_db_name).integration_handler.create_table(
-                    vector_table_name
-                )
             else:
                 # create chroma db with same name
                 vector_table_name = "default_collection"
@@ -728,6 +739,10 @@ class KnowledgeBaseController:
         else:
             vector_db_name, vector_table_name = storage.parts
 
+        # create table in vectordb before creating KB
+        self.session.datahub.get(vector_db_name).integration_handler.create_table(
+            vector_table_name
+        )
         vector_database_id = self.session.integration_controller.get(vector_db_name)['id']
 
         # Store sparse vector settings in params if specified

mindsdb/interfaces/knowledge_base/preprocessing/document_loader.py

@@ -1,15 +1,13 @@
 import os
 from typing import List, Iterator
 from langchain_core.documents import Document as LangchainDocument
-from langchain_text_splitters import MarkdownHeaderTextSplitter, RecursiveCharacterTextSplitter
+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
 from mindsdb.integrations.utilities.rag.splitters.file_splitter import (
     FileSplitter,
-    DEFAULT_CHUNK_SIZE,
-    DEFAULT_CHUNK_OVERLAP
 )
 from mindsdb.integrations.handlers.web_handler.urlcrawl_helpers import get_all_websites
 from mindsdb.interfaces.knowledge_base.preprocessing.models import Document
@@ -45,12 +43,6 @@ class DocumentLoader:
         self.file_loader_class = file_loader_class
         self.mysql_proxy = mysql_proxy
 
-        # Initialize text splitter for query results with default settings
-        self.query_splitter = RecursiveCharacterTextSplitter(
-            chunk_size=DEFAULT_CHUNK_SIZE,
-            chunk_overlap=DEFAULT_CHUNK_OVERLAP
-        )
-
     def load_files(self, file_names: List[str]) -> Iterator[Document]:
         """Load and split documents from files"""
         for file_name in file_names:
@@ -143,8 +135,9 @@ class DocumentLoader:
 
         # Process each row into a Document
         for _, row in df.iterrows():
-            # Extract content and metadata
+            # Extract id, content  and metadata
             content = str(row.get('content', ''))
+            id = row.get('id', None)
 
             # Convert remaining columns to metadata
             metadata = {
@@ -156,21 +149,9 @@ class DocumentLoader:
 
             # Split content using recursive splitter
             if content:
-                doc = LangchainDocument(
-                    page_content=content,
+
+                yield Document(
+                    id=id,
+                    content=content,
                     metadata=metadata
                 )
-                # Use FileSplitter with default recursive splitter
-                split_docs = self.file_splitter.split_documents(
-                    [doc],
-                    default_failover=True
-                )
-
-                for split_doc in split_docs:
-                    metadata = doc.metadata.copy()
-                    metadata.update(split_doc.metadata or {})
-
-                    yield Document(
-                        content=split_doc.page_content,
-                        metadata=metadata
-                    )

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

@@ -15,19 +15,25 @@ class MindsDBSQLToolkit(SQLDatabaseToolkit):
         list_sql_database_tool = ListSQLDatabaseTool(
             name=f'sql_db_list_tables{prefix}',
             db=self.db,
-            description=(
-                "Input is an empty string, output is a comma-separated list of tables in the database. "
-                "Each table name in the list may be in one of two formats: database_name.table_name or "
-                "database_name.schema_name.table_name."
-            )
+            description=dedent("""\n
+                Input is an empty string, output is a comma-separated list of tables in the database. Each table name is escaped using backticks.
+                Each table name in the list may be in one of two formats: database_name.`table_name` or database_name.schema_name.`table_name`.
+                Table names in response to the user must be escaped using backticks.
+            """)
         )
 
         info_sql_database_tool_description = (
-            "Input: A comma-separated list of tables. Output: Schema and sample rows for those tables. "
-            f"Ensure tables exist by calling {list_sql_database_tool.name} first. "
+            "Input: A comma-separated list of tables enclosed between the symbols $START$ and $STOP$. The tables names itself must be escaped using backticks.\n"
+            "Output: Schema and sample rows for those tables. \n"
             "Use this tool to investigate table schemas for needed columns. "
-            "Get sample data with 'SELECT * FROM table LIMIT 3' before answering questions. "
-            "Example Input: table1, table2, table3"
+            f"Ensure tables exist by calling {list_sql_database_tool.name} first. "
+            # "The names of tables, schemas, and databases must be escaped using backticks. "
+            # "Always enclose the names of tables, schemas, and databases in backticks. "
+            "Get sample data with 'SELECT * FROM `database`.`table` LIMIT 3' before answering questions. \n"
+            "Example of correct Input:\n    $START$ `database`.`table1`, `database`.`table2`, `database`.`table3` $STOP$\n"
+            "    $START$ `table1` `table2` `table3` $STOP$\n"
+            "Example of wrong Input:\n    $START$ `database.table1`, `database.table2`, `database.table3` $STOP$\n"
+            "    $START$ table1 table2 table3 $STOP$\n"
         )
         info_sql_database_tool = InfoSQLDatabaseTool(
             name=f'sql_db_schema{prefix}',
@@ -35,7 +41,7 @@ class MindsDBSQLToolkit(SQLDatabaseToolkit):
         )
 
         query_sql_database_tool_description = dedent(f"""\
-            Input: A detailed SQL query.
+            Input: A detailed and well-structured SQL query. The query must be enclosed between the symbols $START$ and $STOP$.
             Output: Database result or error message. For errors, rewrite and retry the query. For 'Unknown column' errors, use '{info_sql_database_tool.name}' to check table fields.
             This system is a highly intelligent and reliable PostgreSQL SQL skill designed to work with databases.
             Follow these instructions with utmost precision:
@@ -63,6 +69,8 @@ class MindsDBSQLToolkit(SQLDatabaseToolkit):
                  SELECT NOW() - INTERVAL 1 YEAR;
             6. Query Best Practices:
                - Always send only one query at a time.
+               - Always enclose the names of tables, schemas, and databases in backticks.
+               - The input SQL query must end with a semicolon.
                - Query only necessary columns, not all.
                - Use only existing column names from correct tables.
                - Use database-specific syntax for date operations.

mindsdb/interfaces/skills/skill_tool.py

@@ -126,6 +126,10 @@ class SkillToolController:
 
         command_executor = self.get_command_executor()
 
+        def escape_table_name(name: str) -> str:
+            name = name.strip(' `')
+            return f'`{name}`'
+
         tables_list = []
         for skill in skills:
             database = skill.params['database']
@@ -137,19 +141,22 @@ class SkillToolController:
                 else:
                     response = handler.get_tables()
                 # no restrictions
+                columns = [c.lower() for c in response.data_frame.columns]
+                name_idx = columns.index('table_name') if 'table_name' in columns else 0
+
                 if 'table_schema' in response.data_frame.columns:
                     for _, row in response.data_frame.iterrows():
-                        tables_list.append(f"{database}.{row['table_schema']}.{row['table_name']}")
+                        tables_list.append(f"{database}.{row['table_schema']}.{escape_table_name(row[name_idx])}")
                 else:
-                    for _, row in response.data_frame.iterrows():
-                        tables_list.append(f"{database}.{row['table_name']}")
+                    for table_name in response.data_frame.iloc[:, name_idx]:
+                        tables_list.append(f"{database}.{escape_table_name(table_name)}")
                 continue
             for schema_name, tables in restriction_on_tables.items():
                 for table in tables:
                     if schema_name is None:
-                        tables_list.append(f'{database}.{table}')
+                        tables_list.append(f'{database}.{escape_table_name(table)}')
                     else:
-                        tables_list.append(f'{database}.{schema_name}.{table}')
+                        tables_list.append(f'{database}.{schema_name}.{escape_table_name(table)}')
 
         sql_agent = SQLAgent(
             command_executor=command_executor,
@@ -219,7 +226,6 @@ class SkillToolController:
         return build_retrieval_tool(tool, pred_args, skill)
 
     def _get_rag_query_function(self, skill: db.Skills):
-
         session_controller = self.get_command_executor().session
 
         def _answer_question(question: str) -> str:

mindsdb/interfaces/skills/skills_controller.py

@@ -1,5 +1,5 @@
 import datetime
-from typing import Dict, List
+from typing import Dict, List, Optional
 
 from sqlalchemy import null
 from sqlalchemy.orm.attributes import flag_modified
@@ -16,7 +16,7 @@ class SkillsController:
             project_controller = ProjectController()
         self.project_controller = project_controller
 
-    def get_skill(self, skill_name: str, project_name: str = 'mindsdb') -> db.Skills:
+    def get_skill(self, skill_name: str, project_name: str = 'mindsdb') -> Optional[db.Skills]:
         '''
         Gets a skill by name. Skills are expected to have unique names.
 
@@ -25,7 +25,7 @@ class SkillsController:
             project_name (str): The name of the containing project
 
         Returns:
-            skill (db.Skills): The database skill object
+            skill (Optional[db.Skills]): The database skill object
 
         Raises:
             ValueError: If `project_name` does not exist
@@ -136,6 +136,8 @@ class SkillsController:
         existing_skill = self.get_skill(skill_name, project_name)
         if existing_skill is None:
             raise ValueError(f'Skill with name not found: {skill_name}')
+        if isinstance(existing_skill.params, dict) and existing_skill.params.get('is_demo') is True:
+            raise ValueError("It is forbidden to change properties of the demo object")
 
         if new_name is not None:
             existing_skill.name = new_name
@@ -171,5 +173,7 @@ class SkillsController:
         skill = self.get_skill(skill_name, project_name)
         if skill is None:
             raise ValueError(f"Skill with name doesn't exist: {skill_name}")
+        if isinstance(skill.params, dict) and skill.params.get('is_demo') is True:
+            raise ValueError("Unable to delete demo object")
         skill.deleted_at = datetime.datetime.now()
         db.session.commit()