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

mindsdb/__about__.py

@@ -1,6 +1,6 @@
 __title__ = "MindsDB"
 __package_name__ = "mindsdb"
-__version__ = "25.8.2.0"
+__version__ = "25.8.3.0"
 __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/__main__.py

@@ -134,6 +134,9 @@ class TrunkProcessData:
 
 def close_api_gracefully(trunc_processes_struct):
     _stop_event.set()
+
+    delete_pid_file()
+
     try:
         for trunc_processes_data in trunc_processes_struct.values():
             process = trunc_processes_data.process
@@ -600,7 +603,6 @@ if __name__ == "__main__":
             ],
             return_exceptions=False,
         )
-        delete_pid_file()
 
     ioloop = asyncio.new_event_loop()
     ioloop.run_until_complete(wait_apis_start())

mindsdb/api/a2a/agent.py

@@ -3,7 +3,7 @@ from typing import Any, AsyncIterable, Dict, List
 import requests
 import logging
 import httpx
-from mindsdb.api.a2a.utils import to_serializable
+from mindsdb.api.a2a.utils import to_serializable, convert_a2a_message_to_qa_format
 from mindsdb.api.a2a.constants import DEFAULT_STREAM_TIMEOUT
 
 logger = logging.getLogger(__name__)
@@ -117,22 +117,12 @@ class MindsDBAgent:
         """Stream responses from the MindsDB agent (uses streaming API endpoint)."""
         try:
             logger.info(f"Using streaming API for query: {query[:100]}...")
-            formatted_messages = []
+            # Create A2A message structure with history and current query
+            a2a_message = {"role": "user", "parts": [{"text": query}]}
             if history:
-                for msg in history:
-                    msg_dict = msg.dict() if hasattr(msg, "dict") else msg
-                    role = msg_dict.get("role", "user")
-                    text = ""
-                    for part in msg_dict.get("parts", []):
-                        if part.get("type") == "text":
-                            text = part.get("text", "")
-                            break
-                    if text:
-                        if role == "user":
-                            formatted_messages.append({"question": text, "answer": None})
-                        elif role == "assistant" and formatted_messages:
-                            formatted_messages[-1]["answer"] = text
-            formatted_messages.append({"question": query, "answer": None})
+                a2a_message["history"] = history
+            # Convert to Q&A format using centralized utility
+            formatted_messages = convert_a2a_message_to_qa_format(a2a_message)
             logger.debug(f"Formatted messages for agent: {formatted_messages}")
             streaming_response = self.streaming_invoke(formatted_messages, timeout=timeout)
             async for chunk in streaming_response:

mindsdb/api/a2a/common/types.py

@@ -35,9 +35,7 @@ class FileContent(BaseModel):
         if not (self.bytes or self.uri):
             raise ValueError("Either 'bytes' or 'uri' must be present in the file data")
         if self.bytes and self.uri:
-            raise ValueError(
-                "Only one of 'bytes' or 'uri' can be present in the file data"
-            )
+            raise ValueError("Only one of 'bytes' or 'uri' can be present in the file data")
         return self
 
 
@@ -57,9 +55,10 @@ Part = Annotated[Union[TextPart, FilePart, DataPart], Field(discriminator="type"
 
 
 class Message(BaseModel):
-    role: Literal["user", "agent"]
+    role: Literal["user", "agent", "assistant"]
     parts: List[Part]
     metadata: dict[str, Any] | None = None
+    history: Optional[List["Message"]] = None
 
 
 class TaskStatus(BaseModel):

mindsdb/api/a2a/task_manager.py

@@ -18,7 +18,7 @@ from mindsdb.api.a2a.common.types import (
 )
 from mindsdb.api.a2a.common.server.task_manager import InMemoryTaskManager
 from mindsdb.api.a2a.agent import MindsDBAgent
-from mindsdb.api.a2a.utils import to_serializable
+from mindsdb.api.a2a.utils import to_serializable, convert_a2a_message_to_qa_format
 
 from typing import Union
 import logging
@@ -94,22 +94,8 @@ class AgentTaskManager(InMemoryTaskManager):
 
         agent = self._create_agent(agent_name)
 
-        # Get the history from the task
+        # Get the history from the task object (where it was properly extracted and stored)
         history = task.history if task and task.history else []
-        logger.info(f"Using history with length {len(history)} for request")
-
-        # Log the history for debugging
-        logger.info(f"Conversation history for task {task_send_params.id}:")
-        for idx, msg in enumerate(history):
-            # Convert Message object to dict if needed
-            msg_dict = msg.dict() if hasattr(msg, "dict") else msg
-            role = msg_dict.get("role", "unknown")
-            text = ""
-            for part in msg_dict.get("parts", []):
-                if part.get("type") == "text":
-                    text = part.get("text", "")
-                    break
-            logger.info(f"Message {idx + 1} ({role}): {text[:100]}...")
 
         if not streaming:
             # If streaming is disabled, use invoke and return a single response
@@ -183,17 +169,16 @@ class AgentTaskManager(InMemoryTaskManager):
         # If streaming is enabled (default), use the streaming implementation
         try:
             logger.debug(f"[TaskManager] Entering agent.stream() at {time.time()}")
-            # Transform to agent-compatible format
-            agent_messages = to_question_format(
-                [
-                    {
-                        "role": task_send_params.message.role,
-                        "parts": task_send_params.message.parts,
-                        "metadata": task_send_params.message.metadata,
-                    }
-                ]
-            )
-            async for item in agent.streaming_invoke(agent_messages, timeout=60):
+            # Create A2A message structure and convert using centralized utility
+            a2a_message = task_send_params.message.model_dump()
+            if history:
+                a2a_message["history"] = [msg.model_dump() if hasattr(msg, "model_dump") else msg for msg in history]
+
+            # Convert to Q&A format using centralized utility function
+            all_messages = convert_a2a_message_to_qa_format(a2a_message)
+
+            logger.debug(f"Sending {len(all_messages)} total messages to streaming agent")
+            async for item in agent.streaming_invoke(all_messages, timeout=60):
                 # Clean up: Remove verbose debug logs, keep only errors and essential info
                 if isinstance(item, dict) and "artifact" in item and "parts" in item["artifact"]:
                     item["artifact"]["parts"] = [to_serializable(p) for p in item["artifact"]["parts"]]
@@ -235,19 +220,23 @@ class AgentTaskManager(InMemoryTaskManager):
                 message = task_send_params.message
                 message_dict = message.dict() if hasattr(message, "dict") else message
 
-                # Get history from request if available
+                # Get history from request if available - check both locations
                 history = []
+
+                # First check if history is at top level (task_send_params.history)
                 if hasattr(task_send_params, "history") and task_send_params.history:
-                    # Convert each history item to dict if needed and ensure proper role
+                    # Convert each history item to dict if needed
                     for item in task_send_params.history:
-                        item_dict = item.dict() if hasattr(item, "dict") else item
-                        # Ensure the role is properly set
-                        if "role" not in item_dict:
-                            item_dict["role"] = "assistant" if "answer" in item_dict else "user"
+                        item_dict = item.model_dump() if hasattr(item, "model_dump") else item
+                        history.append(item_dict)
+                # Also check if history is nested under message (message.history)
+                elif hasattr(task_send_params.message, "history") and task_send_params.message.history:
+                    for item in task_send_params.message.history:
+                        item_dict = item.model_dump() if hasattr(item, "model_dump") else item
                         history.append(item_dict)
 
-                # Add current message to history
-                history.append(message_dict)
+                # DO NOT add current message to history - it should be processed separately
+                # The current message will be extracted during streaming from task_send_params.message
 
                 # Create a new task
                 task = Task(

mindsdb/api/a2a/utils.py

@@ -1,3 +1,9 @@
+from typing import Dict, List
+from mindsdb.utilities.log import getLogger
+
+logger = getLogger(__name__)
+
+
 def to_serializable(obj):
     # Primitives
     if isinstance(obj, (str, int, float, bool, type(None))):
@@ -19,3 +25,60 @@ def to_serializable(obj):
         return [to_serializable(v) for v in obj]
     # Fallback: string
     return str(obj)
+
+
+def convert_a2a_message_to_qa_format(a2a_message: Dict) -> List[Dict[str, str]]:
+    """
+    Convert A2A message format to question/answer format.
+
+    This is the format that the langchain agent expects and ensure effective multi-turn conversation
+
+    Args:
+        a2a_message: A2A message containing history and current message parts
+
+    Returns:
+        List of messages in question/answer format
+    """
+    converted_messages = []
+
+    # Process conversation history first
+    if "history" in a2a_message:
+        for hist_msg in a2a_message["history"]:
+            if hist_msg.get("role") == "user":
+                # Extract text from parts
+                text = ""
+                for part in hist_msg.get("parts", []):
+                    if part.get("type") == "text":
+                        text = part.get("text", "")
+                        break
+                # Create question with empty answer initially
+                converted_messages.append({"question": text, "answer": ""})
+            elif hist_msg.get("role") in ["agent", "assistant"]:
+                # Extract text from parts
+                text = ""
+                for part in hist_msg.get("parts", []):
+                    if part.get("type") == "text":
+                        text = part.get("text", "")
+                        break
+                # Pair with the most recent question that has empty answer
+                paired = False
+                for i in range(len(converted_messages) - 1, -1, -1):
+                    if converted_messages[i].get("answer") == "":
+                        converted_messages[i]["answer"] = text
+                        paired = True
+                        break
+
+                if not paired:
+                    logger.warning("Could not pair agent response with question (no empty answer found)")
+
+        logger.debug(f"Converted {len(a2a_message['history'])} A2A history messages to Q&A format")
+
+    # Add current message as final question with empty answer
+    current_text = ""
+    for part in a2a_message.get("parts", []):
+        if part.get("type") == "text":
+            current_text = part.get("text", "")
+            break
+    converted_messages.append({"question": current_text, "answer": ""})
+
+    return converted_messages

mindsdb/api/http/namespaces/agents.py

@@ -323,15 +323,16 @@ class AgentCompletionsStream(Resource):
     @ns_conf.doc("agent_completions_stream")
     @api_endpoint_metrics("POST", "/agents/agent/completions/stream")
     def post(self, project_name, agent_name):
-        logger.info(f"Received streaming request for agent {agent_name} in project {project_name}")
-
-        # Check for required parameters.
+        # Extract messages from request (HTTP format only)
         if "messages" not in request.json:
-            logger.error("Missing 'messages' parameter in request body")
             return http_error(
-                HTTPStatus.BAD_REQUEST, "Missing parameter", 'Must provide "messages" parameter in POST body'
+                HTTPStatus.BAD_REQUEST,
+                "Missing parameter",
+                'Must provide "messages" parameter in POST body',
             )
 
+        messages = request.json["messages"]
+
         session = SessionController()
         try:
             existing_agent = session.agents_controller.get_agent(agent_name, project_name=project_name)
@@ -346,8 +347,6 @@ class AgentCompletionsStream(Resource):
                 HTTPStatus.NOT_FOUND, "Project not found", f"Project with name {project_name} does not exist"
             )
 
-        messages = request.json["messages"]
-
         try:
             gen = _completion_event_generator(agent_name, messages, project_name)
             logger.info(f"Starting streaming response for agent {agent_name}")

mindsdb/interfaces/agents/constants.py

@@ -212,7 +212,14 @@ DEFAULT_TIKTOKEN_MODEL_NAME = os.getenv("DEFAULT_TIKTOKEN_MODEL_NAME", "gpt-4")
 AGENT_CHUNK_POLLING_INTERVAL_SECONDS = os.getenv("AGENT_CHUNK_POLLING_INTERVAL_SECONDS", 1.0)
 DEFAULT_TEXT2SQL_DATABASE = "mindsdb"
 DEFAULT_AGENT_SYSTEM_PROMPT = """
-You are an AI assistant powered by MindsDB. When answering questions, follow these guidelines:
+You are an AI assistant powered by MindsDB. You have access to conversation history and should use it to provide contextual responses. When answering questions, follow these guidelines:
+
+**CONVERSATION CONTEXT:**
+- You have access to previous messages in this conversation through your memory system
+- When users ask about previous questions, topics, or context, refer to the conversation history
+- Maintain conversational continuity and reference earlier parts of the conversation when relevant
+- When asked to retrieve or list past user questions, examine your conversation memory to identify and list previous user queries
+- You can reference specific past questions by their content or by their position in the conversation (e.g., "your first question", "the question you asked earlier about...")
 
 1. For factual questions about specific topics, use the knowledge base tools in this sequence:
    - First use kb_list_tool to see available knowledge bases
@@ -230,7 +237,14 @@ For factual questions, ALWAYS use the available tools to look up information rat
 
 """
 
-MINDSDB_PREFIX = """You are an AI assistant powered by MindsDB. When answering questions, follow these guidelines:
+MINDSDB_PREFIX = """You are an AI assistant powered by MindsDB. You have access to conversation history and should use it to provide contextual responses. When answering questions, follow these guidelines:
+
+**CONVERSATION CONTEXT:**
+- You have access to previous messages in this conversation through your memory system
+- When users ask about previous questions, topics, or context, refer to the conversation history
+- Maintain conversational continuity and reference earlier parts of the conversation when relevant
+- When asked to retrieve or list past user questions, examine your conversation memory to identify and list previous user queries
+- You can reference specific past questions by their content or by their position in the conversation (e.g., "your first question", "the question you asked earlier about...")
 
 1. For questions about database tables and their contents:
    - Use the sql_db_query to query the tables directly

mindsdb/interfaces/agents/langchain_agent.py

@@ -7,6 +7,7 @@ import re
 import threading
 import numpy as np
 import pandas as pd
+import logging
 
 from langchain.agents import AgentExecutor
 from langchain.agents.initialize import initialize_agent
@@ -16,6 +17,7 @@ from langchain_writer import ChatWriter
 from langchain_google_genai import ChatGoogleGenerativeAI
 from langchain_core.agents import AgentAction, AgentStep
 from langchain_core.callbacks.base import BaseCallbackHandler
+from langchain_core.messages import HumanMessage, AIMessage, SystemMessage
 
 from langchain_nvidia_ai_endpoints import ChatNVIDIA
 from langchain_core.messages.base import BaseMessage
@@ -63,7 +65,6 @@ from mindsdb.interfaces.agents.constants import (
 )
 from mindsdb.interfaces.skills.skill_tool import skill_tool, SkillData
 from langchain_anthropic import ChatAnthropic
-from langchain_core.messages import SystemMessage
 from langchain_openai import ChatOpenAI
 
 from mindsdb.utilities.langfuse import LangfuseClientWrapper
@@ -297,6 +298,11 @@ class LangchainAgent:
         if "prompt_template" in args:
             logger.info(f"Using prompt template: {args['prompt_template'][:50]}...")
 
+        if "model_name" not in args:
+            raise ValueError(
+                "No model name provided for agent. Provide it in the model parameter or in the default model setup."
+            )
+
         return args
 
     def get_metadata(self) -> Dict:
@@ -345,15 +351,20 @@ class LangchainAgent:
         args.update(params or {})
 
         df = pd.DataFrame(messages)
+        logger.info(f"LangchainAgent.get_completion: Received {len(messages)} messages")
+        if logger.isEnabledFor(logging.DEBUG):
+            logger.debug(f"Messages DataFrame shape: {df.shape}")
+            logger.debug(f"Messages DataFrame columns: {df.columns.tolist()}")
+            logger.debug(f"Messages DataFrame content: {df.to_dict('records')}")
 
         # Back compatibility for old models
         self.provider = args.get("provider", get_llm_provider(args))
 
         df = df.reset_index(drop=True)
         agent = self.create_agent(df)
-        # Use last message as prompt, remove other questions.
-        user_column = args.get("user_column", USER_COLUMN)
-        df.iloc[:-1, df.columns.get_loc(user_column)] = None
+        # Keep conversation history for context - don't nullify previous messages
+
+        # Only use the last message as the current prompt, but preserve history for agent memory
         response = self.run_agent(df, agent, args)
 
         # End the run completion span and update the metadata with tool usage
@@ -374,6 +385,12 @@ class LangchainAgent:
         args = self.args
 
         df = pd.DataFrame(messages)
+        logger.info(f"LangchainAgent._get_completion_stream: Received {len(messages)} messages")
+        # Check if we have the expected columns for conversation history
+        if "question" in df.columns and "answer" in df.columns:
+            logger.debug("DataFrame has question/answer columns for conversation history")
+        else:
+            logger.warning("DataFrame missing question/answer columns! Available columns: {df.columns.tolist()}")
 
         self.embedding_model_provider = args.get("embedding_model_provider", get_embedding_model_provider(args))
         # Back compatibility for old models
@@ -381,9 +398,8 @@ class LangchainAgent:
 
         df = df.reset_index(drop=True)
         agent = self.create_agent(df)
-        # Use last message as prompt, remove other questions.
-        user_column = args.get("user_column", USER_COLUMN)
-        df.iloc[:-1, df.columns.get_loc(user_column)] = None
+        # Keep conversation history for context - don't nullify previous messages
+        # Only use the last message as the current prompt, but preserve history for agent memory
         return self.stream_agent(df, agent, args)
 
     def create_agent(self, df: pd.DataFrame) -> AgentExecutor:
@@ -403,7 +419,8 @@ class LangchainAgent:
         # Prefer prediction prompt template over original if provided.
         prompt_template = args["prompt_template"]
 
-        # Set up memory.
+        # Modern LangChain approach: Use memory but populate it correctly
+        # Create memory and populate with conversation history
         memory = ConversationSummaryBufferMemory(
             llm=llm,
             input_key="input",
@@ -412,17 +429,41 @@ class LangchainAgent:
             memory_key="chat_history",
         )
 
+        # Add system message first
         memory.chat_memory.messages.insert(0, SystemMessage(content=prompt_template))
-        # User - Assistant conversation. All except the last message.
+
         user_column = args.get("user_column", USER_COLUMN)
         assistant_column = args.get("assistant_column", ASSISTANT_COLUMN)
-        for row in df[:-1].to_dict("records"):
-            question = row[user_column]
-            answer = row[assistant_column]
+
+        logger.info(f"Processing conversation history: {len(df)} total messages, {len(df[:-1])} history messages")
+        logger.debug(f"User column: {user_column}, Assistant column: {assistant_column}")
+
+        # Process history messages (all except the last one which is current message)
+        history_df = df[:-1]
+        if len(history_df) == 0:
+            logger.debug("No history rows to process - this is normal for first message")
+
+        history_count = 0
+        for i, row in enumerate(history_df.to_dict("records")):
+            question = row.get(user_column)
+            answer = row.get(assistant_column)
+            logger.debug(f"Converting history row {i}: question='{question}', answer='{answer}'")
+
+            # Add messages directly to memory's chat_memory.messages list (modern approach)
             if isinstance(question, str) and len(question) > 0:
-                memory.chat_memory.add_user_message(question)
+                memory.chat_memory.messages.append(HumanMessage(content=question))
+                history_count += 1
+                logger.debug(f"Added HumanMessage to memory: {question}")
             if isinstance(answer, str) and len(answer) > 0:
-                memory.chat_memory.add_ai_message(answer)
+                memory.chat_memory.messages.append(AIMessage(content=answer))
+                history_count += 1
+                logger.debug(f"Added AIMessage to memory: {answer}")
+
+        logger.info(f"Built conversation history with {history_count} history messages + system message")
+        logger.debug(f"Final memory messages count: {len(memory.chat_memory.messages)}")
+
+        # Store memory for agent use
+        self._conversation_memory = memory
 
         agent_type = args.get("agent_type", DEFAULT_AGENT_TYPE)
         agent_executor = initialize_agent(
@@ -562,7 +603,22 @@ AI: {response}"""
                 return {CONTEXT_COLUMN: [], ASSISTANT_COLUMN: ""}
             try:
                 callbacks, context_callback = prepare_callbacks(self, args)
-                result = agent_executor.invoke(prompt, config={"callbacks": callbacks})
+
+                # Modern LangChain approach: Include conversation history + current message
+                if hasattr(self, "_conversation_messages") and self._conversation_messages:
+                    # Add current user message to conversation history
+                    full_messages = self._conversation_messages + [HumanMessage(content=prompt)]
+                    logger.critical(f"🔍 INVOKING AGENT with {len(full_messages)} messages (including history)")
+                    logger.debug(
+                        f"Full conversation messages: {[type(msg).__name__ + ': ' + msg.content[:100] + '...' for msg in full_messages]}"
+                    )
+
+                    # For agents, we need to pass the input in the expected format
+                    # The agent expects 'input' key with the current question, but conversation history should be in memory
+                    result = agent_executor.invoke({"input": prompt}, config={"callbacks": callbacks})
+                else:
+                    logger.warning("No conversation messages found - using simple prompt")
+                    result = agent_executor.invoke({"input": prompt}, config={"callbacks": callbacks})
                 captured_context = context_callback.get_contexts()
                 output = result["output"] if isinstance(result, dict) and "output" in result else str(result)
                 return {CONTEXT_COLUMN: captured_context, ASSISTANT_COLUMN: output}
@@ -585,7 +641,14 @@ AI: {response}"""
         agent_timeout_seconds = args.get("timeout", DEFAULT_AGENT_TIMEOUT_SECONDS)
 
         with ContextThreadPoolExecutor(max_workers=max_workers) as executor:
-            futures = [executor.submit(_invoke_agent_executor_with_prompt, agent, prompt) for prompt in prompts]
+            # Only process the last prompt (current question), not all prompts
+            # The previous prompts are conversation history and should only be used for context
+            if prompts:
+                current_prompt = prompts[-1]  # Last prompt is the current question
+                futures = [executor.submit(_invoke_agent_executor_with_prompt, agent, current_prompt)]
+            else:
+                logger.error("No prompts found to process")
+                futures = []
             try:
                 for future in as_completed(futures, timeout=agent_timeout_seconds):
                     result = future.result()
@@ -686,12 +749,14 @@ AI: {response}"""
 
         callbacks, context_callback = prepare_callbacks(self, args)
 
-        yield self.add_chunk_metadata({"type": "start", "prompt": prompts[0]})
+        # Use last prompt (current question) instead of first prompt (history)
+        current_prompt = prompts[-1] if prompts else ""
+        yield self.add_chunk_metadata({"type": "start", "prompt": current_prompt})
 
         if not hasattr(agent_executor, "stream") or not callable(agent_executor.stream):
             raise AttributeError("The agent_executor does not have a 'stream' method")
 
-        stream_iterator = self._stream_agent_executor(agent_executor, prompts[0], callbacks)
+        stream_iterator = self._stream_agent_executor(agent_executor, current_prompt, callbacks)
         for chunk in stream_iterator:
             yield chunk
 

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

@@ -15,6 +15,7 @@ from mindsdb.interfaces.skills.custom.text2sql.mindsdb_kb_tools import (
 
 
 class MindsDBSQLToolkit(SQLDatabaseToolkit):
+    include_tables_tools: bool = True
     include_knowledge_base_tools: bool = True
 
     def get_tools(self, prefix="") -> List[BaseTool]:
@@ -212,8 +213,13 @@ class MindsDBSQLToolkit(SQLDatabaseToolkit):
         )
 
         # Return standard SQL tools and knowledge base tools
-        return sql_tools + [
+        kb_tools = [
             kb_list_tool,
             kb_info_tool,
             kb_query_tool,
         ]
+
+        if not self.include_tables_tools:
+            return kb_tools
+        else:
+            return sql_tools + kb_tools

mindsdb/interfaces/skills/skill_tool.py

@@ -347,7 +347,13 @@ class SkillToolController:
         )
         db = MindsDBSQL.custom_init(sql_agent=sql_agent)
         should_include_kb_tools = include_knowledge_bases is not None and len(include_knowledge_bases) > 0
-        toolkit = MindsDBSQLToolkit(db=db, llm=llm, include_knowledge_base_tools=should_include_kb_tools)
+        should_include_tables_tools = len(databases_struct) > 0 or len(tables_list) > 0
+        toolkit = MindsDBSQLToolkit(
+            db=db,
+            llm=llm,
+            include_tables_tools=should_include_tables_tools,
+            include_knowledge_base_tools=should_include_kb_tools,
+        )
         return toolkit.get_tools()
 
     def _make_retrieval_tools(self, skill: db.Skills, llm, embedding_model):

mindsdb/interfaces/skills/sql_agent.py

@@ -405,6 +405,7 @@ class SQLAgent:
             tables_idx[tuple(table.parts)] = table
 
         tables = []
+        not_found = []
         for table_name in table_names:
             if not table_name.strip():
                 continue
@@ -419,9 +420,12 @@ class SQLAgent:
             table_identifier = tables_idx.get(tuple(table_parts))
 
             if table_identifier is None:
-                raise ValueError(f"Table {table_name} not found in the database")
-            tables.append(table_identifier)
+                not_found.append(table_name)
+            else:
+                tables.append(table_identifier)
 
+        if not_found:
+            raise ValueError(f"Tables: {', '.join(not_found)} not found in the database")
         return tables
 
     def get_knowledge_base_info(self, kb_names: Optional[List[str]] = None) -> str:

mindsdb/utilities/fs.py

@@ -133,6 +133,9 @@ def create_pid_file():
     Create mindsdb process pid file. Check if previous process exists and is running
     """
 
+    if os.environ.get("USE_PIDFILE") != "1":
+        return
+
     p = get_tmp_dir()
     p.mkdir(parents=True, exist_ok=True)
     pid_file = p.joinpath("pid")
@@ -141,11 +144,11 @@ def create_pid_file():
         pid = pid_file.read_text().strip()
         try:
             psutil.Process(int(pid))
-            raise Exception(f"Found PID file with existing process: {pid}")
+            raise Exception(f"Found PID file with existing process: {pid} {pid_file}")
         except (psutil.Error, ValueError):
             ...
 
-        logger.warning(f"Found existing PID file ({pid}), removing")
+        logger.warning(f"Found existing PID file {pid_file}({pid}), removing")
         pid_file.unlink()
 
     pid_file.write_text(str(os.getpid()))
@@ -155,15 +158,18 @@ def delete_pid_file():
     """
     Remove existing process pid file if it matches current process
     """
+
+    if os.environ.get("USE_PIDFILE") != "1":
+        return
+
     pid_file = get_tmp_dir().joinpath("pid")
 
     if not pid_file.exists():
-        logger.warning("Mindsdb PID file does not exist")
         return
 
     pid = pid_file.read_text().strip()
     if pid != str(os.getpid()):
-        logger.warning("Process id in PID file doesn't match mindsdb pid")
+        logger.warning(f"Process id in PID file ({pid_file}) doesn't match mindsdb pid")
         return
 
     pid_file.unlink()