tables_db_create_row

Add a new data entry to an existing Appwrite database table by specifying database ID, table ID, row ID, and JSON data.

Instructions

Create a new Row. Before using this route, you should create a new table resource using either a server integration API or directly from your database console.

Input Schema

TableJSON Schema

Name	Required	Description
`database_id`	Yes	Database ID.
`table_id`	Yes	Table ID. You can create a new table using the Database service [server integration](https://appwrite.io/docs/references/cloud/server-dart/tablesDB#createTable). Make sure to define columns before creating rows.
`row_id`	Yes	Row ID. Choose a custom ID or generate a random ID with `ID.unique()`. Valid chars are a-z, A-Z, 0-9, period, hyphen, and underscore. Can't start with a special char. Max length is 36 chars.
`data`	Yes	Row data as JSON object.
`permissions`	No	An array of permissions strings. By default, only the current user is granted all permissions. [Learn more about permissions](https://appwrite.io/docs/permissions).
`transaction_id`	No	Transaction ID for staging the operation.

Implementation Reference

src/mcp_server_appwrite/server.py:103-122 (handler)

Generic handler for all MCP tools, including 'tables_db_create_row'. Retrieves the tool info, calls the bound TablesDB.create_row method with arguments, and returns formatted result or error.

@server.call_tool()
async def handle_call_tool(
    name: str, arguments: dict | None
) -> list[types.TextContent | types.ImageContent | types.EmbeddedResource]:
    
    try:
        tool_info = tools_manager.get_tool(name)
        if not tool_info:
            raise McpError(f"Tool {name} not found")
        
        bound_method = tool_info["function"]
        result = bound_method(**(arguments or {}))
        if hasattr(result, 'to_dict'):
            result_dict = result.to_dict()
            return [types.TextContent(type="text", text=str(result_dict))]
        return [types.TextContent(type="text", text=str(result))]
    except AppwriteException as e:
        return [types.TextContent(type="text", text=f"Appwrite Error: {str(e)}")]
    except Exception as e:
        return [types.TextContent(type="text", text=f"Error: {str(e)}")]

src/mcp_server_appwrite/service.py:73-127 (schema)

Generates tool definitions and input schemas for all methods of TablesDB service, creating 'tables_db_create_row' from the create_row method using introspection, type hints, and docstrings.

def list_tools(self) -> Dict[str, Dict]:
    """Lists all available tools for this service"""
    tools = {}

    for name, func in inspect.getmembers(self.service, predicate=inspect.ismethod):
        if name.startswith('_'): # Skip private methods
            continue

        original_func = func.__func__
        
        # Skip if not from the service's module
        if original_func.__module__ != self.service.__class__.__module__:
            continue

        # Get the overridden name if it exists
        tool_name = self._method_name_overrides.get(name, f"{self.service_name}_{name}")

        docstring = parse(original_func.__doc__)
        signature = inspect.signature(original_func)
        type_hints = get_type_hints(original_func)

        properties = {}
        required = []

        for param_name, param in signature.parameters.items():
            if param_name == 'self':
                continue

            param_type = type_hints.get(param_name, str)
            properties[param_name] = self.python_type_to_json_schema(param_type)
            properties[param_name]["description"] = f"Parameter '{param_name}'"
            
            for doc_param in docstring.params:
                if doc_param.arg_name == param_name:
                    properties[param_name]["description"] = doc_param.description

            if param.default is param.empty:
                required.append(param_name)

        tool_definition = Tool(
            name=tool_name,
            description=f"{docstring.short_description or "No description available"}",
            inputSchema={
                "type": "object",
                "properties": properties,
                "required": required
            }
        )
        
        tools[tool_name] = {
            "definition": tool_definition,
            "function": func
        }
        
    return tools

src/mcp_server_appwrite/server.py:70-71 (registration)
Explicit registration of TablesDB service as 'tables_db' when --tables-db flag is used, triggering tool generation including tables_db_create_row.
```
if args.tables_db:
    tools_manager.register_service(Service(TablesDB(client), "tables_db"))
```
src/mcp_server_appwrite/server.py:94-94 (registration)
Default registration of TablesDB service as 'tables_db' if no other services are specified.
```
tools_manager.register_service(Service(TablesDB(client), "tables_db"))
```
src/mcp_server_appwrite/server.py:13-13 (registration)
Import of the TablesDB class whose methods are wrapped into MCP tools like tables_db_create_row.
```
from appwrite.services.tables_db import TablesDB
```

Appwrite MCP Server