refactor (MCP): refactor MCP tools; share AI Assistant capabilities (baserow#4980)

* feat(mcp): refactor tools to service layer and add database/table/field CRUD

Replace internal API request pattern with a dedicated service module for
MCP operations. Simplify tool architecture from dynamic per-table tools
to static tools with explicit table_id parameters. Add new tools for
managing databases, tables, fields, and batch row operations.

* fix(mcp): address Copilot review feedback

- Let exceptions propagate from MCPTool.call() so call_tool() logs them
- Fix N+1 queries in get_table_schema using enhance_field_queryset hook
- Fetch fields for all tables in a single specific_iterator pass
- Clamp list_rows pagination to safe bounds (ROW_PAGE_SIZE_LIMIT)
- Fix update_fields docstring to reflect type-change support
- Fix module path in utils.py comment
- Update "Adding a new tool" docs to match current MCPTool pattern

* fix: comment risky tools; waiting for a proper permission check

* feat(mcp): add enabled flag to MCPTool and disable risky tools

Add `enabled` attribute to MCPTool base class so tools can be registered
but hidden from MCP clients. Disable database/table/field CRUD tools
until users can control tool availability through the UI.

Also add docs/testing/mcp-test-plan.md with manual testing instructions.

* fix(mcp): replace list[dict] with typed Pydantic models for field/row specs

Validate required keys (name+type for field create, id for field update,
id for row update) at the schema level instead of relying on KeyError
from dict.pop() in the service layer.

Uses extra="allow" so type-specific options and field values pass through.

* fix: wrap update_rows in a transaction

* address feedback

Author: silvestrid

backend/src/baserow/contrib/database/apps.py

@@ -1037,20 +1037,44 @@ def ready(self):
         notification_type_registry.register(WebhookDeactivatedNotificationType())
         notification_type_registry.register(WebhookPayloadTooLargeNotificationType())
 
+        from baserow.contrib.database.mcp.fields.tools import (
+            CreateFieldsMcpTool,
+            DeleteFieldsMcpTool,
+            UpdateFieldsMcpTool,
+        )
         from baserow.contrib.database.mcp.rows.tools import (
-            CreateRowMcpTool,
-            DeleteRowMcpTool,
+            CreateRowsMcpTool,
+            DeleteRowsMcpTool,
             ListRowsMcpTool,
-            UpdateRowMcpTool,
+            UpdateRowsMcpTool,
+        )
+        from baserow.contrib.database.mcp.table.tools import (
+            CreateDatabaseMcpTool,
+            CreateTableMcpTool,
+            DeleteTableMcpTool,
+            GetTableSchemaMcpTool,
+            ListDatabasesMcpTool,
+            ListTablesMcpTool,
+            UpdateTableMcpTool,
         )
-        from baserow.contrib.database.mcp.table.tools import ListTablesMcpTool
         from baserow.core.mcp.registries import mcp_tool_registry
 
+        mcp_tool_registry.register(ListDatabasesMcpTool())
         mcp_tool_registry.register(ListTablesMcpTool())
+        mcp_tool_registry.register(GetTableSchemaMcpTool())
         mcp_tool_registry.register(ListRowsMcpTool())
-        mcp_tool_registry.register(CreateRowMcpTool())
-        mcp_tool_registry.register(UpdateRowMcpTool())
-        mcp_tool_registry.register(DeleteRowMcpTool())
+        mcp_tool_registry.register(CreateRowsMcpTool())
+        mcp_tool_registry.register(UpdateRowsMcpTool())
+        mcp_tool_registry.register(DeleteRowsMcpTool())
+        # Disabled (enabled=False) until users can control tool
+        # availability through the UI.
+        mcp_tool_registry.register(CreateDatabaseMcpTool())
+        mcp_tool_registry.register(CreateTableMcpTool())
+        mcp_tool_registry.register(UpdateTableMcpTool())
+        mcp_tool_registry.register(DeleteTableMcpTool())
+        mcp_tool_registry.register(CreateFieldsMcpTool())
+        mcp_tool_registry.register(UpdateFieldsMcpTool())
+        mcp_tool_registry.register(DeleteFieldsMcpTool())
 
         from baserow.contrib.database.rows.history_providers import (
             CreateRowHistoryProvider,

backend/src/baserow/contrib/database/mcp/fields/__init__.py

@@ -0,0 +1 @@
+

backend/src/baserow/contrib/database/mcp/fields/schemas.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class FieldSpec(BaseModel):
+    """A field to create: name and type are required, extra keys are type-specific."""
+
+    model_config = ConfigDict(extra="allow")
+
+    name: str = Field(..., description="The field name.")
+    type: str = Field(..., description="The field type (e.g. text, number, link_row).")
+
+
+class FieldUpdateSpec(BaseModel):
+    """A field to update: id is required, extra keys are the properties to change."""
+
+    model_config = ConfigDict(extra="allow")
+
+    id: int = Field(..., description="The ID of the field to update.")
+
+
+class CreateFieldsInput(BaseModel):
+    table_id: int = Field(..., description="The ID of the table to add fields to.")
+    fields: list[FieldSpec] = Field(
+        ...,
+        description=(
+            "List of fields to create. Each item must have 'name' "
+            "and 'type'. See create_table for valid types and extras."
+        ),
+    )
+
+
+class UpdateFieldsInput(BaseModel):
+    fields: list[FieldUpdateSpec] = Field(
+        ...,
+        description=(
+            "List of field updates. Each item must have 'id' "
+            "plus the properties to change (name, type, "
+            "or type-specific options)."
+        ),
+    )
+
+
+class DeleteFieldsInput(BaseModel):
+    field_ids: list[int] = Field(..., description="List of field IDs to delete.")

backend/src/baserow/contrib/database/mcp/fields/tools.py

@@ -0,0 +1,61 @@
+from baserow.contrib.database.mcp import services
+from baserow.contrib.database.mcp.fields.schemas import (
+    CreateFieldsInput,
+    DeleteFieldsInput,
+    UpdateFieldsInput,
+)
+from baserow.core.mcp.models import MCPEndpoint
+from baserow.core.mcp.registries import MCPTool
+
+
+class CreateFieldsMcpTool(MCPTool):
+    """
+    Add one or more fields to an existing table.
+    Call get_table_schema first to see existing fields and avoid duplicates.
+    Fields are created in dependency order (regular → link_row → lookup → formula).
+    For link_row fields, the linked table must already exist.
+    """
+
+    type = "create_fields"
+    enabled = False
+    input_schema = CreateFieldsInput
+
+    def _sync_call(self, endpoint: MCPEndpoint, args: CreateFieldsInput) -> list[dict]:
+        return services.create_fields(
+            endpoint.user,
+            endpoint.workspace,
+            args.table_id,
+            [f.model_dump() for f in args.fields],
+        )
+
+
+class UpdateFieldsMcpTool(MCPTool):
+    """
+    Update one or more existing fields (rename, change type, change properties).
+    Call get_table_schema first to get field IDs and current types.
+    """
+
+    type = "update_fields"
+    enabled = False
+    input_schema = UpdateFieldsInput
+
+    def _sync_call(self, endpoint: MCPEndpoint, args: UpdateFieldsInput) -> list[dict]:
+        return services.update_fields(
+            endpoint.user, endpoint.workspace, [f.model_dump() for f in args.fields]
+        )
+
+
+class DeleteFieldsMcpTool(MCPTool):
+    """
+    Delete (trash) one or more fields by ID.
+    Primary fields cannot be deleted.
+    Call get_table_schema first to confirm field IDs.
+    """
+
+    type = "delete_fields"
+    enabled = False
+    input_schema = DeleteFieldsInput
+
+    def _sync_call(self, endpoint: MCPEndpoint, args: DeleteFieldsInput) -> str:
+        services.delete_fields(endpoint.user, endpoint.workspace, args.field_ids)
+        return "Fields successfully deleted."

backend/src/baserow/contrib/database/mcp/rows/schemas.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class ListRowsInput(BaseModel):
+    table_id: int = Field(..., description="The ID of the table to list rows from.")
+    search: str | None = Field(None, description="Optional search term to filter rows.")
+    page: int = Field(1, description="Page number (1-based).")
+    size: int = Field(100, description="Maximum number of rows to return.")
+
+
+class CreateRowsInput(BaseModel):
+    table_id: int = Field(..., description="The ID of the table to create rows in.")
+    rows: list[dict] = Field(
+        ...,
+        description=(
+            "List of rows to create. Each row is an object mapping field name to value."
+        ),
+    )
+
+
+class RowUpdateSpec(BaseModel):
+    """A row to update: id is required, extra keys are field name → new value."""
+
+    model_config = ConfigDict(extra="allow")
+
+    id: int = Field(..., description="The row ID.")
+
+
+class UpdateRowsInput(BaseModel):
+    table_id: int = Field(..., description="The ID of the table containing the rows.")
+    rows: list[RowUpdateSpec] = Field(
+        ...,
+        description=(
+            "List of rows to update. Each row must have 'id' "
+            "plus the field names and their new values."
+        ),
+    )
+
+
+class DeleteRowsInput(BaseModel):
+    table_id: int = Field(..., description="The ID of the table to delete rows from.")
+    row_ids: list[int] = Field(..., description="List of row IDs to delete.")