### Run Appwrite MCP Server Locally

Source: https://github.com/appwrite/mcp-for-api/blob/main/README.md

Start the Appwrite MCP server using 'uv run'. Ensure the virtual environment is activated and dependencies are installed.

```bash
uv run -v --directory ./ mcp-server-appwrite
```

--------------------------------

### Install and Run MCP Server with uvx

Source: https://github.com/appwrite/mcp-for-api/blob/main/README.md

Use uvx to directly run the mcp-server-appwrite without a specific installation.

```bash
uvx mcp-server-appwrite
```

--------------------------------

### Install MCP Server with pip

Source: https://github.com/appwrite/mcp-for-api/blob/main/README.md

Install the mcp-server-appwrite package using pip.

```bash
pip install mcp-server-appwrite
```

--------------------------------

### Install uv on Windows

Source: https://github.com/appwrite/mcp-for-api/blob/main/README.md

Install the 'uv' package manager on Windows using PowerShell. This command bypasses execution policy restrictions for installation.

```powershell
powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"
```

--------------------------------

### Install uv on Linux/macOS

Source: https://github.com/appwrite/mcp-for-api/blob/main/README.md

Install the 'uv' package manager using a curl script. This is a prerequisite for managing Python environments and running the server.

```bash
curl -LsSf https://astral.sh/uv/install.sh | sh
```

--------------------------------

### Run MCP Server after pip install

Source: https://github.com/appwrite/mcp-for-api/blob/main/README.md

Execute the mcp-server-appwrite using the python -m command after installing with pip.

```bash
python -m mcp_server_appwrite
```

--------------------------------

### Get File Preview

Source: https://context7.com/appwrite/mcp-for-api/llms.txt

The `storage_get_file_preview` tool can be used to retrieve a preview of an uploaded image. For PNG/JPEG, it returns an `ImageContent` object.

```python
# Preview the uploaded image (returns ImageContent for PNG/JPEG)
result = execute_registered_tool(manager, "storage_get_file_preview", {
    "bucket_id": "my-bucket",
    "file_id": "file-001",
})
# result[0] is types.ImageContent with mimeType="image/png"
```

--------------------------------

### Clone Appwrite MCP Repository

Source: https://github.com/appwrite/mcp-for-api/blob/main/README.md

Clone the Appwrite MCP for API repository from GitHub to your local machine to begin development or setup.

```bash
git clone https://github.com/appwrite/mcp-for-api.git
```

--------------------------------

### Configure and Run Appwrite MCP Server

Source: https://context7.com/appwrite/mcp-for-api/llms.txt

Set up environment variables or a .env file for Appwrite credentials and endpoint. Run the server using uvx or pip and Python.

```bash
# .env
APPWRITE_PROJECT_ID=your-project-id
APPWRITE_API_KEY=your-api-key
APPWRITE_ENDPOINT=https://fra.cloud.appwrite.io/v1

# Load on Linux / macOS
source .env

# Run with uvx (no separate install needed)
uvx mcp-server-appwrite

# Or install and run with pip
pip install mcp-server-appwrite
python -m mcp_server_appwrite
```

--------------------------------

### Execute Appwrite Tool - Create Database with Shorthand

Source: https://context7.com/appwrite/mcp-for-api/llms.txt

Top-level arguments like `database_id` can be provided directly to `execute_public_tool` and are merged with the `arguments` object. `confirm_write` is mandatory for write operations.

```python
operator.execute_public_tool(
    "appwrite_call_tool",
    {
        "tool_name": "tables_db_create",
        "database_id": "main-db",        # top-level key, merged automatically
        "name": "Main Database",
        "confirm_write": True,
    },
)
```

--------------------------------

### Configure Cursor MCP Server on Windows

Source: https://github.com/appwrite/mcp-for-api/blob/main/README.md

Set up the Appwrite MCP server in Cursor settings for Windows, including environment variables.

```cmd
cmd /c SET APPWRITE_PROJECT_ID=your-project-id && SET APPWRITE_API_KEY=your-api-key && uvx mcp-server-appwrite
```

--------------------------------

### Run Live Integration Tests

Source: https://github.com/appwrite/mcp-for-api/blob/main/README.md

Execute live integration tests that interact with real Appwrite resources. Ensure Appwrite credentials are set in the environment or a .env file.

```bash
uv run --extra integration python -m unittest discover -s tests/integration -v
```

--------------------------------

### Service Class for Appwrite SDK

Source: https://context7.com/appwrite/mcp-for-api/llms.txt

Illustrates how to wrap an Appwrite SDK service with the MCP `Service` class to introspect its methods and generate `Tool` definitions. Ensure the Appwrite client is built before creating the `Service` instance.

```python
from appwrite.services.users import Users
from mcp_server_appwrite.server import build_client
from mcp_server_appwrite.service import Service

client = build_client()
users_service = Service(Users(client), "users")

tools = users_service.list_tools()
# keys are tool names: "users_list", "users_get", "users_create", ...

tool_def = tools["users_create"]["definition"]
print(tool_def.name)         # users_create
print(tool_def.description)  # Create a new user.
print(list(tool_def.inputSchema["properties"].keys()))
# ['user_id', 'email', 'password', 'name', 'phone']
```

--------------------------------

### build_client

Source: https://context7.com/appwrite/mcp-for-api/llms.txt

Constructs an authenticated Appwrite client by loading configuration from environment variables or a .env file. It sets the project ID, API key, and endpoint, and adds a custom SDK name header. An optional AppwriteConfig object can be provided for explicit configuration.

```APIDOC
## build_client(config?)

### Description
Loads configuration from environment / `.env`, sets the project ID, API key, and endpoint on an Appwrite `Client`, and adds the `x-sdk-name: mcp` header. Accepts an optional `AppwriteConfig` dataclass; if omitted, configuration is loaded automatically.

### Method
```python
build_client(config?)
```

### Parameters
#### Optional Parameters
- **config** (`AppwriteConfig`) - Optional - An optional AppwriteConfig dataclass for explicit configuration.

### Request Example
```python
from mcp_server_appwrite.server import build_client, AppwriteConfig

# Auto-load from environment
client = build_client()

# Explicit config
config = AppwriteConfig(
    project_id="my-project",
    api_key="my-api-key",
    endpoint="https://fra.cloud.appwrite.io/v1",
)
client = build_client(config)

print(client._endpoint)            # https://fra.cloud.appwrite.io/v1
print(client._global_headers["x-appwrite-project"])  # my-project
```
```

--------------------------------

### Run Unit Tests

Source: https://context7.com/appwrite/mcp-for-api/llms.txt

Command to execute unit tests for the Appwrite project. No Appwrite credentials are required for these tests.

```bash
# Unit tests (no Appwrite credentials needed)
uv run python -m unittest discover -s tests/unit -v
```

--------------------------------

### Execute Registered Tool

Source: https://context7.com/appwrite/mcp-for-api/llms.txt

Demonstrates how to execute a registered Appwrite tool using the `execute_registered_tool` function. This is useful for direct tool invocation.

```python
result = execute_registered_tool(manager, "users_list", {})
```

```python
print(result[0].text)   # JSON string: {"total": 3, "users": [...]}
```

```python
execute_registered_tool(manager, "users_create", {
    "userId": "user-abc",
    "email": "alice@example.com",
    "password": "Passw0rd!123",
    "name": "Alice",
})
```

--------------------------------

### Execute Appwrite Tool - Create User

Source: https://context7.com/appwrite/mcp-for-api/llms.txt

Use `operator.execute_public_tool` to call Appwrite tools. `confirm_write` is mandatory for create, update, or delete operations.

```python
operator.execute_public_tool(
    "appwrite_call_tool",
    {
        "tool_name": "users_create",
        "arguments": {
            "user_id": "user-xyz",
            "email": "bob@example.com",
            "password": "Passw0rd!123",
        },
        "confirm_write": True,     # mandatory for create / update / delete
    },
)
```

--------------------------------

### Configure Cursor MCP Server on MacOS

Source: https://github.com/appwrite/mcp-for-api/blob/main/README.md

Set up the Appwrite MCP server in Cursor settings for MacOS, including environment variables.

```bash
env APPWRITE_API_KEY=your-api-key env APPWRITE_PROJECT_ID=your-project-id uvx mcp-server-appwrite
```

--------------------------------

### Run Unit Tests

Source: https://github.com/appwrite/mcp-for-api/blob/main/README.md

Execute the unit tests for the Appwrite MCP server using 'uv run' and Python's unittest module. The '-v' flag provides verbose output.

```bash
uv run python -m unittest discover -s tests/unit -v
```

--------------------------------

### Validate Appwrite Services at Startup

Source: https://context7.com/appwrite/mcp-for-api/llms.txt

Perform a lightweight probe against the first registered service to confirm endpoint, credentials, and scopes. Raises a RuntimeError if validation fails, providing details about the Appwrite error.

```python
from mcp_server_appwrite.server import build_client, register_services, validate_services
from appwrite.exception import AppwriteException

client = build_client()
manager = register_services(client)

try:
    validate_services(manager)   # raises RuntimeError on bad credentials/scopes
    print("Startup validation passed")
except RuntimeError as exc:
    # e.g. "Appwrite startup validation failed ... tables_db: code=401, type=..."
    print(f"Cannot start: {exc}")
```

--------------------------------

### Configure Appwrite Environment Variables

Source: https://github.com/appwrite/mcp-for-api/blob/main/README.md

Set up your Appwrite project ID, API key, and endpoint in a .env file for the MCP server.

```env
APPWRITE_PROJECT_ID=your-project-id
APPWRITE_API_KEY=your-api-key
APPWRITE_ENDPOINT=https://<REGION>.cloud.appwrite.io/v1
```

--------------------------------

### Build Authenticated Appwrite Client

Source: https://context7.com/appwrite/mcp-for-api/llms.txt

Construct an Appwrite client instance, automatically loading configuration from the environment or explicitly providing an AppwriteConfig object. Verifies the endpoint and project ID headers.

```python
from mcp_server_appwrite.server import build_client, AppwriteConfig

# Auto-load from environment
client = build_client()

# Explicit config
config = AppwriteConfig(
    project_id="my-project",
    api_key="my-api-key",
    endpoint="https://fra.cloud.appwrite.io/v1",
)
client = build_client(config)

print(client._endpoint)            # https://fra.cloud.appwrite.io/v1
print(client._global_headers["x-appwrite-project"])  # my-project
```

--------------------------------

### Create Virtual Environment with uv

Source: https://github.com/appwrite/mcp-for-api/blob/main/README.md

Create a new virtual environment named '.venv' using the 'uv' package manager. This isolates project dependencies.

```bash
uv venv
```

--------------------------------

### Upload File using Storage Service - File Path

Source: https://context7.com/appwrite/mcp-for-api/llms.txt

The `storage_create_file` tool accepts a local file path string for uploading files. Ensure the path is correct.

```python
# Option 1: file path string
execute_registered_tool(manager, "storage_create_file", {
    "bucket_id": "my-bucket",
    "file_id": "file-001",
    "file": "/tmp/report.pdf",
})
```

--------------------------------

### Configure Claude Desktop MCP Server

Source: https://github.com/appwrite/mcp-for-api/blob/main/README.md

Add the Appwrite MCP server configuration to your Claude Desktop settings.

```json
{
  "mcpServers": {
    "appwrite": {
      "command": "uvx",
      "args": [
        "mcp-server-appwrite"
      ],
      "env": {
        "APPWRITE_PROJECT_ID": "<YOUR_PROJECT_ID>",
        "APPWRITE_API_KEY": "<YOUR_API_KEY>",
        "APPWRITE_ENDPOINT": "https://<REGION>.cloud.appwrite.io/v1" // Optional
      }
    }
  }
}

```

--------------------------------

### Claude Desktop IDE Configuration

Source: https://context7.com/appwrite/mcp-for-api/llms.txt

Configuration for Claude Desktop to connect to an Appwrite MCP server. Requires setting environment variables for project ID, API key, and endpoint.

```json
{
  "mcpServers": {
    "appwrite": {
      "command": "uvx",
      "args": ["mcp-server-appwrite"],
      "env": {
        "APPWRITE_PROJECT_ID": "<YOUR_PROJECT_ID>",
        "APPWRITE_API_KEY": "<YOUR_API_KEY>",
        "APPWRITE_ENDPOINT": "https://fra.cloud.appwrite.io/v1"
      }
    }
  }
}
```

--------------------------------

### Activate Virtual Environment on Linux/macOS

Source: https://github.com/appwrite/mcp-for-api/blob/main/README.md

Activate the created virtual environment. This ensures that subsequent commands use the project's isolated Python environment.

```bash
source .venv/bin/activate
```

--------------------------------

### Operator for Public MCP Tool Surface

Source: https://context7.com/appwrite/mcp-for-api/llms.txt

Shows how to set up the `Operator` class, which wraps a `ToolManager` and exposes public tools for interacting with the MCP. The `Operator` maintains a tool catalog and a search engine.

```python
from mcp_server_appwrite.operator import Operator
from mcp_server_appwrite.server import build_client, register_services, execute_registered_tool

client = build_client()
manager = register_services(client)

operator = Operator(
    manager,
    lambda tool_name, args: execute_registered_tool(manager, tool_name, args),
)

# Only two tools are exposed to the MCP client
public_tools = operator.get_public_tools()
print([t.name for t in public_tools])
# ['appwrite_search_tools', 'appwrite_call_tool']
```

--------------------------------

### register_services

Source: https://context7.com/appwrite/mcp-for-api/llms.txt

Registers all Appwrite SDK services with a ToolManager. It wraps each service class in an adapter and makes every public SDK method available as a callable tool.

```APIDOC
## register_services(client) → ToolManager

### Description
Wraps each Appwrite SDK service class in a `Service` adapter and registers it with a `ToolManager`. Returns a `ToolManager` whose `tools_registry` contains every public SDK method as a callable tool definition.

### Method
```python
register_services(client)
```

### Parameters
#### Path Parameters
- **client** (`Client`) - Required - An authenticated Appwrite client instance.

### Response
#### Success Response
- **ToolManager** (`ToolManager`) - A ToolManager instance with all Appwrite services registered as tools.

### Response Example
```python
from mcp_server_appwrite.server import build_client, register_services

client = build_client()
manager = register_services(client)

# Inspect registered service names
service_names = {s.service_name for s in manager.services}
# {'tables_db', 'users', 'teams', 'storage', 'functions',
#  'messaging', 'locale', 'avatars', 'sites'}

# List every tool name the manager knows about
all_tool_names = [t.name for t in manager.get_all_tools()]
print(all_tool_names[:5])
# ['tables_db_list', 'tables_db_get', 'tables_db_create', ...]
```
```

--------------------------------

### Activate Virtual Environment on Windows

Source: https://github.com/appwrite/mcp-for-api/blob/main/README.md

Activate the created virtual environment on Windows. This command sets up the shell to use the project's isolated Python environment.

```powershell
.venv\Scripts\activate
```

--------------------------------

### appwrite_search_tools: Natural Language Catalog Search

Source: https://context7.com/appwrite/mcp-for-api/llms.txt

Demonstrates searching the Appwrite tool catalog using natural language queries via the `appwrite_search_tools` public tool. This tool scores matches based on token overlap, service hints, and argument coverage.

```python
# Via operator.execute_public_tool (same interface the MCP host uses)
result = operator.execute_public_tool(
    "appwrite_search_tools",
    {
        "query": "list databases",
        "service_hints": ["tables_db"],   # optional service filter
        "argument_hints": {},             # known args for missing-required detection
        "include_mutating": False,        # default: inferred from query
        "limit": 5,
    },
)
print(result[0].text)
# 1. tool=tables_db_list service=tables_db class=read required=none score=25
#    List all databases.
#
# Call via appwrite_call_tool with tool_name and arguments.
# Full catalog resource: appwrite://operator/catalog
```

--------------------------------

### ToolManager for Centralized Tool Registry

Source: https://context7.com/appwrite/mcp-for-api/llms.txt

Demonstrates the use of `ToolManager` to aggregate tools from multiple Appwrite services. Register services using `register_service` and retrieve tools via `get_all_tools` or `get_tool`.

```python
from mcp_server_appwrite.tool_manager import ToolManager
from mcp_server_appwrite.service import Service
from appwrite.services.users import Users
from appwrite.services.teams import Teams
from mcp_server_appwrite.server import build_client

client = build_client()
manager = ToolManager()
manager.register_service(Service(Users(client), "users"))
manager.register_service(Service(Teams(client), "teams"))

tool_info = manager.get_tool("users_list")
# tool_info["definition"] → Tool(name="users_list", ...)
# tool_info["function"]   → bound method Users.list
# tool_info["parameter_types"] → {}

all_names = [t.name for t in manager.get_all_tools()]
print(all_names)
# ['users_list', 'users_get', ..., 'teams_list', 'teams_create', ...]
```

--------------------------------

### Read Appwrite Catalog Resource

Source: https://context7.com/appwrite/mcp-for-api/llms.txt

Access the full tool catalog as a static MCP resource using `operator.read_resource`. The content is returned as a JSON string that needs to be parsed.

```python
import json

# Read the full hidden catalog
catalog_contents = operator.read_resource("appwrite://operator/catalog")
catalog = json.loads(catalog_contents[0].content)
print(catalog[0])
```

--------------------------------

### Register Appwrite Services with ToolManager

Source: https://context7.com/appwrite/mcp-for-api/llms.txt

Register all Appwrite SDK services with a ToolManager, making their methods available as callable tools. Inspects registered service names and lists all available tool names.

```python
from mcp_server_appwrite.server import build_client, register_services

client = build_client()
manager = register_services(client)

# Inspect registered service names
service_names = {s.service_name for s in manager.services}
# {'tables_db', 'users', 'teams', 'storage', 'functions',
#  'messaging', 'locale', 'avatars', 'sites'}

# List every tool name the manager knows about
all_tool_names = [t.name for t in manager.get_all_tools()]
print(all_tool_names[:5])
# ['tables_db_list', 'tables_db_get', 'tables_db_create', ...]
```

--------------------------------

### Source .env file on Windows Command Prompt

Source: https://github.com/appwrite/mcp-for-api/blob/main/README.md

Load environment variables from a .env file into your current Command Prompt session on Windows.

```cmd
for /f "tokens=1,2 delims==" %A in (.env) do set %A=%B
```

--------------------------------

### appwrite_call_tool: Execute a Hidden Appwrite Tool

Source: https://context7.com/appwrite/mcp-for-api/llms.txt

Explains how to execute a specific Appwrite tool by its name using the `appwrite_call_tool` public tool. Write and delete operations require `confirm_write=true`. Large results are stored and returned via a URI.

```python
# Read tool – no confirm_write needed
result = operator.execute_public_tool(
    "appwrite_call_tool",
    {
        "tool_name": "users_list",
        "arguments": {},
    },
)
```

--------------------------------

### Debug Appwrite MCP Server with Inspector

Source: https://github.com/appwrite/mcp-for-api/blob/main/README.md

Debug the Appwrite MCP server using the MCP inspector. Ensure your .env file is correctly configured for Appwrite credentials.

```bash
npx @modelcontextprotocol/inspector \
  uv \
  --directory . \
  run mcp-server-appwrite
```

--------------------------------

### validate_services

Source: https://context7.com/appwrite/mcp-for-api/llms.txt

Performs a lightweight probe against the first registered service to validate Appwrite credentials, project ID, API key, and required scopes. Raises a RuntimeError if validation fails.

```APIDOC
## validate_services(tools_manager)

### Description
Runs a lightweight read probe against the first registered service to confirm the endpoint, project ID, API key, and required scopes are all valid. Raises `RuntimeError` with a descriptive message (including the Appwrite error code and type) if the probe fails.

### Method
```python
validate_services(tools_manager)
```

### Parameters
#### Path Parameters
- **tools_manager** (`ToolManager`) - Required - The ToolManager instance containing the registered services.

### Request Example
```python
from mcp_server_appwrite.server import build_client, register_services, validate_services
from appwrite.exception import AppwriteException

client = build_client()
manager = register_services(client)

try:
    validate_services(manager)   # raises RuntimeError on bad credentials/scopes
    print("Startup validation passed")
except RuntimeError as exc:
    # e.g. "Appwrite startup validation failed ... tables_db: code=401, type=..."
    print(f"Cannot start: {exc}")
```
```

--------------------------------

### Source .env file on Linux/MacOS

Source: https://github.com/appwrite/mcp-for-api/blob/main/README.md

Load environment variables from a .env file into your current shell session on Linux or MacOS.

```sh
source .env
```

--------------------------------

### Configure Windsurf Editor for Appwrite MCP

Source: https://github.com/appwrite/mcp-for-api/blob/main/README.md

Update the mcp_config.json file in Windsurf Editor to include the Appwrite MCP server configuration. Ensure your project ID, API key, and endpoint are correctly set.

```json
{
  "mcpServers": {
    "appwrite": {
      "command": "uvx",
      "args": [
        "mcp-server-appwrite"
      ],
      "env": {
        "APPWRITE_PROJECT_ID": "<YOUR_PROJECT_ID>",
        "APPWRITE_API_KEY": "<YOUR_API_KEY>",
        "APPWRITE_ENDPOINT": "https://<REGION>.cloud.appwrite.io/v1" // Optional
      }
    }
  }
}
```

--------------------------------

### VS Code IDE Configuration

Source: https://context7.com/appwrite/mcp-for-api/llms.txt

Configuration for VS Code to connect to an Appwrite MCP server. Similar to Claude Desktop, it requires setting environment variables for project ID, API key, and endpoint.

```json
{
  "servers": {
    "appwrite": {
      "command": "uvx",
      "args": ["mcp-server-appwrite"],
      "env": {
        "APPWRITE_PROJECT_ID": "<YOUR_PROJECT_ID>",
        "APPWRITE_API_KEY": "<YOUR_API_KEY>",
        "APPWRITE_ENDPOINT": "https://fra.cloud.appwrite.io/v1"
      }
    }
  }
}
```

--------------------------------

### Source .env file on Windows PowerShell

Source: https://github.com/appwrite/mcp-for-api/blob/main/README.md

Load environment variables from a .env file into your current PowerShell session on Windows.

```powershell
Get-Content .\.env | ForEach-Object {
  if ($_ -match '^(.*?)=(.*)$') {
    [System.Environment]::SetEnvironmentVariable($matches[1], $matches[2], "Process")
  }
}
```

--------------------------------

### Upload File using Storage Service - Inline Base64 Content

Source: https://context7.com/appwrite/mcp-for-api/llms.txt

For uploading files with inline content, provide a dictionary with filename, base64 encoded content, encoding type, and MIME type to the `file` parameter.

```python
import base64

execute_registered_tool(manager, "storage_create_file", {
    "bucket_id": "my-bucket",
    "file_id": "file-002",
    "file": {
        "filename": "hello.txt",
        "content": base64.b64encode(b"Hello, Appwrite!").decode(),
        "encoding": "base64",
        "mime_type": "text/plain",
    },
})
```

--------------------------------

### Debug MCP Inspector

Source: https://context7.com/appwrite/mcp-for-api/llms.txt

Command to run the MCP Inspector for debugging the full stdio transport of the Appwrite MCP server.

```bash
# MCP Inspector (debug the full stdio transport)
npx @modelcontextprotocol/inspector uv --directory . run mcp-server-appwrite
```

--------------------------------

### Execute Registered Appwrite Tool

Source: https://context7.com/appwrite/mcp-for-api/llms.txt

Invoke a hidden Appwrite tool by its name and arguments. The function handles argument normalization, tool invocation, and serializes the result into MCP content types.

```python
from mcp_server_appwrite.server import build_client, register_services, execute_registered_tool
import mcp.types as types

client = build_client()
manager = register_services(client)


```

--------------------------------

### execute_registered_tool

Source: https://context7.com/appwrite/mcp-for-api/llms.txt

Invokes a specific Appwrite tool registered within the ToolManager. It looks up the tool by name, normalizes arguments, calls the corresponding Appwrite SDK method, and serializes the result into an MCP content type.

```APIDOC
## execute_registered_tool(tools_manager, name, arguments)

### Description
Looks up the named tool in the registry, normalises and coerces arguments (snake_case / camelCase / `$`-prefixed Appwrite response fields), calls the underlying SDK method, and serialises the result as MCP content types (`TextContent`, `ImageContent`, or `EmbeddedResource`).

### Method
```python
execute_registered_tool(tools_manager, name, arguments)
```

### Parameters
#### Path Parameters
- **tools_manager** (`ToolManager`) - Required - The ToolManager instance containing the registered services.
- **name** (`str`) - Required - The name of the tool to execute.
- **arguments** (`dict`) - Required - A dictionary of arguments to pass to the tool.

### Request Example
```python
from mcp_server_appwrite.server import build_client, register_services, execute_registered_tool
import mcp.types as types

client = build_client()
manager = register_services(client)

# Example of executing a tool (assuming 'users_list' is a registered tool)
# try:
#     result = execute_registered_tool(manager, 'users_list', {'limit': 10})
#     print(result)
# except Exception as e:
#     print(f"Error executing tool: {e}")
```
```

--------------------------------

### Configure VS Code for Appwrite MCP

Source: https://github.com/appwrite/mcp-for-api/blob/main/README.md

Add the Appwrite MCP server configuration to your VS Code user settings (mcp.json). This enables VS Code to connect to the Appwrite MCP server.

```json
{
  "servers": {
    "appwrite": {
      "command": "uvx",
      "args": ["mcp-server-appwrite"],
      "env": {
        "APPWRITE_PROJECT_ID": "<YOUR_PROJECT_ID>",
        "APPWRITE_API_KEY": "<YOUR_API_KEY>",
        "APPWRITE_ENDPOINT": "https://<REGION>.cloud.appwrite.io/v1"
      }
    }
  }
}
```

--------------------------------

### Read Stored Large Tool Result

Source: https://context7.com/appwrite/mcp-for-api/llms.txt

After a tool execution that results in a large output, the result is stored and a URI is provided. Use `operator.read_resource` with this URI to retrieve the full data.

```python
import re
result = operator.execute_public_tool("appwrite_call_tool", {"tool_name": "users_list"})
# result[0].text ends with "...Full result stored at appwrite://operator/results/<uuid>"
uri_match = re.search(r"appwrite://operator/results/[\w-]+", result[0].text)
if uri_match:
    stored = operator.read_resource(uri_match.group())
    full_data = json.loads(stored[0].content)
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.