mindsdb

MindsDB exposes a MySQL-compatible protocol (port 47335) and HTTP REST API that translates standard SQL queries into source-specific API calls and database commands. The IntegrationController manages 200+ data source handlers (PostgreSQL, MySQL, BigQuery, MongoDB, Salesforce, GitLab, etc.), each implementing a unified interface that abstracts connection pooling, authentication, and query translation. Queries are parsed into an AST, optimized, and dispatched to appropriate handlers with result aggregation and schema inference happening transparently.

MindsDB's KNOWLEDGE_BASE abstraction fuses structured tables (from databases) with vectorized unstructured data (PDFs, HTML, text) by storing embeddings in integrated vector databases (Pinecone, Weaviate, Milvus, etc.). The RAG pipeline implementation accepts documents, chunks them, generates embeddings via configured LLM providers, and stores them alongside metadata. Queries trigger semantic search to retrieve relevant context, which is then joined with structured data and passed to reasoning agents. The knowledge base is queryable via SQL, enabling agents to perform hybrid structured-semantic searches.

MindsDB organizes resources (models, agents, knowledge bases, data connections) into Projects, providing logical isolation and multi-tenancy. Each project has its own namespace, allowing teams to organize work by domain, customer, or application. Projects are queryable via REST API and SQL, enabling programmatic project management. Access control is enforced at the project level, supporting role-based permissions for team collaboration.

MindsDB supports scheduled job execution via cron-like syntax, enabling automated workflows such as periodic model retraining, data synchronization, and report generation. Jobs are defined via SQL (CREATE JOB) or REST API, specifying a query to execute and a schedule. The job scheduler manages execution, handles failures with retry logic, and logs execution history. Jobs can trigger agents, execute SQL queries, or invoke external webhooks, enabling complex automation without external orchestration tools.

MindsDB integrates with multiple vector databases (Pinecone, Weaviate, Milvus, Qdrant, Chroma) to store and query embeddings. The integration abstracts vector database APIs, enabling semantic search queries via SQL (e.g., 'SELECT * FROM vector_db WHERE semantic_search(query)'). Embeddings are generated via configured LLM providers and stored alongside metadata, enabling hybrid queries that combine semantic similarity with structured filters. The vector database handler manages connection pooling, index management, and result ranking.

MindsDB abstracts LLM provider APIs (OpenAI, Anthropic, Ollama, HuggingFace, Vertex AI, etc.) behind a unified interface, enabling agents and models to use any provider without code changes. Providers are configured via REST API or SQL, with credentials stored securely. The LLM handler manages API calls, token counting, rate limiting, and fallback logic. Agents can specify a preferred provider, and MindsDB automatically routes requests to the appropriate API.

MindsDB's AI Agents System implements a skill-based architecture where agents are composed of reusable tools (skills) that map to database queries, API calls, or LLM invocations. The agent execution engine uses a planning-reasoning loop: the LLM decomposes user intent into subtasks, selects appropriate skills, executes them via the unified SQL/API layer, and iterates until the goal is achieved. Skills are registered in a schema-based function registry, enabling multi-provider LLM support (OpenAI, Anthropic, Ollama) with native function-calling APIs. Agent state is managed via a session context that persists across reasoning steps.

MindsDB exposes an MCP server interface that allows external AI agents (Claude, other LLM-based systems) to interact with MindsDB capabilities as MCP resources and tools. The MCP implementation translates agent requests into MindsDB operations: querying data sources, executing agents, managing knowledge bases, and retrieving results. This enables Claude and other MCP-compatible agents to treat MindsDB as a data and reasoning backend without direct API calls, using the standardized MCP protocol for resource discovery and tool invocation.

MindsDB implements an Agent-to-Agent protocol that enables autonomous agents to communicate, delegate tasks, and share context. Agents can invoke other agents via the A2A protocol, passing structured parameters and receiving results, enabling hierarchical task decomposition and specialization. The protocol manages agent discovery, request routing, and result aggregation, allowing complex workflows where agents collaborate to solve problems that require multiple specialized skills or data sources.

MindsDB exposes ML model training and inference through SQL commands (CREATE MODEL, SELECT ... FROM model_name), abstracting the complexity of feature engineering, hyperparameter tuning, and model selection. The system integrates with Lightwood (MindsDB's AutoML engine) and external ML frameworks (scikit-learn, TensorFlow, XGBoost via handlers). Training queries automatically handle data preprocessing, feature engineering, train/test splitting, and model evaluation. Predictions are executed via SELECT queries that join input data with the trained model, returning predictions with confidence scores.

MindsDB's BYOM system allows developers to register custom ML models (trained in scikit-learn, TensorFlow, PyTorch, etc.) as queryable MindsDB models. Models are packaged as Python classes implementing a standard interface (fit, predict methods), uploaded to MindsDB, and then invoked via SQL SELECT queries. The system handles model versioning, serialization, and execution in isolated Python environments, enabling teams to deploy proprietary or domain-specific models without rewriting them for MindsDB's AutoML engine.

MindsDB integrates with HuggingFace's model hub, allowing developers to deploy pre-trained NLP and vision models (text classification, summarization, object detection, etc.) as queryable MindsDB models. The integration handles model downloading, caching, tokenization, and inference through a unified SQL interface. Models are invoked via SELECT queries, with input text or images passed as query parameters and results returned as structured data (classifications, summaries, detections).

MindsDB exposes a comprehensive HTTP REST API (port 47334) that enables programmatic access to all core capabilities: executing SQL queries, managing projects, creating/training models, deploying agents, and managing knowledge bases. The API follows RESTful conventions with JSON request/response bodies, supports authentication via API keys, and provides OpenAPI documentation for client generation. The API is the primary integration point for external applications, dashboards, and automation tools.

MindsDB implements the MySQL wire protocol (port 47335), allowing any MySQL-compatible client (MySQL CLI, Tableau, Metabase, DBeaver, etc.) to connect and query MindsDB as if it were a MySQL server. The protocol adapter translates MySQL commands into MindsDB operations, enabling seamless integration with existing BI tools, SQL IDEs, and reporting systems without custom drivers or adapters. Connection pooling, prepared statements, and transaction semantics are supported.