tables_db_create_relationship_column

Create a relationship column between tables in Appwrite databases to establish data connections and enforce referential integrity.

Instructions

Create relationship column. Learn more about relationship columns.

Input Schema

TableJSON Schema

Name	Required	Description
`database_id`	Yes	Database ID.
`table_id`	Yes	Table ID.
`related_table_id`	Yes	Related Table ID.
`type`	Yes	Relation type
`two_way`	No	Is Two Way?
`key`	No	Column Key.
`two_way_key`	No	Two Way Column Key.
`on_delete`	No	Constraints option

Implementation Reference

src/mcp_server_appwrite/server.py:70-72 (registration)
Registers the TablesDB service with the tool manager using service name "tables_db". This enables dynamic registration of all public methods on TablesDB(client) as MCP tools prefixed with "tables_db_", including "tables_db_create_relationship_column" (assuming TablesDB has a method named create_relationship_column). Similar registration occurs by default if no services specified (lines 92-94).
```
if args.tables_db:
    tools_manager.register_service(Service(TablesDB(client), "tables_db"))
if args.users:
```

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

Generic handler for all registered tools. For "tables_db_create_relationship_column", it retrieves the bound method from TablesDB.create_relationship_column and invokes it with the provided arguments, returning the result as text.

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

Dynamically inspects the service instance (TablesDB) to generate tool definitions. Constructs the tool name "tables_db_create_relationship_column" from service_name + method_name (line 88), builds inputSchema from type hints and docstrings (lines 94-119), and registers the tool with its bound function.

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/tool_manager.py:10-14 (helper)
ToolManager method that registers a service by appending it to services list and updating the tools_registry with the tools from service.list_tools(). This is called when registering tables_db service.
```
def register_service(self, service: Service):
    """Register a new service and its tools"""
    self.services.append(service)
    self.tools_registry.update(service.list_tools())
```

Appwrite MCP Server