Feishu/Lark OpenAPI MCP

English | 中文

> ⚠️ Beta Version Notice: This tool is currently in Beta stage. Features and APIs may change, so please stay updated with version releases.

This is the Feishu/Lark official OpenAPI MCP (Model Context Protocol) tool designed to help users quickly connect to the Feishu/Lark platform and enable efficient collaboration between AI Agents and Feishu/Lark. The tool encapsulates Feishu/Lark Open Platform API interfaces as MCP tools, allowing AI assistants to directly call these interfaces and implement various automation scenarios such as document processing, conversation management, calendar scheduling, and more.

Features

- Complete Feishu/Lark API Toolkit: Encapsulates almost all Feishu/Lark API interfaces, including message management, group management, document operations, calendar events, Bitable, and other core functional areas.
- Dual Authentication Support:
- Supports App Access Token authentication
- Supports User Access Token authentication
- Flexible Communication Protocols:
- Supports standard input/output stream (stdio) mode, suitable for integration with AI tools like Cursor/Claude
- Supports Server-Sent Events (SSE) mode, providing HTTP-based interfaces

- Supports multiple configuration methods, adapting to different usage scenarios

Tool List

A complete list of all supported Feishu/Lark tools can be found in tools.md, where tools are categorized by project and version with descriptions.

Preparation

Creating a Feishu/Lark Application

Before using the lark-mcp tool, you need to create a Feishu/Lark application:

1. Visit the Feishu Open Platform or Lark Open Platform and log in
2. Click "Get Started" and create a new application
3. Obtain the App ID and App Secret, which will be used for API authentication
4. Add the necessary permissions for your application based on your usage scenario
5. If you need to call APIs as a user, set up OAuth 2.0 redirect URLs and obtain user access tokens

For detailed application creation and configuration guidelines, please refer to the Feishu Open Platform Documentation - Creating an Application or the Lark Open Platform Documentation.

Installing Node.js

Before using the lark-mcp tool, you need to install the Node.js environment.

Installing Node.js on macOS

1. Using Homebrew (Recommended):

   brew install node
   

2. Using the Official Installer:
- Visit the Node.js website
- Download and install the LTS version
- After installation, verify in the terminal:

     node -v

     npm -v

     

Installing Node.js on Windows

1. Using the Official Installer:

- Visit the Node.js website
- Download and run the Windows installer (.msi file)
- Follow the installation wizard to complete the installation
- After installation, verify in the command prompt:

     node -v

     npm -v

     

2. Using nvm-windows:
- Download nvm-windows
- Install nvm-windows
- Use nvm to install Node.js:

     nvm install latest

     nvm use <version_number>

     

Installation

Install the lark-mcp tool globally:

npm install -g @larksuiteoapi/lark-mcp

Usage Guide

Using with Cursor/Claude

To integrate Feishu/Lark functionality in AI tools like Cursor or Claude, add the following to your configuration file:

{
  "mcpServers": {
    "lark-mcp": {
      "command": "npx",
      "args": [
        "-y",
        "@larksuiteoapi/lark-mcp",
        "mcp",
        "-a",
        "<your_app_id>",
        "-s",
        "<your_app_secret>"
      ]
    }
  }
}

To access APIs with user identity, you can add a user access token:

{
  "mcpServers": {
    "lark-mcp": {
     "command": "npx",
      "args": [
        "-y",
        "@larksuiteoapi/lark-mcp",
        "mcp",
        "-a",
        "<your_app_id>",
        "-s",
        "<your_app_secret>",
        "-u",
        "<your_user_token>"
      ]
    }
  }
}

Advanced Configuration

Command Line Parameters

The lark-mcp tool provides various command line parameters for flexible MCP service configuration:

| Parameter | Short | Description | Example |
|------|------|------|------|
| --app-id | -a | Feishu/Lark application App ID | -a cli_xxxx |
| --app-secret | -s | Feishu/Lark application App Secret | -s xxxx |
| --domain | -d | Feishu/Lark API domain, default is Feishu China version | -d https://open.larksuite.com |
| --tools | -t | List of API tools to enable, separated by commas | -t im.v1.message.create,im.v1.chat.create |
| --tool-name-case | -c | Tool name format, options are snake, camel, dot, or kebab, default is snake | -c camel |
| --language | -l | Tools language, options are zh or en, default is en | -l zh |
| --user-access-token | -u | User access token for calling APIs as a user | -u u-xxxx |
| --mode | -m | Transport mode, options are stdio or sse, default is stdio | -m sse |
| --host | | Listening host in SSE mode, default is localhost | --host 0.0.0.0 |
| --port | -p | Listening port in SSE mode, default is 3000 | -p 3000 |
| --config | | Configuration file path, supports JSON format | --config ./config.json |
| --version | -V | Display version number | -V |
| --help | -h | Display help information | -h |

Parameter Usage Examples

1. Basic Usage (using application identity):

   lark-mcp mcp -a cli_xxxx -s yyyyy

   

2. Using User Identity:

   lark-mcp mcp -a cli_xxxx -s yyyyy -u u-zzzz

   

3. Specifying Lark International Domain:

   lark-mcp mcp -a cli_xxxx -s yyyyy -d https://open.larksuite.com

   

4. Enabling Only Specific API Tools:

   lark-mcp mcp -a cli_xxxx -s yyyyy -t im.v1.chat.create,im.v1.message.create

   

5. Using SSE Mode with Specific Port and Host:

   lark-mcp mcp -a cli_xxxx -s yyyyy -m sse --host 0.0.0.0 -p 3000

   

6. Setting Tools Language to Chinese:

   lark-mcp mcp -a cli_xxxx -s yyyyy -l zh

   

7. Setting Tool Name Format to Camel Case:

   lark-mcp mcp -a cli_xxxx -s yyyyy -c camel

   

8. Using Environment Variables Instead of Command Line Parameters:

   # Set environment variables

   export APP_ID=cli_xxxx

   export APP_SECRET=yyyyy

   

   # Start the service (no need to specify -a and -s parameters)

   lark-mcp mcp

   

Using Configuration File

Besides command line parameters, you can also use a JSON format configuration file to set parameters:

lark-mcp mcp --config ./config.json

Configuration file example (config.json):

{
  "appId": "cli_xxxx",
  "appSecret": "xxxx",
  "domain": "https://open.feishu.cn",
  "tools": ["im.v1.message.create","im.v1.chat.create"],
  "toolNameCase": "snake",
  "language": "zh",
  "userAccessToken": "",
  "mode": "stdio",
  "host": "localhost",
  "port": "3000"
}

> Note: Command line parameters have higher priority than configuration file. When using both command line parameters and configuration file, command line parameters will override corresponding settings in the configuration file.

Using User Access Token

If you need to call APIs as a specific user, you can do so by specifying a User Access Token:

lark-mcp mcp -a <your_app_id> -s <your_app_secret> -u <your_user_token>

User access tokens can be obtained through the Feishu Open Platform's authorization process or Lark Open Platform's authorization process, or you can use the API debugging console to obtain them. After using a user access token, API calls will be made with that user's identity.

Specifying Custom Domains

If you are using the Lark international version or a custom domain, you can specify it using the -d parameter:

```bash