Appwrite Command Line Interface Server Module

mcp-name: io.github.appwrite/mcp-for-api

Conceptual Overview

This Model Context Protocol (MCP) backend module is designed specifically for interfacing with the Appwrite REST API. It furnishes developers with the necessary constructs to orchestrate administrative operations across databases, user identity systems, deployed server functions, team structures, and various other project components residing within an Appwrite environment.

Rapid Access Links

• Setup Parameters
• Acquisition Steps
• IDE Integration Details:
• For Claude Desktop Users
• For Cursor Users
• For Windsurf Editor Users
• For VS Code Users
• Local Environment Configuration
• Troubleshooting

Configuration Prerequisites

Prior to initiating the MCP service, one must establish an active Appwrite project and generate an API access token provisioned with all requisite operational permissions (scopes).

Establish a configuration file named .env within your primary working directory and populate it with the following key-value pairs:

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

Subsequently, execute the appropriate shell command to inject these variables into the active session environment:

Linux and MacOS Shells

source .env

Windows Environments

Command Prompt (cmd)

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

PowerShell

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

Acquisition Procedures

Utilizing uv (Preferred Method)

When leveraging the uv package manager for dependency handling, dedicated installation is bypassed. We employ uvx to execute the mcp-server-appwrite binary directly.

uvx mcp-server-appwrite [optional-arguments]

Using pip

pip install mcp-server-appwrite

Then initiate the service via:

python -m mcp_server_appwrite [optional-arguments]

Command Line Parameters

Both the uv and pip bootstrap routines necessitate specific flag arguments to activate the MCP tools corresponding to distinct Appwrite API segments.

When an MCP utility is activated, its schema definition is transmitted to the Language Model, consuming a portion of the model's finite contextual capacity. Consequently, the usable context window shrinks.

By default, the Appwrite MCP server module activates only the Databases tools (our most frequently required API set) to adhere to these capacity restrictions. Additional functionalities can be integrated using the switches detailed below.

Argument	Purpose
--databases	Activates Database Management API toolset
--users	Activates User Account Management API toolset
--teams	Activates Team/Group Management API toolset
--storage	Activates File Storage API toolset
--functions	Activates Serverless Function Execution API toolset
--messaging	Activates Messaging/Notification API toolset
--locale	Activates Locale/Localization API toolset
--avatars	Activates Avatar Generation API toolset
--sites	Activates Site Configuration API toolset
--all	Enables the complete suite of Appwrite APIs

Integration with Claude Desktop

Within the Claude Desktop application, navigate to Settings (access via CTRL + , on Windows or CMD + , on MacOS) and proceed to the Developer section. Click Edit Config to modify the claude_desktop_config.json file, where you must append the subsequent JSON structure:

{
  "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
      }
    }
  }
}

Troubleshooting Tip: If an uvx ENOENT exception occurs, verify that uvx is correctly present in your system's PATH environment variable, or alternatively, specify the absolute filesystem path to your uvx executable within the configuration file.

Once configuration is finalized, the server instance should appear listed among the active servers accessible within the Claude Desktop interface.

Integration with Cursor

Access Cursor's configuration panel via Settings > MCP and select the Add new MCP server option. Designate the type as Command and input the relevant execution string into the Command input field, dependent on your operating system:

• MacOS/Linux Execution String

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

• Windows Execution String

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

Integration with Windsurf Editor

Navigate to Windsurf's configuration panel at Settings > Cascade > Model Context Protocol (MCP) Servers and choose View raw config. Modify the mcp_config.json file to incorporate the following block:

{
  "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
      }
    }
  }
}

Integration with VS Code

Configuration Steps

1. Modify the MCP Settings File: Invoke the Command Palette (Ctrl+Shift+P or Cmd+Shift+P) and execute the command MCP: Open User Configuration. This action will load the mcp.json settings file associated with your user profile.

2. Insert the Appwrite Server Definition: Add the subsequent configuration snippet into your mcp.json file:

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

1. Initiate the MCP Service: Access the Command Palette again (Ctrl+Shift+P or Cmd+Shift+P) and select MCP: List Servers. Choose appwrite from the presented options and trigger the Start Server action.

2. Utilization within Copilot Chat: Switch the Copilot Chat interface into Agent Mode to gain functional access to the Appwrite toolset.

Local Environment Setup

Source Code Acquisition

git clone https://github.com/appwrite/mcp.git

Installing uv Dependency Manager

• For Linux or MacOS shells

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

• For Windows using PowerShell

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

Virtual Environment Preparation

First, initialize a dedicated isolated Python environment.

uv venv

Next, activate the newly created environment.

• Linux or MacOS

source .venv/bin/activate

• Windows

.venv\Scripts\activate

Running the Server Locally

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

Diagnostic Procedures

Debugging the server operation can be performed using the official MCP inspector utility.

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

Ensure that the credentials defined in your .env file are correctly provisioned before attempting to launch the inspector. The debugging interface will then be reachable at http://localhost:5173.

Licensing Information

This MCP server module is released under the terms of the MIT License. This grants recipients the liberty to employ, modify, and disseminate the software, contingent upon adherence to the stipulations outlined in the MIT License. Comprehensive legal details are available within the repository's LICENSE file.

CLOUD COMPUTING PRINCIPLES (Derived from ISO/NIST Standards)

ISO defines cloud computing as: "a framework permitting network availability to a configurable, elastic aggregate of shared physical or virtual assets, featuring provisioning and management capabilities that operate autonomously based on immediate requirements,"

== Essential Attributes == In 2011, the U.S. National Institute of Standards and Technology (NIST) delineated five 'core characteristics' integral to cloud architectures. Below are the precise specifications from NIST:

Self-Service Provisioning: "A consumer can unilaterally procure computational resources, such as processing time or network storage capacity, as required, without requiring human intervention from the service provider for each request." Ubiquitous Network Access: "Services are accessible across the network utilizing standard communication protocols, facilitating consumption across diverse endpoint devices (e.g., smartphones, tablets, laptops, desktop workstations)." Resource Aggregation: "The provider's computing assets are pooled to serve multiple consumers under a multi-tenant paradigm, where physical and virtual assets are dynamically allocated and reallocated dynamically based on fluctuating user demands." Rapid Elasticity: "Capabilities possess the ability to scale both outwards (up) and inwards (down) swiftly, sometimes automatically, to match instantaneous load fluctuations. To the end-user, the accessible capacity often appears virtually infinite and capturable in any quantity at any moment." Usage Metering: "Cloud systems inherently manage and optimize resource consumption through integrated measurement functionality, applied at an abstraction layer suitable for the service type (e.g., bandwidth, compute cycles, storage volume, active user sessions). Utilization data is tracked, constrained, and reported, ensuring transparency for both the provider and the consuming entity." By the year 2023, the International Organization for Standardization (ISO) had expanded and refined this foundational list.

== Historical Context ==

The conceptual genesis of cloud computing traces back to the 1960s, coinciding with the popularization of time-sharing concepts via Remote Job Entry (RJE). During this epoch, the 'data center' methodology—where users submitted computational tasks to dedicated operators for execution on mainframe computers—was predominant. This era was characterized by intensive research and practical experimentation aimed at democratizing access to high-capacity computational power, optimizing infrastructure, platform layers, and application efficiency for the end-user base. The 'cloud' graphical metaphor, representing abstracted, virtualized services, originated in 1994 when it was employed by General Magic to denote the conceptual space accessible to mobile agents operating within their Telescript environment. This analogy is attributed to David Hoffman, a communications specialist at General Magic, who adapted it from its established meaning in telecommunications networking. The formal term 'cloud computing' gained broader recognition in 1996 following the drafting of a strategic business plan by Compaq Computer Corporation concerning future computing architectures and the internet. The firm's aspiration was to sup