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

mindsdb/__about__.py

@@ -1,6 +1,6 @@
 __title__ = "MindsDB"
 __package_name__ = "mindsdb"
-__version__ = "25.8.2.0"
+__version__ = "25.9.1.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

@@ -8,7 +8,6 @@ import atexit
 import signal
 import psutil
 import asyncio
-import secrets
 import traceback
 import threading
 from enum import Enum
@@ -28,14 +27,11 @@ from mindsdb.utilities.config import config
 from mindsdb.utilities.starters import (
     start_http,
     start_mysql,
-    start_mongo,
     start_postgres,
     start_ml_task_queue,
     start_scheduler,
     start_tasks,
-    start_mcp,
     start_litellm,
-    start_a2a,
 )
 from mindsdb.utilities.ps import is_pid_listen_port, get_child_pids
 import mindsdb.interfaces.storage.db as db
@@ -61,18 +57,15 @@ _stop_event = threading.Event()
 class TrunkProcessEnum(Enum):
     HTTP = "http"
     MYSQL = "mysql"
-    MONGODB = "mongodb"
     POSTGRES = "postgres"
     JOBS = "jobs"
     TASKS = "tasks"
     ML_TASK_QUEUE = "ml_task_queue"
-    MCP = "mcp"
     LITELLM = "litellm"
-    A2A = "a2a"
 
     @classmethod
     def _missing_(cls, value):
-        print(f'"{value}" is not a valid name of subprocess')
+        logger.error(f'"{value}" is not a valid name of subprocess')
         sys.exit(1)
 
 
@@ -134,6 +127,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
@@ -345,9 +341,6 @@ if __name__ == "__main__":
     config.raise_warnings(logger=logger)
     os.environ["MINDSDB_RUNTIME"] = "1"
 
-    if os.environ.get("FLASK_SECRET_KEY") is None:
-        os.environ["FLASK_SECRET_KEY"] = secrets.token_hex(32)
-
     if os.environ.get("ARROW_DEFAULT_MEMORY_POOL") is None:
         try:
             """It seems like snowflake handler have memory issue that related to pyarrow. Memory usage keep growing with
@@ -382,7 +375,7 @@ if __name__ == "__main__":
     apis = os.getenv("MINDSDB_APIS") or config.cmd_args.api
 
     if apis is None:  # If "--api" option is not specified, start the default APIs
-        api_arr = [TrunkProcessEnum.HTTP, TrunkProcessEnum.MYSQL, TrunkProcessEnum.MCP, TrunkProcessEnum.A2A]
+        api_arr = [TrunkProcessEnum.HTTP, TrunkProcessEnum.MYSQL]
     elif apis == "":  # If "--api=" (blank) is specified, don't start any APIs
         api_arr = []
     else:  # The user has provided a list of APIs to start
@@ -418,9 +411,7 @@ if __name__ == "__main__":
     # Get config values for APIs
     http_api_config = config.get("api", {}).get("http", {})
     mysql_api_config = config.get("api", {}).get("mysql", {})
-    mcp_api_config = config.get("api", {}).get("mcp", {})
     litellm_api_config = config.get("api", {}).get("litellm", {})
-    a2a_api_config = config.get("api", {}).get("a2a", {})
     trunc_processes_struct = {
         TrunkProcessEnum.HTTP: TrunkProcessData(
             name=TrunkProcessEnum.HTTP.value,
@@ -444,12 +435,6 @@ if __name__ == "__main__":
                 "max_restart_interval_seconds", TrunkProcessData.max_restart_interval_seconds
             ),
         ),
-        TrunkProcessEnum.MONGODB: TrunkProcessData(
-            name=TrunkProcessEnum.MONGODB.value,
-            entrypoint=start_mongo,
-            port=config["api"]["mongodb"]["port"],
-            args=(config.cmd_args.verbose,),
-        ),
         TrunkProcessEnum.POSTGRES: TrunkProcessData(
             name=TrunkProcessEnum.POSTGRES.value,
             entrypoint=start_postgres,
@@ -465,18 +450,6 @@ if __name__ == "__main__":
         TrunkProcessEnum.ML_TASK_QUEUE: TrunkProcessData(
             name=TrunkProcessEnum.ML_TASK_QUEUE.value, entrypoint=start_ml_task_queue, args=(config.cmd_args.verbose,)
         ),
-        TrunkProcessEnum.MCP: TrunkProcessData(
-            name=TrunkProcessEnum.MCP.value,
-            entrypoint=start_mcp,
-            port=mcp_api_config.get("port", 47337),
-            args=(config.cmd_args.verbose,),
-            need_to_run=mcp_api_config.get("need_to_run", False),
-            restart_on_failure=mcp_api_config.get("restart_on_failure", False),
-            max_restart_count=mcp_api_config.get("max_restart_count", TrunkProcessData.max_restart_count),
-            max_restart_interval_seconds=mcp_api_config.get(
-                "max_restart_interval_seconds", TrunkProcessData.max_restart_interval_seconds
-            ),
-        ),
         TrunkProcessEnum.LITELLM: TrunkProcessData(
             name=TrunkProcessEnum.LITELLM.value,
             entrypoint=start_litellm,
@@ -488,18 +461,6 @@ if __name__ == "__main__":
                 "max_restart_interval_seconds", TrunkProcessData.max_restart_interval_seconds
             ),
         ),
-        TrunkProcessEnum.A2A: TrunkProcessData(
-            name=TrunkProcessEnum.A2A.value,
-            entrypoint=start_a2a,
-            port=a2a_api_config.get("port", 8001),
-            args=(config.cmd_args.verbose,),
-            need_to_run=a2a_api_config.get("enabled", False),
-            restart_on_failure=a2a_api_config.get("restart_on_failure", True),
-            max_restart_count=a2a_api_config.get("max_restart_count", TrunkProcessData.max_restart_count),
-            max_restart_interval_seconds=a2a_api_config.get(
-                "max_restart_interval_seconds", TrunkProcessData.max_restart_interval_seconds
-            ),
-        ),
     }
 
     for api_enum in api_arr:
@@ -600,7 +561,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/__init__.py

@@ -0,0 +1,52 @@
+# A2A specific imports
+from mindsdb.api.a2a.common.types import (
+    AgentCard,
+    AgentCapabilities,
+    AgentSkill,
+)
+from mindsdb.api.a2a.common.server.server import A2AServer
+from mindsdb.api.a2a.task_manager import AgentTaskManager
+from mindsdb.api.a2a.agent import MindsDBAgent
+from mindsdb.utilities.config import config
+
+
+def get_a2a_app(
+    project_name: str = "mindsdb",
+):
+    mindsdb_port = config.get("api", {}).get("http", {}).get("port", 47334)
+
+    # Prepare A2A artefacts (agent card & task-manager)
+    capabilities = AgentCapabilities(streaming=True)
+    skill = AgentSkill(
+        id="mindsdb_query",
+        name="MindsDB Query",
+        description="Executes natural-language queries via MindsDB agents.",
+        tags=["database", "mindsdb", "query", "analytics"],
+        examples=[
+            "What trends exist in my sales data?",
+            "Generate insights from the support tickets dataset.",
+        ],
+        inputModes=MindsDBAgent.SUPPORTED_CONTENT_TYPES,
+        outputModes=MindsDBAgent.SUPPORTED_CONTENT_TYPES,
+    )
+
+    agent_card = AgentCard(
+        name="MindsDB Agent Connector",
+        description=(f"A2A connector that proxies requests to MindsDB agents in project '{project_name}'."),
+        url=f"http://127.0.0.1:{mindsdb_port}",
+        version="1.0.0",
+        defaultInputModes=MindsDBAgent.SUPPORTED_CONTENT_TYPES,
+        defaultOutputModes=MindsDBAgent.SUPPORTED_CONTENT_TYPES,
+        capabilities=capabilities,
+        skills=[skill],
+    )
+
+    task_manager = AgentTaskManager(
+        project_name=project_name,
+    )
+
+    server = A2AServer(
+        agent_card=agent_card,
+        task_manager=task_manager,
+    )
+    return server.app

mindsdb/api/a2a/agent.py

@@ -1,12 +1,13 @@
 import json
 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
+from mindsdb.utilities import log
+from mindsdb.utilities.config import config
 
-logger = logging.getLogger(__name__)
+logger = log.getLogger(__name__)
 
 
 class MindsDBAgent:
@@ -18,16 +19,15 @@ class MindsDBAgent:
         self,
         agent_name="my_agent",
         project_name="mindsdb",
-        host="localhost",
-        port=47334,
+        user_info: Dict[str, Any] = None,
     ):
         self.agent_name = agent_name
         self.project_name = project_name
-        self.host = host
-        self.port = port
-        self.base_url = f"http://{host}:{port}"
+        port = config.get("api", {}).get("http", {}).get("port", 47334)
+        self.base_url = f"http://localhost:{port}"
         self.agent_url = f"{self.base_url}/api/projects/{project_name}/agents/{agent_name}"
         self.sql_url = f"{self.base_url}/api/sql/query"
+        self.headers = {k: v for k, v in user_info.items() if v is not None} or {}
         logger.info(f"Initialized MindsDB agent connector to {self.base_url}")
 
     def invoke(self, query, session_id) -> Dict[str, Any]:
@@ -35,8 +35,8 @@ class MindsDBAgent:
         try:
             escaped_query = query.replace("'", "''")
             sql_query = f"SELECT * FROM {self.project_name}.{self.agent_name} WHERE question = '{escaped_query}'"
-            logger.info(f"Sending SQL query to MindsDB: {sql_query[:100]}...")
-            response = requests.post(self.sql_url, json={"query": sql_query})
+            logger.debug(f"Sending SQL query to MindsDB: {sql_query[:100]}...")
+            response = requests.post(self.sql_url, json={"query": sql_query}, headers=self.headers)
             response.raise_for_status()
             data = response.json()
             logger.debug(f"Received response from MindsDB: {json.dumps(data)[:200]}...")
@@ -89,8 +89,8 @@ class MindsDBAgent:
 
     async def streaming_invoke(self, messages, timeout=DEFAULT_STREAM_TIMEOUT):
         url = f"{self.base_url}/api/projects/{self.project_name}/agents/{self.agent_name}/completions/stream"
-        logger.info(f"Sending streaming request to MindsDB agent: {self.agent_name}")
-        async with httpx.AsyncClient(timeout=timeout) as client:
+        logger.debug(f"Sending streaming request to MindsDB agent: {self.agent_name}")
+        async with httpx.AsyncClient(timeout=timeout, headers=self.headers) as client:
             async with client.stream("POST", url, json={"messages": to_serializable(messages)}) as response:
                 response.raise_for_status()
                 async for line in response.aiter_lines():
@@ -116,23 +116,12 @@ class MindsDBAgent:
     ) -> AsyncIterable[Dict[str, Any]]:
         """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/server/server.py

@@ -7,6 +7,7 @@ from starlette.middleware.cors import CORSMiddleware
 from starlette.responses import JSONResponse
 from sse_starlette.sse import EventSourceResponse
 from starlette.requests import Request
+from starlette.routing import Route
 from ...common.types import (
     A2ARequest,
     JSONRPCResponse,
@@ -26,7 +27,6 @@ from pydantic import ValidationError
 from ...common.server.task_manager import TaskManager
 
 from mindsdb.utilities import log
-from mindsdb.utilities.log import get_uvicorn_logging_config, get_mindsdb_log_level
 
 logger = log.getLogger(__name__)
 
@@ -34,22 +34,18 @@ logger = log.getLogger(__name__)
 class A2AServer:
     def __init__(
         self,
-        host="0.0.0.0",
-        port=5000,
-        endpoint="/",
         agent_card: AgentCard = None,
         task_manager: TaskManager = None,
     ):
-        self.host = host
-        self.port = port
-        self.endpoint = endpoint
         self.task_manager = task_manager
         self.agent_card = agent_card
-        self.app = Starlette()
-        self.app.add_route(self.endpoint, self._process_request, methods=["POST"])
-        self.app.add_route("/.well-known/agent.json", self._get_agent_card, methods=["GET"])
-        # Add status endpoint
-        self.app.add_route("/status", self._get_status, methods=["GET"])
+        self.app = Starlette(
+            routes=[
+                Route("/", self._process_request, methods=["POST"]),
+                Route("/.well-known/agent.json", self._get_agent_card, methods=["GET"]),
+                Route("/status", self._get_status, methods=["GET"]),
+            ]
+        )
         # TODO: Remove this when we have a proper CORS policy
         self.app.add_middleware(
             CORSMiddleware,
@@ -60,26 +56,6 @@ class A2AServer:
         )
         self.start_time = time.time()
 
-    def start(self):
-        if self.agent_card is None:
-            raise ValueError("agent_card is not defined")
-
-        if self.task_manager is None:
-            raise ValueError("request_handler is not defined")
-
-        import uvicorn
-
-        # Configure uvicorn with optimized settings for streaming
-        uvicorn.run(
-            self.app,
-            host=self.host,
-            port=self.port,
-            http="h11",
-            timeout_keep_alive=65,
-            log_level=get_mindsdb_log_level(),
-            log_config=get_uvicorn_logging_config("uvicorn_a2a"),
-        )
-
     def _get_agent_card(self, request: Request) -> JSONResponse:
         return JSONResponse(self.agent_card.model_dump(exclude_none=True))
 
@@ -94,8 +70,6 @@ class A2AServer:
             "status": "ok",
             "service": "mindsdb-a2a",
             "uptime_seconds": round(uptime_seconds, 2),
-            "host": self.host,
-            "port": self.port,
             "agent_name": self.agent_card.name if self.agent_card else None,
             "version": self.agent_card.version if self.agent_card else "unknown",
         }
@@ -107,13 +81,20 @@ class A2AServer:
             body = await request.json()
             json_rpc_request = A2ARequest.validate_python(body)
 
+            user_info = {
+                "user-id": request.headers.get("user-id", None),
+                "company-id": request.headers.get("company-id", None),
+                "user-class": request.headers.get("user-class", None),
+                "authorization": request.headers.get("Authorization", None),
+            }
+
             if isinstance(json_rpc_request, GetTaskRequest):
                 result = await self.task_manager.on_get_task(json_rpc_request)
             elif isinstance(json_rpc_request, SendTaskRequest):
-                result = await self.task_manager.on_send_task(json_rpc_request)
+                result = await self.task_manager.on_send_task(json_rpc_request, user_info)
             elif isinstance(json_rpc_request, SendTaskStreamingRequest):
                 # Don't await the async generator, just pass it to _create_response
-                result = self.task_manager.on_send_task_subscribe(json_rpc_request)
+                result = self.task_manager.on_send_task_subscribe(json_rpc_request, user_info)
             elif isinstance(json_rpc_request, CancelTaskRequest):
                 result = await self.task_manager.on_cancel_task(json_rpc_request)
             elif isinstance(json_rpc_request, SetTaskPushNotificationRequest):

mindsdb/api/a2a/common/server/task_manager.py

@@ -1,5 +1,5 @@
 from abc import ABC, abstractmethod
-from typing import Union, AsyncIterable, List
+from typing import Union, AsyncIterable, List, Dict
 from ...common.types import Task
 from ...common.types import (
     JSONRPCResponse,
@@ -31,10 +31,10 @@ from ...common.types import (
     InternalError,
 )
 from ...common.server.utils import new_not_implemented_error
+from mindsdb.utilities import log
 import asyncio
-import logging
 
-logger = logging.getLogger(__name__)
+logger = log.getLogger(__name__)
 
 
 class TaskManager(ABC):
@@ -47,12 +47,12 @@ class TaskManager(ABC):
         pass
 
     @abstractmethod
-    async def on_send_task(self, request: SendTaskRequest) -> SendTaskResponse:
+    async def on_send_task(self, request: SendTaskRequest, user_info: Dict) -> SendTaskResponse:
         pass
 
     @abstractmethod
     async def on_send_task_subscribe(
-        self, request: SendTaskStreamingRequest
+        self, request: SendTaskStreamingRequest, user_info: Dict
     ) -> Union[AsyncIterable[SendTaskStreamingResponse], JSONRPCResponse]:
         pass
 
@@ -92,9 +92,7 @@ class InMemoryTaskManager(TaskManager):
             if task is None:
                 return GetTaskResponse(id=request.id, error=TaskNotFoundError())
 
-            task_result = self.append_task_history(
-                task, task_query_params.historyLength
-            )
+            task_result = self.append_task_history(task, task_query_params.historyLength)
 
         return GetTaskResponse(id=request.id, result=task_result)
 
@@ -110,18 +108,16 @@ class InMemoryTaskManager(TaskManager):
         return CancelTaskResponse(id=request.id, error=TaskNotCancelableError())
 
     @abstractmethod
-    async def on_send_task(self, request: SendTaskRequest) -> SendTaskResponse:
+    async def on_send_task(self, request: SendTaskRequest, user_info: Dict) -> SendTaskResponse:
         pass
 
     @abstractmethod
     async def on_send_task_subscribe(
-        self, request: SendTaskStreamingRequest
+        self, request: SendTaskStreamingRequest, user_info: Dict
     ) -> Union[AsyncIterable[SendTaskStreamingResponse], JSONRPCResponse]:
         pass
 
-    async def set_push_notification_info(
-        self, task_id: str, notification_config: PushNotificationConfig
-    ):
+    async def set_push_notification_info(self, task_id: str, notification_config: PushNotificationConfig):
         async with self.lock:
             task = self.tasks.get(task_id)
             if task is None:
@@ -160,14 +156,10 @@ class InMemoryTaskManager(TaskManager):
             logger.error(f"Error while setting push notification info: {e}")
             return JSONRPCResponse(
                 id=request.id,
-                error=InternalError(
-                    message="An error occurred while setting push notification info"
-                ),
+                error=InternalError(message="An error occurred while setting push notification info"),
             )
 
-        return SetTaskPushNotificationResponse(
-            id=request.id, result=task_notification_params
-        )
+        return SetTaskPushNotificationResponse(id=request.id, result=task_notification_params)
 
     async def on_get_task_push_notification(
         self, request: GetTaskPushNotificationRequest
@@ -181,16 +173,12 @@ class InMemoryTaskManager(TaskManager):
             logger.error(f"Error while getting push notification info: {e}")
             return GetTaskPushNotificationResponse(
                 id=request.id,
-                error=InternalError(
-                    message="An error occurred while getting push notification info"
-                ),
+                error=InternalError(message="An error occurred while getting push notification info"),
             )
 
         return GetTaskPushNotificationResponse(
             id=request.id,
-            result=TaskPushNotificationConfig(
-                id=task_params.id, pushNotificationConfig=notification_info
-            ),
+            result=TaskPushNotificationConfig(id=task_params.id, pushNotificationConfig=notification_info),
         )
 
     async def upsert_task(self, task_send_params: TaskSendParams) -> Task:
@@ -216,9 +204,7 @@ class InMemoryTaskManager(TaskManager):
     ) -> Union[AsyncIterable[SendTaskStreamingResponse], JSONRPCResponse]:
         return new_not_implemented_error(request.id)
 
-    async def update_store(
-        self, task_id: str, status: TaskStatus, artifacts: list[Artifact]
-    ) -> Task:
+    async def update_store(self, task_id: str, status: TaskStatus, artifacts: list[Artifact]) -> Task:
         async with self.lock:
             try:
                 task = self.tasks[task_id]

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