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

mindsdb/interfaces/agents/constants.py

@@ -208,11 +208,19 @@ DEFAULT_TEMPERATURE = 0.0
 USER_COLUMN = "question"
 DEFAULT_EMBEDDINGS_MODEL_PROVIDER = "openai"
 DEFAULT_EMBEDDINGS_MODEL_CLASS = OpenAIEmbeddings
+MAX_INSERT_BATCH_SIZE = 50_000
 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 +238,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/knowledge_base/controller.py

@@ -29,7 +29,7 @@ from mindsdb.integrations.handlers.langchain_embedding_handler.langchain_embeddi
     construct_model_from_args,
 )
 
-from mindsdb.interfaces.agents.constants import DEFAULT_EMBEDDINGS_MODEL_CLASS
+from mindsdb.interfaces.agents.constants import DEFAULT_EMBEDDINGS_MODEL_CLASS, MAX_INSERT_BATCH_SIZE
 from mindsdb.interfaces.agents.langchain_agent import create_chat_model, get_llm_provider
 from mindsdb.interfaces.database.projects import ProjectController
 from mindsdb.interfaces.variables.variables_controller import variables_controller
@@ -493,6 +493,8 @@ class KnowledgeBaseTable:
         """Process and insert raw data rows"""
         if not rows:
             return
+        if len(rows) > MAX_INSERT_BATCH_SIZE:
+            raise ValueError("Input data is too large, please load data in batches")
 
         df = pd.DataFrame(rows)
 

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/config.py

@@ -3,13 +3,14 @@ import sys
 import json
 import argparse
 import datetime
+import logging
 from pathlib import Path
 from copy import deepcopy
-import multiprocessing as mp
 
 from appdirs import user_data_dir
 
 # NOTE do not `import from mindsdb` here
+logger = logging.getLogger(__name__)
 
 
 def _merge_key_recursive(target_dict, source_dict, key):
@@ -171,14 +172,6 @@ class Config:
                     "restart_on_failure": True,
                     "max_restart_count": 1,
                     "max_restart_interval_seconds": 60,
-                    "server": {
-                        "type": "waitress",  # MINDSDB_HTTP_SERVER_TYPE MINDSDB_DEFAULT_SERVER
-                        "config": {
-                            "threads": 16,
-                            "max_request_body_size": (1 << 30) * 10,  # 10GB
-                            "inbuf_overflow": (1 << 30) * 10,
-                        },
-                    },
                 },
                 "mysql": {
                     "host": api_host,
@@ -189,29 +182,11 @@ class Config:
                     "max_restart_count": 1,
                     "max_restart_interval_seconds": 60,
                 },
-                "mongodb": {"host": api_host, "port": "47336", "database": "mindsdb"},
                 "postgres": {"host": api_host, "port": "55432", "database": "mindsdb"},
-                "mcp": {
-                    "host": api_host,
-                    "port": "47337",
-                    "enabled": True,
-                    "restart_on_failure": True,
-                    "max_restart_count": 1,
-                    "max_restart_interval_seconds": 60,
-                },
                 "litellm": {
                     "host": "0.0.0.0",  # API server binds to all interfaces by default
                     "port": "8000",
                 },
-                "a2a": {
-                    "host": api_host,
-                    "port": 47338,
-                    "mindsdb_host": "localhost",
-                    "mindsdb_port": 47334,
-                    "agent_name": "my_agent",
-                    "project_name": "mindsdb",
-                    "enabled": False,
-                },
             },
             "cache": {"type": "local"},
             "ml_task_queue": {"type": "local"},
@@ -250,7 +225,7 @@ class Config:
         """Collect config values from env vars to self._env_config"""
         self._env_config = {
             "logging": {"handlers": {"console": {}, "file": {}}},
-            "api": {"http": {"server": {}}, "a2a": {}},
+            "api": {"http": {}},
             "auth": {},
             "paths": {},
             "permanent_storage": {},
@@ -298,21 +273,6 @@ class Config:
             self._env_config["auth"]["password"] = http_password
         # endregion
 
-        # region permanent session lifetime
-        for env_name in (
-            "MINDSDB_HTTP_PERMANENT_SESSION_LIFETIME",
-            "FLASK_PERMANENT_SESSION_LIFETIME",
-        ):
-            env_value = os.environ.get(env_name)
-            if isinstance(env_value, str):
-                try:
-                    permanent_session_lifetime = int(env_value)
-                except Exception:
-                    raise ValueError(f"Warning: Can't cast env var {env_name} value to int: {env_value}")
-                self._env_config["auth"]["http_permanent_session_lifetime"] = permanent_session_lifetime
-                break
-        # endregion
-
         # region logging
         if os.environ.get("MINDSDB_LOG_LEVEL", "") != "":
             self._env_config["logging"]["handlers"]["console"]["level"] = os.environ["MINDSDB_LOG_LEVEL"]
@@ -325,35 +285,6 @@ class Config:
             self._env_config["logging"]["handlers"]["file"]["enabled"] = True
         # endregion
 
-        # region server type
-        server_type = os.environ.get("MINDSDB_HTTP_SERVER_TYPE", "").lower()
-        if server_type == "":
-            server_type = os.environ.get("MINDSDB_DEFAULT_SERVER", "").lower()
-        if server_type != "":
-            if server_type == "waitress":
-                self._env_config["api"]["http"]["server"]["type"] = "waitress"
-                self._default_config["api"]["http"]["server"]["config"] = {}
-                self._env_config["api"]["http"]["server"]["config"] = {
-                    "threads": 16,
-                    "max_request_body_size": (1 << 30) * 10,  # 10GB
-                    "inbuf_overflow": (1 << 30) * 10,
-                }
-            elif server_type == "flask":
-                self._env_config["api"]["http"]["server"]["type"] = "flask"
-                self._default_config["api"]["http"]["server"]["config"] = {}
-                self._env_config["api"]["http"]["server"]["config"] = {}
-            elif server_type == "gunicorn":
-                self._env_config["api"]["http"]["server"]["type"] = "gunicorn"
-                self._default_config["api"]["http"]["server"]["config"] = {}
-                self._env_config["api"]["http"]["server"]["config"] = {
-                    "workers": min(mp.cpu_count(), 4),
-                    "timeout": 600,
-                    "reuse_port": True,
-                    "preload_app": True,
-                    "threads": 4,
-                }
-        # endregion
-
         if os.environ.get("MINDSDB_DB_CON", "") != "":
             self._env_config["storage_db"] = os.environ["MINDSDB_DB_CON"]
 
@@ -373,32 +304,6 @@ class Config:
         if os.environ.get("MINDSDB_DATA_CATALOG_ENABLED", "").lower() in ("1", "true"):
             self._env_config["data_catalog"] = {"enabled": True}
 
-        # region vars: a2a configuration
-        a2a_config = {}
-        if os.environ.get("MINDSDB_A2A_HOST"):
-            a2a_config["host"] = os.environ.get("MINDSDB_A2A_HOST")
-        if os.environ.get("MINDSDB_A2A_PORT"):
-            a2a_config["port"] = int(os.environ.get("MINDSDB_A2A_PORT"))
-        if os.environ.get("MINDSDB_HOST"):
-            a2a_config["mindsdb_host"] = os.environ.get("MINDSDB_HOST")
-        if os.environ.get("MINDSDB_PORT"):
-            a2a_config["mindsdb_port"] = int(os.environ.get("MINDSDB_PORT"))
-        if os.environ.get("MINDSDB_AGENT_NAME"):
-            a2a_config["agent_name"] = os.environ.get("MINDSDB_AGENT_NAME")
-        if os.environ.get("MINDSDB_PROJECT_NAME"):
-            a2a_config["project_name"] = os.environ.get("MINDSDB_PROJECT_NAME")
-        if os.environ.get("MINDSDB_A2A_ENABLED") is not None:
-            a2a_config["enabled"] = os.environ.get("MINDSDB_A2A_ENABLED").lower() in (
-                "true",
-                "1",
-                "yes",
-                "y",
-            )
-
-        if a2a_config:
-            self._env_config["api"]["a2a"] = a2a_config
-        # endregion
-
     def fetch_auto_config(self) -> bool:
         """Load dict readed from config.auto.json to `auto_config`.
         Do it only if `auto_config` was not loaded before or config.auto.json been changed.
@@ -462,38 +367,6 @@ class Config:
         _merge_configs(new_config, self._auto_config or {})
         _merge_configs(new_config, self._env_config or {})
 
-        # Apply command-line arguments for A2A
-        a2a_config = {}
-
-        # Check for A2A command-line arguments
-        if hasattr(self.cmd_args, "a2a_host") and self.cmd_args.a2a_host is not None:
-            a2a_config["host"] = self.cmd_args.a2a_host
-
-        if hasattr(self.cmd_args, "a2a_port") and self.cmd_args.a2a_port is not None:
-            a2a_config["port"] = self.cmd_args.a2a_port
-
-        if hasattr(self.cmd_args, "mindsdb_host") and self.cmd_args.mindsdb_host is not None:
-            a2a_config["mindsdb_host"] = self.cmd_args.mindsdb_host
-
-        if hasattr(self.cmd_args, "mindsdb_port") and self.cmd_args.mindsdb_port is not None:
-            a2a_config["mindsdb_port"] = self.cmd_args.mindsdb_port
-
-        if hasattr(self.cmd_args, "agent_name") and self.cmd_args.agent_name is not None:
-            a2a_config["agent_name"] = self.cmd_args.agent_name
-
-        if hasattr(self.cmd_args, "project_name") and self.cmd_args.project_name is not None:
-            a2a_config["project_name"] = self.cmd_args.project_name
-
-        # Merge command-line args config with highest priority
-        if a2a_config:
-            _merge_configs(new_config, {"api": {"a2a": a2a_config}})
-
-        # Ensure A2A port is never 0, which would prevent the A2A API from starting
-        a2a_config = new_config["api"].get("a2a")
-        if a2a_config is not None and isinstance(a2a_config, dict):
-            if "port" in a2a_config and (a2a_config["port"] == 0 or a2a_config["port"] is None):
-                a2a_config["port"] = 47338  # Use the default port value
-
         # region create dirs
         for key, value in new_config["paths"].items():
             if isinstance(value, str):
@@ -550,12 +423,6 @@ class Config:
         if "log" in self._config:
             logger.warning("The 'log' config option is no longer supported. Use 'logging' instead.")
 
-        if os.environ.get("MINDSDB_DEFAULT_SERVER", "") != "":
-            logger.warning(
-                "Env variable 'MINDSDB_DEFAULT_SERVER' is going to be deprecated soon. "
-                "Use 'MINDSDB_HTTP_SERVER_TYPE' instead."
-            )
-
         file_upload_domains = self._config.get("file_upload_domains")
         if isinstance(file_upload_domains, list) and len(file_upload_domains) > 0:
             allowed_origins = self._config["url_file_upload"]["allowed_origins"]
@@ -566,14 +433,6 @@ class Config:
                 'use config["url_file_upload"]["allowed_origins"] instead.'
             )
 
-        for env_name in ("MINDSDB_HTTP_SERVER_TYPE", "MINDSDB_DEFAULT_SERVER"):
-            env_value = os.environ.get(env_name, "")
-            if env_value.lower() not in ("waitress", "flask", "gunicorn", ""):
-                logger.warning(
-                    f"The value '{env_value}' of the environment variable {env_name} is not valid. "
-                    "It must be one of the following: 'waitress', 'flask', or 'gunicorn'."
-                )
-
     @property
     def cmd_args(self):
         if self._cmd_args is None:
@@ -624,17 +483,6 @@ class Config:
             help="Project containing the agent (default: mindsdb)",
         )
 
-        # A2A specific arguments
-        parser.add_argument("--a2a-host", type=str, default=None, help="A2A server host")
-        parser.add_argument("--a2a-port", type=int, default=None, help="A2A server port")
-        parser.add_argument("--mindsdb-host", type=str, default=None, help="MindsDB server host")
-        parser.add_argument("--mindsdb-port", type=int, default=None, help="MindsDB server port")
-        parser.add_argument(
-            "--agent-name",
-            type=str,
-            default=None,
-            help="MindsDB agent name to connect to",
-        )
         parser.add_argument("--project-name", type=str, default=None, help="MindsDB project name")
         parser.add_argument("--update-gui", action="store_true", default=False, help="Update GUI and exit")
 

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()

mindsdb/utilities/log.py

@@ -99,31 +99,6 @@ def get_handlers_config(process_name: str) -> dict:
     return handlers_config
 
 
-def get_uvicorn_logging_config(process_name: str) -> dict:
-    """Generate a logging configuration dictionary for Uvicorn using MindsDB's logging settings.
-
-    Args:
-        process_name (str): The name of the process to include in log file names and handlers.
-
-    Returns:
-        dict: A dictionary suitable for use with logging.config.dictConfig, configured for Uvicorn logging.
-    """
-    handlers_config = get_handlers_config(process_name)
-    mindsdb_log_level = get_mindsdb_log_level()
-    return {
-        "version": 1,
-        "formatters": FORMATTERS,
-        "handlers": handlers_config,
-        "loggers": {
-            "uvicorn": {
-                "handlers": list(handlers_config.keys()),
-                "level": mindsdb_log_level,
-                "propagate": False,
-            }
-        },
-    }
-
-
 def configure_logging(process_name: str = None):
     handlers_config = get_handlers_config(process_name)
     mindsdb_log_level = get_mindsdb_log_level()